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.Assert.assertNull;
24 import static org.testng.AssertJUnit.assertEquals;
25 import static org.testng.AssertJUnit.assertFalse;
26 import static org.testng.AssertJUnit.assertTrue;
28 import jalview.analysis.AlignmentGenerator;
29 import jalview.util.Comparison;
31 import java.util.Arrays;
32 import java.util.BitSet;
33 import java.util.Iterator;
34 import java.util.Random;
36 import org.testng.annotations.Test;
38 public class HiddenColumnsTest
41 * Test the method which counts the number of hidden columns
43 @Test(groups = { "Functional" })
44 public void testGetSize()
46 HiddenColumns hidden = new HiddenColumns();
47 assertEquals(0, hidden.getSize());
49 hidden.hideColumns(3, 5);
50 assertEquals(3, hidden.getSize());
52 hidden.hideColumns(8, 8);
53 assertEquals(4, hidden.getSize());
55 hidden.hideColumns(9, 14);
56 assertEquals(10, hidden.getSize());
58 ColumnSelection cs = new ColumnSelection();
59 hidden.revealAllHiddenColumns(cs);
60 assertEquals(0, hidden.getSize());
64 * Test the method that finds the visible column position of an alignment
65 * column, allowing for hidden columns.
67 @Test(groups = { "Functional" })
68 public void testFindColumnPosition()
70 HiddenColumns cs = new HiddenColumns();
71 assertEquals(5, cs.findColumnPosition(5));
73 // hiding column 6 makes no difference
75 assertEquals(5, cs.findColumnPosition(5));
77 // hiding column 4 moves column 5 to column 4
79 assertEquals(4, cs.findColumnPosition(5));
81 // hiding column 4 moves column 4 to position 3
82 assertEquals(3, cs.findColumnPosition(4));
84 // hiding columns 1 and 2 moves column 5 to column 2
86 assertEquals(2, cs.findColumnPosition(5));
88 // check with > 1 hidden column regions
89 // where some columns are in the hidden regions
90 HiddenColumns cs2 = new HiddenColumns();
91 cs2.hideColumns(5, 10);
92 cs2.hideColumns(20, 27);
93 cs2.hideColumns(40, 44);
95 // hiding columns 5-10 and 20-27 moves column 8 to column 4
96 assertEquals(4, cs2.findColumnPosition(8));
98 // and moves column 24 to 13
99 assertEquals(13, cs2.findColumnPosition(24));
101 // and moves column 28 to 14
102 assertEquals(14, cs2.findColumnPosition(28));
104 // and moves column 40 to 25
105 assertEquals(25, cs2.findColumnPosition(40));
107 // check when hidden columns start at 0 that the visible column
109 HiddenColumns cs3 = new HiddenColumns();
110 cs3.hideColumns(0, 4);
111 assertEquals(0, cs3.findColumnPosition(2));
113 // check that column after the last hidden region doesn't crash
114 assertEquals(46, cs2.findColumnPosition(65));
117 @Test(groups = { "Functional" })
118 public void testVisibleContigsIterator()
120 HiddenColumns cs = new HiddenColumns();
122 Iterator<int[]> visible = cs.getVisContigsIterator(3, 10, false);
123 int[] region = visible.next();
124 assertEquals("[3, 9]", Arrays.toString(region));
125 assertFalse(visible.hasNext());
127 cs.hideColumns(3, 6);
128 cs.hideColumns(8, 9);
129 cs.hideColumns(12, 12);
131 // Test both ends visible region
133 // start position is inclusive, end position exclusive
134 visible = cs.getVisContigsIterator(1, 13, false);
135 region = visible.next();
136 assertEquals("[1, 2]", Arrays.toString(region));
137 region = visible.next();
138 assertEquals("[7, 7]", Arrays.toString(region));
139 region = visible.next();
140 assertEquals("[10, 11]", Arrays.toString(region));
141 assertFalse(visible.hasNext());
143 // Test start hidden, end visible
144 visible = cs.getVisContigsIterator(4, 14, false);
145 region = visible.next();
146 assertEquals("[7, 7]", Arrays.toString(region));
147 region = visible.next();
148 assertEquals("[10, 11]", Arrays.toString(region));
149 region = visible.next();
150 assertEquals("[13, 13]", Arrays.toString(region));
151 assertFalse(visible.hasNext());
153 // Test start hidden, end hidden
154 visible = cs.getVisContigsIterator(3, 10, false);
155 region = visible.next();
156 assertEquals("[7, 7]", Arrays.toString(region));
157 assertFalse(visible.hasNext());
159 // Test start visible, end hidden
160 visible = cs.getVisContigsIterator(0, 13, false);
161 region = visible.next();
162 assertEquals("[0, 2]", Arrays.toString(region));
163 region = visible.next();
164 assertEquals("[7, 7]", Arrays.toString(region));
165 region = visible.next();
166 assertEquals("[10, 11]", Arrays.toString(region));
167 assertFalse(visible.hasNext());
170 visible = cs.getVisContigsIterator(4, 6, false);
171 assertFalse(visible.hasNext());
174 @Test(groups = { "Functional" })
175 public void testEquals()
177 HiddenColumns cs = new HiddenColumns();
178 cs.hideColumns(5, 9);
180 // a different set of hidden columns
181 HiddenColumns cs2 = new HiddenColumns();
183 // with no hidden columns
184 assertFalse(cs.equals(cs2));
185 assertFalse(cs2.equals(cs));
187 // with the wrong kind of object
188 assertFalse(cs.equals(new HiddenColumnsCursor()));
190 // with a different hiddenColumns object - by size
191 HiddenColumns cs3 = new HiddenColumns();
192 cs3.hideColumns(2, 3);
193 assertFalse(cs.equals(cs3));
195 // with hidden columns added in a different order
196 cs2.hideColumns(6, 9);
197 assertFalse(cs.equals(cs2));
198 assertFalse(cs2.equals(cs));
200 cs2.hideColumns(5, 8);
202 assertTrue(cs.equals(cs2));
203 assertTrue(cs.equals(cs));
204 assertTrue(cs2.equals(cs));
205 assertTrue(cs2.equals(cs2));
207 // different ranges, same size
208 cs.hideColumns(10, 12);
209 cs2.hideColumns(10, 15);
210 assertFalse(cs.equals(cs2));
214 @Test(groups = "Functional")
215 public void testCopyConstructor()
217 HiddenColumns cs = new HiddenColumns();
218 cs.hideColumns(10, 11);
219 cs.hideColumns(5, 7);
220 Iterator<int[]> regions = cs.iterator();
221 assertEquals("[5, 7]",
222 Arrays.toString(regions.next()));
224 HiddenColumns cs2 = new HiddenColumns(cs);
225 regions = cs2.iterator();
226 assertTrue(cs2.hasHiddenColumns());
227 assertEquals(2, cs2.getNumberOfRegions());
228 // hidden columns are held in column order
229 assertEquals("[5, 7]",
230 Arrays.toString(regions.next()));
231 assertEquals("[10, 11]",
232 Arrays.toString(regions.next()));
235 @Test(groups = "Functional")
236 public void testCopyConstructor2()
238 HiddenColumns cs = new HiddenColumns();
239 cs.hideColumns(10, 11);
240 cs.hideColumns(5, 7);
242 HiddenColumns cs2 = new HiddenColumns(cs, 3, 9, 1);
243 assertTrue(cs2.hasHiddenColumns());
244 Iterator<int[]> regions = cs2.iterator();
246 // only [5,7] returned, offset by 1
247 assertEquals("[4, 6]",
248 Arrays.toString(regions.next()));
249 assertEquals(3, cs2.getSize());
251 cs2 = new HiddenColumns(cs, 8, 15, 4);
252 regions = cs2.iterator();
253 assertTrue(cs2.hasHiddenColumns());
255 // only [10,11] returned, offset by 4
256 assertEquals("[6, 7]",
257 Arrays.toString(regions.next()));
258 assertEquals(2, cs2.getSize());
260 cs2 = new HiddenColumns(cs, 6, 10, 4);
261 assertFalse(cs2.hasHiddenColumns());
265 * Test the code used to locate the reference sequence ruler origin
267 @Test(groups = { "Functional" })
268 public void testLocateVisibleStartofSequence()
270 // create random alignment
271 AlignmentGenerator gen = new AlignmentGenerator(false);
272 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
274 HiddenColumns cs = al.getHiddenColumns();
275 ColumnSelection colsel = new ColumnSelection();
277 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
278 assertEquals(2, seq.findIndex(seq.getStart()));
281 assertEquals(seq.findIndex(seq.getStart()) - 1, cs.locateVisibleStartOfSequence(seq));
283 // hidden column on gap after end of sequence - should not affect bounds
284 colsel.hideSelectedColumns(13, al.getHiddenColumns());
285 assertEquals(seq.findIndex(seq.getStart()) - 1,cs.locateVisibleStartOfSequence(seq));
287 cs.revealAllHiddenColumns(colsel);
288 // hidden column on gap before beginning of sequence - should vis bounds by
290 colsel.hideSelectedColumns(0, al.getHiddenColumns());
291 assertEquals(seq.findIndex(seq.getStart()) - 2,cs.locateVisibleStartOfSequence(seq));
293 cs.revealAllHiddenColumns(colsel);
294 // hide columns around most of sequence - leave one residue remaining
295 cs.hideColumns(1, 3);
296 cs.hideColumns(6, 11);
298 cs.getVisibleSequenceStrings(0, 5, new SequenceI[]
301 assertEquals(1, cs.locateVisibleStartOfSequence(seq));
302 cs.revealAllHiddenColumns(colsel);
304 // hide whole sequence - should just get location of hidden region
305 // containing sequence
306 cs.hideColumns(1, 11);
307 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
309 cs.revealAllHiddenColumns(colsel);
310 cs.hideColumns(0, 15);
311 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
313 SequenceI seq2 = new Sequence("RefSeq2", "-------A-SD-ASD--E---");
315 cs.revealAllHiddenColumns(colsel);
316 cs.hideColumns(7, 17);
317 assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
319 cs.revealAllHiddenColumns(colsel);
320 cs.hideColumns(3, 17);
321 assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
323 cs.revealAllHiddenColumns(colsel);
324 cs.hideColumns(3, 19);
325 assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
327 cs.revealAllHiddenColumns(colsel);
328 cs.hideColumns(0, 0);
329 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
331 cs.revealAllHiddenColumns(colsel);
332 cs.hideColumns(0, 1);
333 assertEquals(1,cs.locateVisibleStartOfSequence(seq));
335 cs.revealAllHiddenColumns(colsel);
336 cs.hideColumns(0, 2);
337 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
339 cs.revealAllHiddenColumns(colsel);
340 cs.hideColumns(1, 1);
341 assertEquals(2,cs.locateVisibleStartOfSequence(seq));
343 cs.revealAllHiddenColumns(colsel);
344 cs.hideColumns(1, 2);
345 assertEquals(1,cs.locateVisibleStartOfSequence(seq));
347 cs.revealAllHiddenColumns(colsel);
348 cs.hideColumns(1, 3);
349 assertEquals(1,cs.locateVisibleStartOfSequence(seq));
351 cs.revealAllHiddenColumns(colsel);
352 cs.hideColumns(0, 2);
353 cs.hideColumns(5, 6);
354 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
356 cs.revealAllHiddenColumns(colsel);
357 cs.hideColumns(0, 2);
358 cs.hideColumns(5, 6);
359 cs.hideColumns(9, 10);
360 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
362 cs.revealAllHiddenColumns(colsel);
363 cs.hideColumns(0, 2);
364 cs.hideColumns(7, 11);
365 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
367 cs.revealAllHiddenColumns(colsel);
368 cs.hideColumns(2, 4);
369 cs.hideColumns(7, 11);
370 assertEquals(1,cs.locateVisibleStartOfSequence(seq));
372 cs.revealAllHiddenColumns(colsel);
373 cs.hideColumns(2, 4);
374 cs.hideColumns(7, 12);
375 assertEquals(1,cs.locateVisibleStartOfSequence(seq));
377 cs.revealAllHiddenColumns(colsel);
378 cs.hideColumns(1, 11);
379 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
381 cs.revealAllHiddenColumns(colsel);
382 cs.hideColumns(0, 12);
383 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
385 cs.revealAllHiddenColumns(colsel);
386 cs.hideColumns(0, 4);
387 cs.hideColumns(6, 12);
388 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
390 cs.revealAllHiddenColumns(colsel);
391 cs.hideColumns(0, 1);
392 cs.hideColumns(3, 12);
393 assertEquals(0,cs.locateVisibleStartOfSequence(seq));
395 cs.revealAllHiddenColumns(colsel);
396 cs.hideColumns(3, 14);
397 cs.hideColumns(17, 19);
398 assertEquals(3,cs.locateVisibleStartOfSequence(seq2));
400 cs.revealAllHiddenColumns(colsel);
401 cs.hideColumns(3, 7);
402 cs.hideColumns(9, 14);
403 cs.hideColumns(17, 19);
404 assertEquals(9,cs.locateVisibleStartOfSequence(seq2));
406 cs.revealAllHiddenColumns(colsel);
407 cs.hideColumns(0, 1);
408 cs.hideColumns(3, 4);
409 cs.hideColumns(6, 8);
410 cs.hideColumns(10, 12);
411 assertEquals(6, cs.locateVisibleStartOfSequence(seq));
415 @Test(groups = { "Functional" })
416 public void testLocateVisibleStartPathologicals()
418 // test some pathological cases we missed
419 AlignmentI al = new Alignment(
421 { new Sequence("refseqGaptest", "KTDVTI----------NFI-----G----L") });
422 HiddenColumns cs = new HiddenColumns();
423 cs.hideInsertionsFor(al.getSequenceAt(0));
425 + al.getSequenceAt(0).getCharAt(cs.adjustForHiddenColumns(9)));
427 // KM: no idea what this is meant to be testing... seems to be an unfinished
431 @Test(groups = { "Functional" })
432 public void testHideColumns()
434 // create random alignment
435 AlignmentGenerator gen = new AlignmentGenerator(false);
436 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
438 ColumnSelection colsel = new ColumnSelection();
439 HiddenColumns cs = al.getHiddenColumns();
440 colsel.hideSelectedColumns(5, al.getHiddenColumns());
441 Iterator<int[]> regions = cs.iterator();
442 assertEquals(1, cs.getNumberOfRegions());
443 assertEquals("[5, 5]", Arrays.toString(regions.next()));
445 colsel.hideSelectedColumns(3, al.getHiddenColumns());
446 regions = cs.iterator();
447 assertEquals(2, cs.getNumberOfRegions());
448 // two hidden ranges, in order:
449 assertEquals("[3, 3]", Arrays.toString(regions.next()));
450 assertEquals("[5, 5]", Arrays.toString(regions.next()));
452 // hiding column 4 expands [3, 3] to [3, 4]
453 // and merges to [5, 5] to make [3, 5]
454 colsel.hideSelectedColumns(4, al.getHiddenColumns());
455 regions = cs.iterator();
456 assertEquals(1, cs.getNumberOfRegions());
457 assertEquals("[3, 5]", Arrays.toString(regions.next()));
459 // clear hidden columns (note they are added to selected)
460 cs.revealAllHiddenColumns(colsel);
461 // it is now actually null but getter returns an empty list
462 assertEquals(0, cs.getNumberOfRegions());
464 cs.hideColumns(3, 6);
465 regions = cs.iterator();
466 int[] firstHiddenRange = regions.next();
467 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
469 // adding a subrange of already hidden should do nothing
470 cs.hideColumns(4, 5);
471 regions = cs.iterator();
472 assertEquals(1, cs.getNumberOfRegions());
473 assertEquals("[3, 6]",
474 Arrays.toString(regions.next()));
475 cs.hideColumns(3, 5);
476 regions = cs.iterator();
477 assertEquals(1, cs.getNumberOfRegions());
478 assertEquals("[3, 6]",
479 Arrays.toString(regions.next()));
480 cs.hideColumns(4, 6);
481 regions = cs.iterator();
482 assertEquals(1, cs.getNumberOfRegions());
483 assertEquals("[3, 6]",
484 Arrays.toString(regions.next()));
485 cs.hideColumns(3, 6);
486 regions = cs.iterator();
487 assertEquals(1, cs.getNumberOfRegions());
488 assertEquals("[3, 6]",
489 Arrays.toString(regions.next()));
491 cs.revealAllHiddenColumns(colsel);
492 cs.hideColumns(2, 4);
493 regions = cs.iterator();
494 assertEquals(1, cs.getNumberOfRegions());
495 assertEquals("[2, 4]", Arrays.toString(regions.next()));
497 // extend contiguous with 2 positions overlap
498 cs.hideColumns(3, 5);
499 regions = cs.iterator();
500 assertEquals(1, cs.getNumberOfRegions());
501 assertEquals("[2, 5]", Arrays.toString(regions.next()));
503 // extend contiguous with 1 position overlap
504 cs.hideColumns(5, 6);
505 regions = cs.iterator();
506 assertEquals(1, cs.getNumberOfRegions());
507 assertEquals("[2, 6]", Arrays.toString(regions.next()));
509 // extend contiguous with overlap both ends:
510 cs.hideColumns(1, 7);
511 regions = cs.iterator();
512 assertEquals(1, cs.getNumberOfRegions());
513 assertEquals("[1, 7]", Arrays.toString(regions.next()));
517 * Test the method that reveals a range of hidden columns given the start
518 * column of the range
520 @Test(groups = { "Functional" })
521 public void testRevealHiddenColumns()
523 ColumnSelection colsel = new ColumnSelection();
524 HiddenColumns cs = new HiddenColumns();
526 // test with null hidden columns
527 cs.revealHiddenColumns(5, colsel);
528 assertTrue(colsel.getSelected().isEmpty());
530 cs.hideColumns(5, 8);
531 colsel.addElement(10);
532 cs.revealHiddenColumns(5, colsel);
534 // hiddenColumns now empty
535 assertEquals(0, cs.getSize());
537 // revealed columns are marked as selected (added to selection):
538 assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
540 // calling with a column other than the range start does nothing:
541 colsel = new ColumnSelection();
542 cs = new HiddenColumns();
543 cs.hideColumns(5, 8);
545 int prevSize = cs.getSize();
546 cs.revealHiddenColumns(6, colsel);
547 assertEquals(prevSize, cs.getSize());
548 assertTrue(colsel.getSelected().isEmpty());
550 // reveal hidden columns when there is more than one region
551 cs.hideColumns(20, 23);
552 // now there are 2 hidden regions
553 assertEquals(2, cs.getNumberOfRegions());
555 cs.revealHiddenColumns(20, colsel);
557 // hiddenColumns now has one region
558 assertEquals(1, cs.getNumberOfRegions());
560 // revealed columns are marked as selected (added to selection):
561 assertEquals("[20, 21, 22, 23]", colsel.getSelected().toString());
563 // call with a column past the end of the hidden column ranges
565 cs.revealHiddenColumns(20, colsel);
566 // hiddenColumns still has 1 region
567 assertEquals(1, cs.getNumberOfRegions());
568 assertTrue(colsel.getSelected().isEmpty());
571 @Test(groups = { "Functional" })
572 public void testRevealAllHiddenColumns()
574 HiddenColumns hidden = new HiddenColumns();
575 ColumnSelection colsel = new ColumnSelection();
577 // test with null hidden columns
578 hidden.revealAllHiddenColumns(colsel);
579 assertTrue(colsel.getSelected().isEmpty());
581 hidden.hideColumns(5, 8);
582 hidden.hideColumns(2, 3);
583 colsel.addElement(11);
584 colsel.addElement(1);
585 hidden.revealAllHiddenColumns(colsel);
588 * revealing hidden columns adds them (in order) to the (unordered)
592 // hiddenColumns now empty
593 assertEquals(0, hidden.getSize());
595 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]",
596 colsel.getSelected().toString());
599 @Test(groups = { "Functional" })
600 public void testIsVisible()
602 HiddenColumns cs = new HiddenColumns();
603 cs.hideColumns(2, 4);
604 cs.hideColumns(6, 7);
605 assertTrue(cs.isVisible(0));
606 assertTrue(cs.isVisible(-99));
607 assertTrue(cs.isVisible(1));
608 assertFalse(cs.isVisible(2));
609 assertFalse(cs.isVisible(3));
610 assertFalse(cs.isVisible(4));
611 assertTrue(cs.isVisible(5));
612 assertFalse(cs.isVisible(6));
613 assertFalse(cs.isVisible(7));
617 * Test for the case when a hidden range encloses more one already hidden
620 @Test(groups = { "Functional" })
621 public void testHideColumns_subsumingHidden()
624 * JAL-2370 bug scenario:
625 * two hidden ranges subsumed by a third
627 HiddenColumns cs = new HiddenColumns();
628 cs.hideColumns(49, 59);
629 cs.hideColumns(69, 79);
630 Iterator<int[]> regions = cs.iterator();
631 assertEquals(2, cs.getNumberOfRegions());
632 assertEquals("[49, 59]", Arrays.toString(regions.next()));
633 assertEquals("[69, 79]", Arrays.toString(regions.next()));
635 cs.hideColumns(48, 80);
636 regions = cs.iterator();
637 assertEquals(1, cs.getNumberOfRegions());
638 assertEquals("[48, 80]", Arrays.toString(regions.next()));
641 * another...joining hidden ranges
643 cs = new HiddenColumns();
644 cs.hideColumns(10, 20);
645 cs.hideColumns(30, 40);
646 cs.hideColumns(50, 60);
647 // hiding 21-49 should merge to one range
648 cs.hideColumns(21, 49);
649 regions = cs.iterator();
650 assertEquals(1, cs.getNumberOfRegions());
651 assertEquals("[10, 60]", Arrays.toString(regions.next()));
654 * another...left overlap, subsumption, right overlap,
655 * no overlap of existing hidden ranges
657 cs = new HiddenColumns();
658 cs.hideColumns(10, 20);
659 cs.hideColumns(10, 20);
660 cs.hideColumns(30, 35);
661 cs.hideColumns(40, 50);
662 cs.hideColumns(60, 70);
664 cs.hideColumns(15, 45);
665 regions = cs.iterator();
666 assertEquals(2, cs.getNumberOfRegions());
667 assertEquals("[10, 50]", Arrays.toString(regions.next()));
668 assertEquals("[60, 70]", Arrays.toString(regions.next()));
671 @Test(groups = { "Functional" })
672 public void testHideBitset()
676 BitSet one = new BitSet();
680 cs = new HiddenColumns();
681 cs.hideMarkedBits(one);
682 assertEquals(1, cs.getNumberOfRegions());
685 cs = new HiddenColumns();
686 cs.hideMarkedBits(one);
687 assertEquals(1, cs.getNumberOfRegions());
690 cs = new HiddenColumns();
691 cs.hideMarkedBits(one);
692 assertEquals(1, cs.getNumberOfRegions());
696 cs = new HiddenColumns();
697 cs.hideMarkedBits(one);
698 assertEquals(2, cs.getNumberOfRegions());
700 assertEquals(0, cs.adjustForHiddenColumns(0));
701 assertEquals(2, cs.adjustForHiddenColumns(1));
702 assertEquals(4, cs.adjustForHiddenColumns(2));
706 cs = new HiddenColumns();
707 cs.hideMarkedBits(one);
709 assertEquals(1, cs.getNumberOfRegions());
711 assertEquals(0, cs.adjustForHiddenColumns(0));
712 assertEquals(1, cs.adjustForHiddenColumns(1));
713 assertEquals(2, cs.adjustForHiddenColumns(2));
714 assertEquals(4, cs.adjustForHiddenColumns(3));
717 @Test(groups = { "Functional" })
718 public void testMarkHiddenRegions()
720 BitSet toMark, fromMark;
721 long seed = -3241532;
722 Random number = new Random(seed);
723 for (int n = 0; n < 1000; n++)
725 // create a random bitfield
728 { number.nextLong(), number.nextLong(), number.nextLong() });
729 toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25)));
730 HiddenColumns hc = new HiddenColumns();
734 hc.markHiddenRegions(fromMark = new BitSet());
735 assertTrue(fromMark.isEmpty());
738 hc.hideMarkedBits(toMark);
740 // see if we can recover bitfield
741 hc.markHiddenRegions(fromMark = new BitSet());
742 assertEquals(toMark, fromMark);
746 @Test(groups = { "Functional" })
747 public void testRegionsToString()
749 HiddenColumns hc = new HiddenColumns();
751 String result = hc.regionsToString(",", "--");
752 assertEquals("", result);
754 hc.hideColumns(3, 7);
755 hc.hideColumns(10, 10);
756 hc.hideColumns(14, 15);
758 result = hc.regionsToString(",", "--");
759 assertEquals("3--7,10--10,14--15", result);
762 @Test(groups = "Functional")
763 public void testGetVisibleStartAndEndIndexTest()
765 Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
766 AlignmentI align = new Alignment(new SequenceI[] { seq });
767 HiddenColumns hc = new HiddenColumns();
769 int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
770 assertEquals(0, startEnd[0]);
771 assertEquals(25, startEnd[1]);
773 hc.hideColumns(0, 0);
774 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
775 assertEquals(1, startEnd[0]);
776 assertEquals(25, startEnd[1]);
778 hc.hideColumns(6, 9);
779 hc.hideColumns(11, 12);
780 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
781 assertEquals(1, startEnd[0]);
782 assertEquals(25, startEnd[1]);
784 hc.hideColumns(24, 25);
785 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
786 System.out.println(startEnd[0] + " : " + startEnd[1]);
787 assertEquals(1, startEnd[0]);
788 assertEquals(23, startEnd[1]);
790 // force lowest range to start of alignment
791 hc = new HiddenColumns();
792 hc.hideColumns(3, 4);
793 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
794 assertEquals(0, startEnd[0]);
795 assertEquals(25, startEnd[1]);
798 @Test(groups = "Functional")
799 public void testGetRegionWithEdgeAtRes()
801 HiddenColumns hc = new HiddenColumns();
803 int[] result = hc.getRegionWithEdgeAtRes(5);
806 hc.hideColumns(3, 7);
807 hc.hideColumns(10, 10);
808 hc.hideColumns(14, 15);
810 result = hc.getRegionWithEdgeAtRes(2);
811 assertEquals(3, result[0]);
812 assertEquals(7, result[1]);
814 result = hc.getRegionWithEdgeAtRes(4);
815 assertEquals(10, result[0]);
816 assertEquals(10, result[1]);
818 result = hc.getRegionWithEdgeAtRes(5);
819 assertEquals(10, result[0]);
820 assertEquals(10, result[1]);
822 result = hc.getRegionWithEdgeAtRes(6);
825 result = hc.getRegionWithEdgeAtRes(0);
828 result = hc.getRegionWithEdgeAtRes(7);
829 assertEquals(14, result[0]);
830 assertEquals(15, result[1]);
832 result = hc.getRegionWithEdgeAtRes(8);
833 assertEquals(14, result[0]);
834 assertEquals(15, result[1]);
836 result = hc.getRegionWithEdgeAtRes(16);
840 @Test(groups = "Functional")
841 public void testPropagateInsertions()
843 // create an alignment with no gaps - this will be the profile seq and other
845 AlignmentGenerator gen = new AlignmentGenerator(false);
846 AlignmentI al = gen.generate(25, 10, 1234, 0, 0);
848 // get the profileseq
849 SequenceI profileseq = al.getSequenceAt(0);
850 SequenceI gappedseq = new Sequence(profileseq);
851 gappedseq.insertCharAt(5, al.getGapCharacter());
852 gappedseq.insertCharAt(6, al.getGapCharacter());
853 gappedseq.insertCharAt(7, al.getGapCharacter());
854 gappedseq.insertCharAt(8, al.getGapCharacter());
856 // force different kinds of padding
857 al.getSequenceAt(3).deleteChars(2, 23);
858 al.getSequenceAt(4).deleteChars(2, 27);
859 al.getSequenceAt(5).deleteChars(10, 27);
861 // create an alignment view with the gapped sequence
862 SequenceI[] seqs = new SequenceI[1];
864 AlignmentI newal = new Alignment(seqs);
865 HiddenColumns hidden = new HiddenColumns();
866 hidden.hideColumns(15, 17);
868 AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
871 // confirm that original contigs are as expected
872 Iterator<int[]> visible = hidden.getVisContigsIterator(0, 25, false);
873 int[] region = visible.next();
874 assertEquals("[0, 14]", Arrays.toString(region));
875 region = visible.next();
876 assertEquals("[18, 24]", Arrays.toString(region));
878 // propagate insertions
879 HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
882 // confirm that the contigs have changed to account for the gaps
883 visible = result.getVisContigsIterator(0, 25, false);
884 region = visible.next();
885 assertEquals("[0, 10]", Arrays.toString(region));
886 region = visible.next();
887 assertEquals("[14, 24]", Arrays.toString(region));
889 // confirm the alignment has been changed so that the other sequences have
890 // gaps inserted where the columns are hidden
891 assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[10]));
892 assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[11]));
893 assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[12]));
894 assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[13]));
895 assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[14]));
899 @Test(groups = "Functional")
900 public void testPropagateInsertionsOverlap()
902 // test propagateInsertions where gaps and hiddenColumns overlap
904 // create an alignment with no gaps - this will be the profile seq and other
906 AlignmentGenerator gen = new AlignmentGenerator(false);
907 AlignmentI al = gen.generate(20, 10, 1234, 0, 0);
909 // get the profileseq
910 SequenceI profileseq = al.getSequenceAt(0);
911 SequenceI gappedseq = new Sequence(profileseq);
912 gappedseq.insertCharAt(5, al.getGapCharacter());
913 gappedseq.insertCharAt(6, al.getGapCharacter());
914 gappedseq.insertCharAt(7, al.getGapCharacter());
915 gappedseq.insertCharAt(8, al.getGapCharacter());
917 // create an alignment view with the gapped sequence
918 SequenceI[] seqs = new SequenceI[1];
920 AlignmentI newal = new Alignment(seqs);
922 // hide columns so that some overlap with the gaps
923 HiddenColumns hidden = new HiddenColumns();
924 hidden.hideColumns(7, 10);
926 AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
929 // confirm that original contigs are as expected
930 Iterator<int[]> visible = hidden.getVisContigsIterator(0, 20, false);
931 int[] region = visible.next();
932 assertEquals("[0, 6]", Arrays.toString(region));
933 region = visible.next();
934 assertEquals("[11, 19]", Arrays.toString(region));
935 assertFalse(visible.hasNext());
937 // propagate insertions
938 HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
941 // confirm that the contigs have changed to account for the gaps
942 visible = result.getVisContigsIterator(0, 20, false);
943 region = visible.next();
944 assertEquals("[0, 4]", Arrays.toString(region));
945 region = visible.next();
946 assertEquals("[7, 19]", Arrays.toString(region));
947 assertFalse(visible.hasNext());
949 // confirm the alignment has been changed so that the other sequences have
950 // gaps inserted where the columns are hidden
951 assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[4]));
952 assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[5]));
953 assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[6]));
954 assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[7]));
957 @Test(groups = "Functional")
958 public void testHasHiddenColumns()
960 HiddenColumns h = new HiddenColumns();
962 // new HiddenColumns2 has no hidden cols
963 assertFalse(h.hasHiddenColumns());
965 // some columns hidden, returns true
966 h.hideColumns(5, 10);
967 assertTrue(h.hasHiddenColumns());
969 // reveal columns, no hidden cols again
970 ColumnSelection sel = new ColumnSelection();
971 h.revealAllHiddenColumns(sel);
972 assertFalse(h.hasHiddenColumns());
975 @Test(groups = "Functional")
976 public void testHasManyHiddenColumns()
978 HiddenColumns h = new HiddenColumns();
980 // new HiddenColumns2 has no hidden cols
981 assertFalse(h.hasManyHiddenColumns());
983 // one set of columns hidden, returns false
984 h.hideColumns(5, 10);
985 assertFalse(h.hasManyHiddenColumns());
987 // two sets hidden, returns true
988 h.hideColumns(15, 17);
989 assertTrue(h.hasManyHiddenColumns());
991 // back to one block, asserts false
992 h.hideColumns(11, 14);
993 assertFalse(h.hasManyHiddenColumns());
996 @Test(groups = "Functional")
997 public void testAdjustForHiddenColumns()
999 HiddenColumns h = new HiddenColumns();
1000 // returns input value when there are no hidden columns
1001 assertEquals(10, h.adjustForHiddenColumns(10));
1003 h.hideColumns(20, 30);
1004 assertEquals(10, h.adjustForHiddenColumns(10));
1005 assertEquals(20 + 11, h.adjustForHiddenColumns(20));
1006 assertEquals(35 + 11, h.adjustForHiddenColumns(35));
1008 h.hideColumns(5, 7);
1009 assertEquals(10 + 3, h.adjustForHiddenColumns(10));
1010 assertEquals(20 + 14, h.adjustForHiddenColumns(20));
1011 assertEquals(35 + 14, h.adjustForHiddenColumns(35));
1013 ColumnSelection sel = new ColumnSelection();
1014 h.revealAllHiddenColumns(sel);
1015 h.hideColumns(0, 1);
1016 assertEquals(4, h.adjustForHiddenColumns(2));
1019 @Test(groups = "Functional")
1020 public void testGetHiddenBoundaryLeft()
1022 HiddenColumns h = new HiddenColumns();
1024 // returns same value if no hidden cols
1025 assertEquals(3, h.getHiddenBoundaryLeft(3));
1027 h.hideColumns(5, 10);
1028 assertEquals(10, h.getHiddenBoundaryLeft(15));
1029 assertEquals(3, h.getHiddenBoundaryLeft(3));
1030 assertEquals(7, h.getHiddenBoundaryLeft(7));
1032 h.hideColumns(15, 20);
1033 assertEquals(10, h.getHiddenBoundaryLeft(15));
1034 assertEquals(20, h.getHiddenBoundaryLeft(21));
1037 @Test(groups = "Functional")
1038 public void testGetHiddenBoundaryRight()
1040 HiddenColumns h = new HiddenColumns();
1042 // returns same value if no hidden cols
1043 assertEquals(3, h.getHiddenBoundaryRight(3));
1045 h.hideColumns(5, 10);
1046 assertEquals(5, h.getHiddenBoundaryRight(3));
1047 assertEquals(15, h.getHiddenBoundaryRight(15));
1048 assertEquals(7, h.getHiddenBoundaryRight(7));
1050 h.hideColumns(15, 20);
1051 assertEquals(15, h.getHiddenBoundaryRight(7));
1052 assertEquals(15, h.getHiddenBoundaryRight(14));
1055 @Test(groups = "Functional")
1056 public void testIterator()
1058 HiddenColumns h = new HiddenColumns();
1059 Iterator<int[]> result = h.iterator();
1060 assertFalse(result.hasNext());
1062 h.hideColumns(5, 10);
1063 result = h.iterator();
1064 int[] next = result.next();
1065 assertEquals(5, next[0]);
1066 assertEquals(10, next[1]);
1067 assertFalse(result.hasNext());
1069 h.hideColumns(22, 23);
1070 result = h.iterator();
1071 next = result.next();
1072 assertEquals(5, next[0]);
1073 assertEquals(10, next[1]);
1074 next = result.next();
1075 assertEquals(22, next[0]);
1076 assertEquals(23, next[1]);
1077 assertFalse(result.hasNext());
1079 // test for only one hidden region at start of alignment
1080 ColumnSelection sel = new ColumnSelection();
1081 h.revealAllHiddenColumns(sel);
1082 h.hideColumns(0, 1);
1083 result = h.iterator();
1084 next = result.next();
1085 assertEquals(0, next[0]);
1086 assertEquals(1, next[1]);
1087 assertFalse(result.hasNext());
1090 @Test(groups = "Functional")
1091 public void testGetVisibleSequenceStrings()
1093 HiddenColumns h = new HiddenColumns();
1094 SequenceI seq1 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
1095 SequenceI seq2 = new Sequence("TEST2", "VICYHRNDTGA");
1096 SequenceI[] seqs = new SequenceI[2];
1099 String[] result = h.getVisibleSequenceStrings(5, 10, seqs);
1100 assertEquals(2, result.length);
1101 assertEquals("WKQES", result[0]);
1102 assertEquals("RNDTG", result[1]);
1104 h.hideColumns(6, 8);
1105 result = h.getVisibleSequenceStrings(5, 10, seqs);
1106 assertEquals(2, result.length);
1107 assertEquals("WS", result[0]);
1108 assertEquals("RG", result[1]);
1110 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
1111 ColumnSelection sel = new ColumnSelection();
1112 h.revealAllHiddenColumns(sel);
1113 h.hideColumns(1, 3);
1114 h.hideColumns(6, 11);
1116 h.getVisibleSequenceStrings(0, 5, new SequenceI[]
1120 @Test(groups = "Functional")
1121 public void testHideInsertionsFor()
1123 HiddenColumns h = new HiddenColumns();
1124 HiddenColumns h2 = new HiddenColumns();
1125 SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT");
1126 SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
1128 h.hideInsertionsFor(seq2);
1129 assertTrue(h.equals(h2));
1131 h.hideInsertionsFor(seq1);
1132 h2.hideColumns(3, 5);
1133 h2.hideColumns(9, 9);
1134 h2.hideColumns(19, 20);
1135 assertTrue(h.equals(h2));
1138 @Test(groups = "Functional")
1139 public void testHideMarkedBits()
1141 HiddenColumns h = new HiddenColumns();
1142 HiddenColumns h2 = new HiddenColumns();
1144 BitSet tohide = new BitSet(21);
1145 h.hideMarkedBits(tohide);
1146 assertTrue(h.equals(h2));
1148 // NB in hideMarkedBits, the last bit is not set to hidden
1152 h.hideMarkedBits(tohide);
1154 h2.hideColumns(3, 5);
1155 h2.hideColumns(9, 9);
1156 h2.hideColumns(19, 20);
1157 assertTrue(h.equals(h2));
1160 @Test(groups = "Functional")
1161 public void testMakeVisibleAnnotation()
1163 HiddenColumns h = new HiddenColumns();
1164 Annotation[] anns = new Annotation[] { null, null, new Annotation(1),
1165 new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1166 new Annotation(5), new Annotation(6), new Annotation(7),
1167 new Annotation(8) };
1168 AlignmentAnnotation ann = new AlignmentAnnotation("an", "some an",
1172 AlignmentAnnotation nullann = null;
1173 h.makeVisibleAnnotation(nullann);
1174 assertNull(nullann);
1176 h.makeVisibleAnnotation(1, 2, nullann);
1177 assertNull(nullann);
1180 AlignmentAnnotation emptyann = new AlignmentAnnotation("an", "some ann", null);
1181 h.makeVisibleAnnotation(emptyann);
1182 assertNull(emptyann.annotations);
1184 h.makeVisibleAnnotation(3, 4, emptyann);
1185 assertNull(emptyann.annotations);
1187 // without bounds, does everything
1188 h.makeVisibleAnnotation(ann);
1189 assertEquals(12, ann.annotations.length);
1190 assertNull(ann.annotations[0]);
1191 assertNull(ann.annotations[1]);
1192 assertEquals(1.0f, ann.annotations[2].value);
1193 assertEquals(2.0f, ann.annotations[3].value);
1194 assertEquals(3.0f, ann.annotations[4].value);
1195 assertNull(ann.annotations[5]);
1196 assertNull(ann.annotations[6]);
1197 assertEquals(4.0f, ann.annotations[7].value);
1198 assertEquals(5.0f, ann.annotations[8].value);
1199 assertEquals(6.0f, ann.annotations[9].value);
1200 assertEquals(7.0f, ann.annotations[10].value);
1201 assertEquals(8.0f, ann.annotations[11].value);
1203 // without hidden cols, just truncates
1204 h.makeVisibleAnnotation(3, 5, ann);
1205 assertEquals(3, ann.annotations.length);
1206 assertEquals(2.0f, ann.annotations[0].value);
1207 assertEquals(3.0f, ann.annotations[1].value);
1208 assertNull(ann.annotations[2]);
1210 anns = new Annotation[] { null, null, new Annotation(1),
1211 new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1212 new Annotation(5), new Annotation(6), new Annotation(7),
1213 new Annotation(8) };
1214 ann = new AlignmentAnnotation("an", "some an", anns);
1215 h.hideColumns(4, 7);
1216 h.makeVisibleAnnotation(1, 9, ann);
1217 assertEquals(5, ann.annotations.length);
1218 assertNull(ann.annotations[0]);
1219 assertEquals(1.0f, ann.annotations[1].value);
1220 assertEquals(2.0f, ann.annotations[2].value);
1221 assertEquals(5.0f, ann.annotations[3].value);
1222 assertEquals(6.0f, ann.annotations[4].value);
1224 anns = new Annotation[] { null, null, new Annotation(1),
1225 new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1226 new Annotation(5), new Annotation(6), new Annotation(7),
1227 new Annotation(8) };
1228 ann = new AlignmentAnnotation("an", "some an", anns);
1229 h.hideColumns(1, 2);
1230 h.makeVisibleAnnotation(1, 9, ann);
1231 assertEquals(3, ann.annotations.length);
1232 assertEquals(2.0f, ann.annotations[0].value);
1233 assertEquals(5.0f, ann.annotations[1].value);
1234 assertEquals(6.0f, ann.annotations[2].value);
1236 anns = new Annotation[] { null, null, new Annotation(1),
1237 new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1238 new Annotation(5), new Annotation(6), new Annotation(7),
1239 new Annotation(8), new Annotation(9), new Annotation(10),
1240 new Annotation(11), new Annotation(12), new Annotation(13),
1241 new Annotation(14), new Annotation(15) };
1242 ann = new AlignmentAnnotation("an", "some an", anns);
1243 h = new HiddenColumns();
1244 h.hideColumns(5, 18);
1245 h.hideColumns(20, 21);
1246 h.makeVisibleAnnotation(1, 21, ann);
1247 assertEquals(5, ann.annotations.length);
1248 assertEquals(1.0f, ann.annotations[1].value);
1249 assertEquals(2.0f, ann.annotations[2].value);
1250 assertEquals(3.0f, ann.annotations[3].value);
1251 assertNull(ann.annotations[0]);
1252 assertNull(ann.annotations[4]);
1255 @Test(groups = "Functional")
1256 public void testSubtractVisibleColumns()
1258 HiddenColumns h = new HiddenColumns();
1259 int result = h.subtractVisibleColumns(1, 10);
1260 assertEquals(9, result);
1262 h.hideColumns(7, 9);
1263 result = h.subtractVisibleColumns(4, 10);
1264 assertEquals(3, result);
1266 h.hideColumns(14, 15);
1267 result = h.subtractVisibleColumns(4, 10);
1268 assertEquals(3, result);
1270 result = h.subtractVisibleColumns(10, 17);
1271 assertEquals(2, result);
1273 result = h.subtractVisibleColumns(1, 7);
1274 assertEquals(5, result);
1276 result = h.subtractVisibleColumns(1, 8);
1277 assertEquals(5, result);
1279 result = h.subtractVisibleColumns(3, 15);
1280 assertEquals(10, result);
1282 ColumnSelection sel = new ColumnSelection();
1283 h.revealAllHiddenColumns(sel);
1284 h.hideColumns(0, 30);
1285 result = h.subtractVisibleColumns(31, 0);
1286 assertEquals(-31, result);
1288 HiddenColumns cs = new HiddenColumns();
1290 // test that without hidden columns, findColumnNToLeft returns
1291 // position n to left of provided position
1292 long pos = cs.subtractVisibleColumns(3, 10);
1293 assertEquals(7, pos);
1295 // 0 returns same position
1296 pos = cs.subtractVisibleColumns(0, 10);
1297 assertEquals(10, pos);
1299 // overflow to left returns negative number
1300 pos = cs.subtractVisibleColumns(3, 0);
1301 assertEquals(-3, pos);
1303 // test that with hidden columns to left of result column
1304 // behaviour is the same as above
1305 cs.hideColumns(1, 3);
1307 // position n to left of provided position
1308 pos = cs.subtractVisibleColumns(3, 10);
1309 assertEquals(7, pos);
1311 // 0 returns same position
1312 pos = cs.subtractVisibleColumns(0, 10);
1313 assertEquals(10, pos);
1315 // test with one set of hidden columns between start and required position
1316 cs.hideColumns(12, 15);
1317 pos = cs.subtractVisibleColumns(8, 17);
1318 assertEquals(5, pos);
1320 // test with two sets of hidden columns between start and required position
1321 cs.hideColumns(20, 21);
1322 pos = cs.subtractVisibleColumns(8, 23);
1323 assertEquals(9, pos);
1325 // repeat last 2 tests with no hidden columns to left of required position
1326 ColumnSelection colsel = new ColumnSelection();
1327 cs.revealAllHiddenColumns(colsel);
1329 // test with one set of hidden columns between start and required position
1330 cs.hideColumns(12, 15);
1331 pos = cs.subtractVisibleColumns(8, 17);
1332 assertEquals(5, pos);
1334 // test with two sets of hidden columns between start and required position
1335 cs.hideColumns(20, 21);
1336 pos = cs.subtractVisibleColumns(8, 23);
1337 assertEquals(9, pos);
1342 @Test(groups = "Functional")
1343 public void testBoundedIterator()
1345 HiddenColumns h = new HiddenColumns();
1346 Iterator<int[]> it = h.getBoundedIterator(0, 10);
1348 // no hidden columns = nothing to iterate over
1349 assertFalse(it.hasNext());
1351 // [start,end] contains all hidden columns
1352 // all regions are returned
1353 h.hideColumns(3, 10);
1354 h.hideColumns(14, 16);
1355 it = h.getBoundedIterator(0, 20);
1356 assertTrue(it.hasNext());
1357 int[] next = it.next();
1358 assertEquals(3, next[0]);
1359 assertEquals(10, next[1]);
1361 assertEquals(14, next[0]);
1362 assertEquals(16, next[1]);
1363 assertFalse(it.hasNext());
1365 // [start,end] overlaps a region
1366 // 1 region returned
1367 it = h.getBoundedIterator(5, 7);
1368 assertTrue(it.hasNext());
1370 assertEquals(3, next[0]);
1371 assertEquals(10, next[1]);
1372 assertFalse(it.hasNext());
1374 // [start,end] fully contains 1 region and start of last
1375 // - 2 regions returned
1376 it = h.getBoundedIterator(3, 15);
1377 assertTrue(it.hasNext());
1379 assertEquals(3, next[0]);
1380 assertEquals(10, next[1]);
1382 assertEquals(14, next[0]);
1383 assertEquals(16, next[1]);
1384 assertFalse(it.hasNext());
1386 // [start,end] contains end of first region and whole of last region
1387 // - 2 regions returned
1388 it = h.getBoundedIterator(4, 20);
1389 assertTrue(it.hasNext());
1391 assertEquals(3, next[0]);
1392 assertEquals(10, next[1]);
1394 assertEquals(14, next[0]);
1395 assertEquals(16, next[1]);
1396 assertFalse(it.hasNext());
1399 @Test(groups = "Functional")
1400 public void testBoundedStartIterator()
1402 HiddenColumns h = new HiddenColumns();
1403 Iterator<Integer> it = h.getBoundedStartIterator(0, 10);
1405 // no hidden columns = nothing to iterate over
1406 assertFalse(it.hasNext());
1408 // [start,end] contains all hidden columns
1409 // all regions are returned
1410 h.hideColumns(3, 10);
1411 h.hideColumns(14, 16);
1412 it = h.getBoundedStartIterator(0, 20);
1413 assertTrue(it.hasNext());
1414 int next = it.next();
1415 assertEquals(3, next);
1417 assertEquals(6, next);
1418 assertFalse(it.hasNext());
1420 // [start,end] does not contain a start of a region
1421 // no regions to iterate over
1422 it = h.getBoundedStartIterator(4, 5);
1423 assertFalse(it.hasNext());
1425 // [start,end] fully contains 1 region and start of last
1426 // - 2 regions returned
1427 it = h.getBoundedStartIterator(3, 7);
1428 assertTrue(it.hasNext());
1430 assertEquals(3, next);
1432 assertEquals(6, next);
1433 assertFalse(it.hasNext());
1435 // [start,end] contains whole of last region
1436 // - 1 region returned
1437 it = h.getBoundedStartIterator(4, 20);
1438 assertTrue(it.hasNext());
1440 assertEquals(6, next);
1441 assertFalse(it.hasNext());
1444 @Test(groups = "Functional")
1445 public void testVisibleBlocksVisBoundsIterator()
1447 HiddenColumns h = new HiddenColumns();
1448 Iterator<int[]> regions = h.getVisContigsIterator(0, 31, true);
1450 // only 1 visible region spanning 0-30 if nothing is hidden
1451 assertTrue(regions.hasNext());
1452 int[] region = regions.next();
1453 assertEquals(0, region[0]);
1454 assertEquals(30, region[1]);
1455 assertFalse(regions.hasNext());
1457 // hide 1 region in middle
1458 // 2 regions one on either side
1459 // second region boundary accounts for hidden columns
1460 h.hideColumns(10, 15);
1461 regions = h.getVisContigsIterator(0, 31, true);
1463 assertTrue(regions.hasNext());
1464 region = regions.next();
1465 assertEquals(0, region[0]);
1466 assertEquals(9, region[1]);
1467 region = regions.next();
1468 assertEquals(16, region[0]);
1469 assertEquals(36, region[1]);
1470 assertFalse(regions.hasNext());
1472 // single hidden region at left
1473 h = new HiddenColumns();
1474 h.hideColumns(0, 5);
1475 regions = h.getVisContigsIterator(0, 31, true);
1477 assertTrue(regions.hasNext());
1478 region = regions.next();
1479 assertEquals(6, region[0]);
1480 assertEquals(36, region[1]);
1481 assertFalse(regions.hasNext());
1483 // single hidden region at right
1484 h = new HiddenColumns();
1485 h.hideColumns(27, 30);
1486 regions = h.getVisContigsIterator(0, 31, true);
1488 assertTrue(regions.hasNext());
1489 region = regions.next();
1490 assertEquals(0, region[0]);
1491 assertEquals(26, region[1]);
1492 region = regions.next();
1493 assertEquals(31, region[0]);
1494 assertEquals(34, region[1]);
1495 assertFalse(regions.hasNext());
1497 // hidden region at left + hidden region in middle
1498 h = new HiddenColumns();
1499 h.hideColumns(0, 5);
1500 h.hideColumns(23, 25);
1501 regions = h.getVisContigsIterator(0, 31, true);
1503 assertTrue(regions.hasNext());
1504 region = regions.next();
1505 assertEquals(6, region[0]);
1506 assertEquals(22, region[1]);
1507 region = regions.next();
1508 assertEquals(26, region[0]);
1509 assertEquals(39, region[1]);
1510 assertFalse(regions.hasNext());
1512 // hidden region at right + hidden region in middle
1513 h = new HiddenColumns();
1514 h.hideColumns(27, 30);
1515 h.hideColumns(11, 14);
1516 regions = h.getVisContigsIterator(0, 31, true);
1518 assertTrue(regions.hasNext());
1519 region = regions.next();
1520 assertEquals(0, region[0]);
1521 assertEquals(10, region[1]);
1522 region = regions.next();
1523 assertEquals(15, region[0]);
1524 assertEquals(26, region[1]);
1525 region = regions.next();
1526 assertEquals(31, region[0]);
1527 assertEquals(38, region[1]);
1528 assertFalse(regions.hasNext());
1530 // hidden region at left and right
1531 h = new HiddenColumns();
1532 h.hideColumns(27, 35);
1533 h.hideColumns(0, 4);
1534 regions = h.getVisContigsIterator(0, 31, true);
1536 assertTrue(regions.hasNext());
1537 region = regions.next();
1538 assertEquals(5, region[0]);
1539 assertEquals(26, region[1]);
1540 region = regions.next();
1541 assertEquals(36, region[0]);
1542 assertEquals(44, region[1]);
1543 assertFalse(regions.hasNext());
1545 // multiple hidden regions
1546 h = new HiddenColumns();
1547 h.hideColumns(1, 1);
1548 h.hideColumns(3, 5);
1549 h.hideColumns(9, 11);
1550 h.hideColumns(22, 26);
1552 regions = h.getVisContigsIterator(0, 31, true);
1554 assertTrue(regions.hasNext());
1555 region = regions.next();
1556 assertEquals(0, region[0]);
1557 assertEquals(0, region[1]);
1558 region = regions.next();
1559 assertEquals(2, region[0]);
1560 assertEquals(2, region[1]);
1561 region = regions.next();
1562 assertEquals(6, region[0]);
1563 assertEquals(8, region[1]);
1564 region = regions.next();
1565 assertEquals(12, region[0]);
1566 assertEquals(21, region[1]);
1567 region = regions.next();
1568 assertEquals(27, region[0]);
1569 assertEquals(42, region[1]);
1570 assertFalse(regions.hasNext());
1574 * the VisibleColsIterator is tested elsewhere, this just tests that
1575 * it can be retrieved from HiddenColumns
1577 @Test(groups = "Functional")
1578 public void testGetVisibleColsIterator()
1580 HiddenColumns h = new HiddenColumns();
1581 Iterator<Integer> it = h.getVisibleColsIterator(0, 10);
1583 assertTrue(it instanceof VisibleColsIterator);
1586 @Test(groups = "Functional")
1587 public void testHashCode()
1589 HiddenColumns h = new HiddenColumns();
1590 h.hideColumns(0, 25);
1592 int result = h.hashCode();
1593 assertTrue(result > 0);
1595 h.hideColumns(30, 50);
1596 assertTrue(h.hashCode() > 0);
1597 assertTrue(result != h.hashCode());