Clover icon

Coverage Report

  1. Project Clover database Tue Mar 10 2026 14:58:44 GMT
  2. Package jalview.datamodel

File HiddenColumnsTest.java

 

Code metrics

0
758
29
1
1,318
888
29
0.04
26.14
29
1

Classes

Class Line # Actions
HiddenColumnsTest 36 758 29
0.00%
 

Contributing tests

No tests hitting this source file were found.

Source view

1    /*
2    * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3    * Copyright (C) $$Year-Rel$$ The Jalview Authors
4    *
5    * This file is part of Jalview.
6    *
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.
11    *
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.
16    *
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.
20    */
21    package jalview.datamodel;
22   
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;
27   
28    import jalview.analysis.AlignmentGenerator;
29   
30    import java.util.Arrays;
31    import java.util.BitSet;
32    import java.util.Iterator;
33   
34    import org.testng.annotations.Test;
35   
 
36    public class HiddenColumnsTest
37    {
38    /**
39    * Test the method which counts the number of hidden columns
40    */
 
41  0 toggle @Test(groups = { "Functional" })
42    public void testGetSize()
43    {
44  0 HiddenColumns hidden = new HiddenColumns();
45  0 assertEquals(0, hidden.getSize());
46   
47  0 hidden.hideColumns(3, 5);
48  0 assertEquals(3, hidden.getSize());
49   
50  0 hidden.hideColumns(8, 8);
51  0 assertEquals(4, hidden.getSize());
52   
53  0 hidden.hideColumns(9, 14);
54  0 assertEquals(10, hidden.getSize());
55   
56  0 ColumnSelection cs = new ColumnSelection();
57  0 hidden.revealAllHiddenColumns(cs);
58  0 assertEquals(0, hidden.getSize());
59    }
60   
61    /**
62    * Test the method that finds the visible column position of an alignment
63    * column, allowing for hidden columns.
64    */
 
65  0 toggle @Test(groups = { "Functional" })
66    public void testFindColumnPosition()
67    {
68  0 HiddenColumns cs = new HiddenColumns();
69  0 assertEquals(5, cs.absoluteToVisibleColumn(5));
70   
71    // hiding column 6 makes no difference
72  0 cs.hideColumns(6, 6);
73  0 assertEquals(5, cs.absoluteToVisibleColumn(5));
74   
75    // hiding column 4 moves column 5 to column 4
76  0 cs.hideColumns(4, 4);
77  0 assertEquals(4, cs.absoluteToVisibleColumn(5));
78   
79    // hiding column 4 moves column 4 to position 3
80  0 assertEquals(3, cs.absoluteToVisibleColumn(4));
81   
82    // hiding columns 1 and 2 moves column 5 to column 2
83  0 cs.hideColumns(1, 2);
84  0 assertEquals(2, cs.absoluteToVisibleColumn(5));
85   
86    // check with > 1 hidden column regions
87    // where some columns are in the hidden regions
88  0 HiddenColumns cs2 = new HiddenColumns();
89  0 cs2.hideColumns(5, 10);
90  0 cs2.hideColumns(20, 27);
91  0 cs2.hideColumns(40, 44);
92   
93    // hiding columns 5-10 and 20-27 moves column 8 to column 4
94  0 assertEquals(4, cs2.absoluteToVisibleColumn(8));
95   
96    // and moves column 24 to 13
97  0 assertEquals(13, cs2.absoluteToVisibleColumn(24));
98   
99    // and moves column 28 to 14
100  0 assertEquals(14, cs2.absoluteToVisibleColumn(28));
101   
102    // and moves column 40 to 25
103  0 assertEquals(25, cs2.absoluteToVisibleColumn(40));
104   
105    // check when hidden columns start at 0 that the visible column
106    // is returned as 0
107  0 HiddenColumns cs3 = new HiddenColumns();
108  0 cs3.hideColumns(0, 4);
109  0 assertEquals(0, cs3.absoluteToVisibleColumn(2));
110   
111    // check that column after the last hidden region doesn't crash
112  0 assertEquals(46, cs2.absoluteToVisibleColumn(65));
113    }
114   
 
115  0 toggle @Test(groups = { "Functional" })
116    public void testVisibleContigsIterator()
117    {
118  0 HiddenColumns cs = new HiddenColumns();
119   
120  0 Iterator<int[]> visible = cs.getVisContigsIterator(3, 10, false);
121  0 int[] region = visible.next();
122  0 assertEquals("[3, 9]", Arrays.toString(region));
123  0 assertFalse(visible.hasNext());
124   
125  0 cs.hideColumns(3, 6);
126  0 cs.hideColumns(8, 9);
127  0 cs.hideColumns(12, 12);
128   
129    // Test both ends visible region
130   
131    // start position is inclusive, end position exclusive
132  0 visible = cs.getVisContigsIterator(1, 13, false);
133  0 region = visible.next();
134  0 assertEquals("[1, 2]", Arrays.toString(region));
135  0 region = visible.next();
136  0 assertEquals("[7, 7]", Arrays.toString(region));
137  0 region = visible.next();
138  0 assertEquals("[10, 11]", Arrays.toString(region));
139  0 assertFalse(visible.hasNext());
140   
141    // Test start hidden, end visible
142  0 visible = cs.getVisContigsIterator(4, 14, false);
143  0 region = visible.next();
144  0 assertEquals("[7, 7]", Arrays.toString(region));
145  0 region = visible.next();
146  0 assertEquals("[10, 11]", Arrays.toString(region));
147  0 region = visible.next();
148  0 assertEquals("[13, 13]", Arrays.toString(region));
149  0 assertFalse(visible.hasNext());
150   
151    // Test start hidden, end hidden
152  0 visible = cs.getVisContigsIterator(3, 10, false);
153  0 region = visible.next();
154  0 assertEquals("[7, 7]", Arrays.toString(region));
155  0 assertFalse(visible.hasNext());
156   
157    // Test start visible, end hidden
158  0 visible = cs.getVisContigsIterator(0, 13, false);
159  0 region = visible.next();
160  0 assertEquals("[0, 2]", Arrays.toString(region));
161  0 region = visible.next();
162  0 assertEquals("[7, 7]", Arrays.toString(region));
163  0 region = visible.next();
164  0 assertEquals("[10, 11]", Arrays.toString(region));
165  0 assertFalse(visible.hasNext());
166   
167    // Test empty result
168  0 visible = cs.getVisContigsIterator(4, 6, false);
169  0 assertFalse(visible.hasNext());
170    }
171   
 
172  0 toggle @Test(groups = { "Functional" })
173    public void testEquals()
174    {
175  0 HiddenColumns cs = new HiddenColumns();
176  0 cs.hideColumns(5, 9);
177   
178    // a different set of hidden columns
179  0 HiddenColumns cs2 = new HiddenColumns();
180   
181    // with no hidden columns
182  0 assertFalse(cs.equals(cs2));
183  0 assertFalse(cs2.equals(cs));
184   
185    // with the wrong kind of object
186  0 assertFalse(cs.equals(new HiddenColumnsCursor()));
187   
188    // with a different hiddenColumns object - by size
189  0 HiddenColumns cs3 = new HiddenColumns();
190  0 cs3.hideColumns(2, 3);
191  0 assertFalse(cs.equals(cs3));
192   
193    // with hidden columns added in a different order
194  0 cs2.hideColumns(6, 9);
195  0 assertFalse(cs.equals(cs2));
196  0 assertFalse(cs2.equals(cs));
197   
198  0 cs2.hideColumns(5, 8);
199   
200  0 assertTrue(cs.equals(cs2));
201  0 assertTrue(cs.equals(cs));
202  0 assertTrue(cs2.equals(cs));
203  0 assertTrue(cs2.equals(cs2));
204   
205    // different ranges, same size
206  0 cs.hideColumns(10, 12);
207  0 cs2.hideColumns(10, 15);
208  0 assertFalse(cs.equals(cs2));
209   
210    }
211   
 
212  0 toggle @Test(groups = "Functional")
213    public void testCopyConstructor()
214    {
215  0 HiddenColumns cs = new HiddenColumns();
216  0 cs.hideColumns(10, 11);
217  0 cs.hideColumns(5, 7);
218  0 Iterator<int[]> regions = cs.iterator();
219  0 assertEquals("[5, 7]", Arrays.toString(regions.next()));
220   
221  0 HiddenColumns cs2 = new HiddenColumns(cs);
222  0 regions = cs2.iterator();
223  0 assertTrue(cs2.hasHiddenColumns());
224  0 assertEquals(2, cs2.getNumberOfRegions());
225    // hidden columns are held in column order
226  0 assertEquals("[5, 7]", Arrays.toString(regions.next()));
227  0 assertEquals("[10, 11]", Arrays.toString(regions.next()));
228    }
229   
 
230  0 toggle @Test(groups = "Functional")
231    public void testCopyConstructor2()
232    {
233  0 HiddenColumns cs = new HiddenColumns();
234  0 cs.hideColumns(10, 11);
235  0 cs.hideColumns(5, 7);
236   
237  0 HiddenColumns cs2 = new HiddenColumns(cs, 3, 9, 1);
238  0 assertTrue(cs2.hasHiddenColumns());
239  0 Iterator<int[]> regions = cs2.iterator();
240   
241    // only [5,7] returned, offset by 1
242  0 assertEquals("[4, 6]", Arrays.toString(regions.next()));
243  0 assertEquals(3, cs2.getSize());
244   
245  0 cs2 = new HiddenColumns(cs, 8, 15, 4);
246  0 regions = cs2.iterator();
247  0 assertTrue(cs2.hasHiddenColumns());
248   
249    // only [10,11] returned, offset by 4
250  0 assertEquals("[6, 7]", Arrays.toString(regions.next()));
251  0 assertEquals(2, cs2.getSize());
252   
253  0 cs2 = new HiddenColumns(cs, 6, 10, 4);
254  0 assertFalse(cs2.hasHiddenColumns());
255    }
256   
 
257  0 toggle @Test(groups = { "Functional" })
258    public void testHideColumns()
259    {
260    // create random alignment
261  0 AlignmentGenerator gen = new AlignmentGenerator(false);
262  0 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
263   
264  0 ColumnSelection colsel = new ColumnSelection();
265  0 HiddenColumns cs = al.getHiddenColumns();
266  0 colsel.hideSelectedColumns(5, al.getHiddenColumns());
267  0 Iterator<int[]> regions = cs.iterator();
268  0 assertEquals(1, cs.getNumberOfRegions());
269  0 assertEquals("[5, 5]", Arrays.toString(regions.next()));
270  0 assertEquals(cs.getSize(), 1);
271   
272  0 colsel.hideSelectedColumns(3, al.getHiddenColumns());
273  0 regions = cs.iterator();
274  0 assertEquals(2, cs.getNumberOfRegions());
275    // two hidden ranges, in order:
276  0 assertEquals("[3, 3]", Arrays.toString(regions.next()));
277  0 assertEquals("[5, 5]", Arrays.toString(regions.next()));
278  0 assertEquals(cs.getSize(), 2);
279   
280    // hiding column 4 expands [3, 3] to [3, 4]
281    // and merges to [5, 5] to make [3, 5]
282  0 colsel.hideSelectedColumns(4, al.getHiddenColumns());
283  0 regions = cs.iterator();
284  0 assertEquals(1, cs.getNumberOfRegions());
285  0 assertEquals("[3, 5]", Arrays.toString(regions.next()));
286  0 assertEquals(cs.getSize(), 3);
287   
288    // clear hidden columns (note they are added to selected)
289  0 cs.revealAllHiddenColumns(colsel);
290    // it is now actually null but getter returns an empty list
291  0 assertEquals(0, cs.getNumberOfRegions());
292  0 assertEquals(cs.getSize(), 0);
293   
294  0 cs.hideColumns(3, 6);
295  0 regions = cs.iterator();
296  0 int[] firstHiddenRange = regions.next();
297  0 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
298  0 assertEquals(cs.getSize(), 4);
299   
300    // adding a subrange of already hidden should do nothing
301  0 cs.hideColumns(4, 5);
302  0 regions = cs.iterator();
303  0 assertEquals(1, cs.getNumberOfRegions());
304  0 assertEquals("[3, 6]", Arrays.toString(regions.next()));
305  0 assertEquals(cs.getSize(), 4);
306  0 cs.hideColumns(3, 5);
307  0 regions = cs.iterator();
308  0 assertEquals(1, cs.getNumberOfRegions());
309  0 assertEquals("[3, 6]", Arrays.toString(regions.next()));
310  0 assertEquals(cs.getSize(), 4);
311  0 cs.hideColumns(4, 6);
312  0 regions = cs.iterator();
313  0 assertEquals(1, cs.getNumberOfRegions());
314  0 assertEquals("[3, 6]", Arrays.toString(regions.next()));
315  0 assertEquals(cs.getSize(), 4);
316  0 cs.hideColumns(3, 6);
317  0 regions = cs.iterator();
318  0 assertEquals(1, cs.getNumberOfRegions());
319  0 assertEquals("[3, 6]", Arrays.toString(regions.next()));
320  0 assertEquals(cs.getSize(), 4);
321   
322  0 cs.revealAllHiddenColumns(colsel);
323  0 cs.hideColumns(2, 4);
324  0 regions = cs.iterator();
325  0 assertEquals(1, cs.getNumberOfRegions());
326  0 assertEquals("[2, 4]", Arrays.toString(regions.next()));
327  0 assertEquals(cs.getSize(), 3);
328   
329    // extend contiguous with 2 positions overlap
330  0 cs.hideColumns(3, 5);
331  0 regions = cs.iterator();
332  0 assertEquals(1, cs.getNumberOfRegions());
333  0 assertEquals("[2, 5]", Arrays.toString(regions.next()));
334  0 assertEquals(cs.getSize(), 4);
335   
336    // extend contiguous with 1 position overlap
337  0 cs.hideColumns(5, 6);
338  0 regions = cs.iterator();
339  0 assertEquals(1, cs.getNumberOfRegions());
340  0 assertEquals("[2, 6]", Arrays.toString(regions.next()));
341  0 assertEquals(cs.getSize(), 5);
342   
343    // extend contiguous with overlap both ends:
344  0 cs.hideColumns(1, 7);
345  0 regions = cs.iterator();
346  0 assertEquals(1, cs.getNumberOfRegions());
347  0 assertEquals("[1, 7]", Arrays.toString(regions.next()));
348  0 assertEquals(cs.getSize(), 7);
349   
350  0 cs.revealAllHiddenColumns(colsel);
351  0 cs.hideColumns(15, 18);
352  0 cs.hideColumns(2, 4);
353  0 cs.hideColumns(7, 9);
354  0 regions = cs.iterator();
355  0 assertEquals(3, cs.getNumberOfRegions());
356  0 assertEquals("[2, 4]", Arrays.toString(regions.next()));
357  0 assertEquals("[7, 9]", Arrays.toString(regions.next()));
358  0 assertEquals("[15, 18]", Arrays.toString(regions.next()));
359  0 assertEquals(cs.getSize(), 10);
360    }
361   
362    /**
363    * Test the method that reveals a range of hidden columns given the start
364    * column of the range
365    */
 
366  0 toggle @Test(groups = { "Functional" })
367    public void testRevealHiddenColumns()
368    {
369  0 ColumnSelection colsel = new ColumnSelection();
370  0 HiddenColumns cs = new HiddenColumns();
371   
372    // test with null hidden columns
373  0 cs.revealHiddenColumns(5, colsel);
374  0 assertTrue(colsel.getSelected().isEmpty());
375   
376  0 cs.hideColumns(5, 8);
377  0 colsel.addElement(10);
378  0 cs.revealHiddenColumns(5, colsel);
379   
380    // hiddenColumns now empty
381  0 assertEquals(0, cs.getSize());
382   
383    // revealed columns are marked as selected (added to selection):
384  0 assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
385   
386    // calling with a column other than the range start does nothing:
387  0 colsel = new ColumnSelection();
388  0 cs = new HiddenColumns();
389  0 cs.hideColumns(5, 8);
390   
391  0 int prevSize = cs.getSize();
392  0 cs.revealHiddenColumns(6, colsel);
393  0 assertEquals(prevSize, cs.getSize());
394  0 assertTrue(colsel.getSelected().isEmpty());
395   
396    // reveal hidden columns when there is more than one region
397  0 cs.hideColumns(20, 23);
398    // now there are 2 hidden regions
399  0 assertEquals(2, cs.getNumberOfRegions());
400   
401  0 cs.revealHiddenColumns(20, colsel);
402   
403    // hiddenColumns now has one region
404  0 assertEquals(1, cs.getNumberOfRegions());
405   
406    // revealed columns are marked as selected (added to selection):
407  0 assertEquals("[20, 21, 22, 23]", colsel.getSelected().toString());
408   
409    // call with a column past the end of the hidden column ranges
410  0 colsel.clear();
411  0 cs.revealHiddenColumns(20, colsel);
412    // hiddenColumns still has 1 region
413  0 assertEquals(1, cs.getNumberOfRegions());
414  0 assertTrue(colsel.getSelected().isEmpty());
415    }
416   
 
417  0 toggle @Test(groups = { "Functional" })
418    public void testRevealAllHiddenColumns()
419    {
420  0 HiddenColumns hidden = new HiddenColumns();
421  0 ColumnSelection colsel = new ColumnSelection();
422   
423    // test with null hidden columns
424  0 hidden.revealAllHiddenColumns(colsel);
425  0 assertTrue(colsel.getSelected().isEmpty());
426   
427  0 hidden.hideColumns(5, 8);
428  0 hidden.hideColumns(2, 3);
429  0 colsel.addElement(11);
430  0 colsel.addElement(1);
431  0 hidden.revealAllHiddenColumns(colsel);
432   
433    /*
434    * revealing hidden columns adds them (in order) to the (unordered)
435    * selection list
436    */
437   
438    // hiddenColumns now empty
439  0 assertEquals(0, hidden.getSize());
440   
441  0 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]",
442    colsel.getSelected().toString());
443    }
444   
 
445  0 toggle @Test(groups = { "Functional" })
446    public void testIsVisible()
447    {
448  0 HiddenColumns cs = new HiddenColumns();
449  0 assertTrue(cs.isVisible(5));
450   
451  0 cs.hideColumns(2, 4);
452  0 cs.hideColumns(6, 7);
453  0 assertTrue(cs.isVisible(0));
454  0 assertTrue(cs.isVisible(-99));
455  0 assertTrue(cs.isVisible(1));
456  0 assertFalse(cs.isVisible(2));
457  0 assertFalse(cs.isVisible(3));
458  0 assertFalse(cs.isVisible(4));
459  0 assertTrue(cs.isVisible(5));
460  0 assertFalse(cs.isVisible(6));
461  0 assertFalse(cs.isVisible(7));
462  0 assertTrue(cs.isVisible(8));
463    }
464   
465    /**
466    * Test for the case when a hidden range encloses more one already hidden
467    * range
468    */
 
469  0 toggle @Test(groups = { "Functional" })
470    public void testHideColumns_subsumingHidden()
471    {
472    /*
473    * JAL-2370 bug scenario:
474    * two hidden ranges subsumed by a third
475    */
476  0 HiddenColumns cs = new HiddenColumns();
477  0 cs.hideColumns(49, 59);
478  0 cs.hideColumns(69, 79);
479  0 Iterator<int[]> regions = cs.iterator();
480  0 assertEquals(2, cs.getNumberOfRegions());
481  0 assertEquals("[49, 59]", Arrays.toString(regions.next()));
482  0 assertEquals("[69, 79]", Arrays.toString(regions.next()));
483  0 assertEquals(22, cs.getSize());
484   
485  0 cs.hideColumns(48, 80);
486  0 regions = cs.iterator();
487  0 assertEquals(1, cs.getNumberOfRegions());
488  0 assertEquals("[48, 80]", Arrays.toString(regions.next()));
489  0 assertEquals(33, cs.getSize());
490   
491    /*
492    * another...joining hidden ranges
493    */
494  0 cs = new HiddenColumns();
495  0 cs.hideColumns(10, 20);
496  0 cs.hideColumns(30, 40);
497  0 cs.hideColumns(50, 60);
498    // hiding 21-49 should merge to one range
499  0 cs.hideColumns(21, 49);
500  0 regions = cs.iterator();
501  0 assertEquals(1, cs.getNumberOfRegions());
502  0 assertEquals("[10, 60]", Arrays.toString(regions.next()));
503  0 assertEquals(51, cs.getSize());
504   
505    /*
506    * another...left overlap, subsumption, right overlap,
507    * no overlap of existing hidden ranges
508    */
509  0 cs = new HiddenColumns();
510  0 cs.hideColumns(10, 20);
511  0 cs.hideColumns(10, 20);
512  0 cs.hideColumns(30, 35);
513  0 cs.hideColumns(40, 50);
514  0 cs.hideColumns(60, 70);
515   
516  0 cs.hideColumns(15, 45);
517  0 regions = cs.iterator();
518  0 assertEquals(2, cs.getNumberOfRegions());
519  0 assertEquals("[10, 50]", Arrays.toString(regions.next()));
520  0 assertEquals("[60, 70]", Arrays.toString(regions.next()));
521  0 assertEquals(52, cs.getSize());
522    }
523   
 
524  0 toggle @Test(groups = { "Functional" })
525    public void testHideColumns_BitSet()
526    {
527  0 HiddenColumns cs;
528   
529  0 BitSet one = new BitSet();
530   
531    // one hidden range
532  0 one.set(1);
533  0 cs = new HiddenColumns();
534  0 cs.hideColumns(one);
535  0 assertEquals(1, cs.getNumberOfRegions());
536  0 assertEquals(1, cs.getSize());
537   
538  0 one.set(2);
539  0 cs = new HiddenColumns();
540  0 cs.hideColumns(one);
541  0 assertEquals(1, cs.getNumberOfRegions());
542  0 assertEquals(2, cs.getSize());
543   
544  0 one.set(3);
545  0 cs = new HiddenColumns();
546  0 cs.hideColumns(one);
547  0 assertEquals(1, cs.getNumberOfRegions());
548  0 assertEquals(3, cs.getSize());
549   
550    // split
551  0 one.clear(2);
552  0 cs = new HiddenColumns();
553  0 cs.hideColumns(one);
554  0 assertEquals(2, cs.getNumberOfRegions());
555  0 assertEquals(2, cs.getSize());
556   
557  0 assertEquals(0, cs.visibleToAbsoluteColumn(0));
558  0 assertEquals(2, cs.visibleToAbsoluteColumn(1));
559  0 assertEquals(4, cs.visibleToAbsoluteColumn(2));
560   
561    // one again
562  0 one.clear(1);
563  0 cs = new HiddenColumns();
564  0 cs.hideColumns(one);
565  0 assertEquals(1, cs.getSize());
566   
567  0 assertEquals(1, cs.getNumberOfRegions());
568   
569  0 assertEquals(0, cs.visibleToAbsoluteColumn(0));
570  0 assertEquals(1, cs.visibleToAbsoluteColumn(1));
571  0 assertEquals(2, cs.visibleToAbsoluteColumn(2));
572  0 assertEquals(4, cs.visibleToAbsoluteColumn(3));
573    }
574   
 
575  0 toggle @Test(groups = { "Functional" })
576    public void testRegionsToString()
577    {
578  0 HiddenColumns hc = new HiddenColumns();
579   
580  0 String result = hc.regionsToString(",", "--");
581  0 assertEquals("", result);
582   
583  0 hc.hideColumns(3, 7);
584  0 hc.hideColumns(10, 10);
585  0 hc.hideColumns(14, 15);
586   
587  0 result = hc.regionsToString(",", "--");
588  0 assertEquals("3--7,10--10,14--15", result);
589    }
590   
 
591  0 toggle @Test(groups = "Functional")
592    public void testGetVisibleStartAndEndIndex()
593    {
594  0 Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
595  0 AlignmentI align = new Alignment(new SequenceI[] { seq });
596  0 HiddenColumns hc = new HiddenColumns();
597   
598  0 int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
599  0 assertEquals(0, startEnd[0]);
600  0 assertEquals(25, startEnd[1]);
601   
602  0 hc.hideColumns(0, 0);
603  0 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
604  0 assertEquals(1, startEnd[0]);
605  0 assertEquals(25, startEnd[1]);
606   
607  0 hc.hideColumns(6, 9);
608  0 hc.hideColumns(11, 12);
609  0 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
610  0 assertEquals(1, startEnd[0]);
611  0 assertEquals(25, startEnd[1]);
612   
613  0 hc.hideColumns(24, 25);
614  0 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
615  0 System.out.println(startEnd[0] + " : " + startEnd[1]);
616  0 assertEquals(1, startEnd[0]);
617  0 assertEquals(23, startEnd[1]);
618   
619    // force lowest range to start of alignment
620  0 hc = new HiddenColumns();
621  0 hc.hideColumns(3, 4);
622  0 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
623  0 assertEquals(0, startEnd[0]);
624  0 assertEquals(25, startEnd[1]);
625    }
626   
 
627  0 toggle @Test(groups = "Functional")
628    public void testGetRegionWithEdgeAtRes()
629    {
630  0 HiddenColumns hc = new HiddenColumns();
631   
632  0 int[] result = hc.getRegionWithEdgeAtRes(5);
633  0 assertNull(result);
634   
635  0 hc.hideColumns(3, 7);
636  0 hc.hideColumns(10, 10);
637  0 hc.hideColumns(14, 15);
638   
639  0 result = hc.getRegionWithEdgeAtRes(2);
640  0 assertEquals(3, result[0]);
641  0 assertEquals(7, result[1]);
642   
643  0 result = hc.getRegionWithEdgeAtRes(4);
644  0 assertEquals(10, result[0]);
645  0 assertEquals(10, result[1]);
646   
647  0 result = hc.getRegionWithEdgeAtRes(5);
648  0 assertEquals(10, result[0]);
649  0 assertEquals(10, result[1]);
650   
651  0 result = hc.getRegionWithEdgeAtRes(6);
652  0 assertNull(result);
653   
654  0 result = hc.getRegionWithEdgeAtRes(0);
655  0 assertNull(result);
656   
657  0 result = hc.getRegionWithEdgeAtRes(7);
658  0 assertEquals(14, result[0]);
659  0 assertEquals(15, result[1]);
660   
661  0 result = hc.getRegionWithEdgeAtRes(8);
662  0 assertEquals(14, result[0]);
663  0 assertEquals(15, result[1]);
664   
665  0 result = hc.getRegionWithEdgeAtRes(16);
666  0 assertNull(result);
667    }
668   
 
669  0 toggle @Test(groups = "Functional")
670    public void testHasHiddenColumns()
671    {
672  0 HiddenColumns h = new HiddenColumns();
673   
674    // new HiddenColumns2 has no hidden cols
675  0 assertFalse(h.hasHiddenColumns());
676   
677    // some columns hidden, returns true
678  0 h.hideColumns(5, 10);
679  0 assertTrue(h.hasHiddenColumns());
680   
681    // reveal columns, no hidden cols again
682  0 ColumnSelection sel = new ColumnSelection();
683  0 h.revealAllHiddenColumns(sel);
684  0 assertFalse(h.hasHiddenColumns());
685    }
686   
 
687  0 toggle @Test(groups = "Functional")
688    public void testHasManyHiddenColumns()
689    {
690  0 HiddenColumns h = new HiddenColumns();
691   
692    // h has no hidden cols
693  0 assertFalse(h.hasMultiHiddenColumnRegions());
694   
695    // one set of columns hidden, returns false
696  0 h.hideColumns(5, 10);
697  0 assertFalse(h.hasMultiHiddenColumnRegions());
698   
699    // two sets hidden, returns true
700  0 h.hideColumns(15, 17);
701  0 assertTrue(h.hasMultiHiddenColumnRegions());
702   
703    // back to one block, asserts false
704  0 h.hideColumns(11, 14);
705  0 assertFalse(h.hasMultiHiddenColumnRegions());
706    }
707   
 
708  0 toggle @Test(groups = "Functional")
709    public void testAdjustForHiddenColumns()
710    {
711  0 HiddenColumns h = new HiddenColumns();
712    // returns input value when there are no hidden columns
713  0 assertEquals(10, h.visibleToAbsoluteColumn(10));
714   
715  0 h.hideColumns(20, 30);
716  0 assertEquals(10, h.visibleToAbsoluteColumn(10));
717  0 assertEquals(20 + 11, h.visibleToAbsoluteColumn(20));
718  0 assertEquals(35 + 11, h.visibleToAbsoluteColumn(35));
719   
720  0 h.hideColumns(5, 7);
721  0 assertEquals(10 + 3, h.visibleToAbsoluteColumn(10));
722  0 assertEquals(20 + 14, h.visibleToAbsoluteColumn(20));
723  0 assertEquals(35 + 14, h.visibleToAbsoluteColumn(35));
724   
725  0 ColumnSelection sel = new ColumnSelection();
726  0 h.revealAllHiddenColumns(sel);
727  0 h.hideColumns(0, 1);
728  0 assertEquals(4, h.visibleToAbsoluteColumn(2));
729    }
730   
 
731  0 toggle @Test(groups = "Functional")
732    public void testGetNextHiddenBoundary_Left()
733    {
734  0 HiddenColumns h = new HiddenColumns();
735   
736    // returns same value if no hidden cols
737  0 assertEquals(3, h.getNextHiddenBoundary(true, 3));
738   
739  0 h.hideColumns(5, 10);
740  0 assertEquals(10, h.getNextHiddenBoundary(true, 15));
741  0 assertEquals(3, h.getNextHiddenBoundary(true, 3));
742  0 assertEquals(7, h.getNextHiddenBoundary(true, 7));
743   
744  0 h.hideColumns(15, 20);
745  0 assertEquals(10, h.getNextHiddenBoundary(true, 15));
746  0 assertEquals(20, h.getNextHiddenBoundary(true, 21));
747    }
748   
 
749  0 toggle @Test(groups = "Functional")
750    public void testGetNextHiddenBoundary_Right()
751    {
752  0 HiddenColumns h = new HiddenColumns();
753   
754    // returns same value if no hidden cols
755  0 assertEquals(3, h.getNextHiddenBoundary(false, 3));
756   
757  0 h.hideColumns(5, 10);
758  0 assertEquals(5, h.getNextHiddenBoundary(false, 3));
759  0 assertEquals(15, h.getNextHiddenBoundary(false, 15));
760  0 assertEquals(7, h.getNextHiddenBoundary(false, 7));
761   
762  0 h.hideColumns(15, 20);
763  0 assertEquals(15, h.getNextHiddenBoundary(false, 7));
764  0 assertEquals(15, h.getNextHiddenBoundary(false, 14));
765   
766    // returns same value if there is no next hidden column
767  0 assertEquals(22, h.getNextHiddenBoundary(false, 22));
768    }
769   
 
770  0 toggle @Test(groups = "Functional")
771    public void testIterator()
772    {
773  0 HiddenColumns h = new HiddenColumns();
774  0 Iterator<int[]> result = h.iterator();
775  0 assertFalse(result.hasNext());
776   
777  0 h.hideColumns(5, 10);
778  0 result = h.iterator();
779  0 int[] next = result.next();
780  0 assertEquals(5, next[0]);
781  0 assertEquals(10, next[1]);
782  0 assertFalse(result.hasNext());
783   
784  0 h.hideColumns(22, 23);
785  0 result = h.iterator();
786  0 next = result.next();
787  0 assertEquals(5, next[0]);
788  0 assertEquals(10, next[1]);
789  0 next = result.next();
790  0 assertEquals(22, next[0]);
791  0 assertEquals(23, next[1]);
792  0 assertFalse(result.hasNext());
793   
794    // test for only one hidden region at start of alignment
795  0 ColumnSelection sel = new ColumnSelection();
796  0 h.revealAllHiddenColumns(sel);
797  0 h.hideColumns(0, 1);
798  0 result = h.iterator();
799  0 next = result.next();
800  0 assertEquals(0, next[0]);
801  0 assertEquals(1, next[1]);
802  0 assertFalse(result.hasNext());
803    }
804   
805    /* @Test(groups = "Functional")
806    public void testGetVisibleSequenceStrings()
807    {
808    HiddenColumns h = new HiddenColumns();
809    SequenceI seq1 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
810    SequenceI seq2 = new Sequence("TEST2", "VICYHRNDTGA");
811    SequenceI[] seqs = new SequenceI[2];
812    seqs[0] = seq1;
813    seqs[1] = seq2;
814    String[] result = h.getVisibleSequenceStrings(5, 10, seqs);
815    assertEquals(2, result.length);
816    assertEquals("WKQES", result[0]);
817    assertEquals("RNDTG", result[1]);
818   
819    h.hideColumns(6, 8);
820    result = h.getVisibleSequenceStrings(5, 10, seqs);
821    assertEquals(2, result.length);
822    assertEquals("WS", result[0]);
823    assertEquals("RG", result[1]);
824   
825    SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
826    ColumnSelection sel = new ColumnSelection();
827    h.revealAllHiddenColumns(sel);
828    h.hideColumns(1, 3);
829    h.hideColumns(6, 11);
830    assertEquals("-D",
831    h.getVisibleSequenceStrings(0, 5, new SequenceI[]
832    { seq })[0]);
833    }*/
834   
 
835  0 toggle @Test(groups = "Functional")
836    public void testHideInsertionsFor()
837    {
838  0 HiddenColumns h = new HiddenColumns();
839  0 HiddenColumns h2 = new HiddenColumns();
840  0 SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT");
841  0 SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
842   
843  0 h.hideList(seq2.getInsertions());
844  0 assertTrue(h.equals(h2));
845  0 assertEquals(0, h.getSize());
846   
847  0 h.hideList(seq1.getInsertions());
848  0 h2.hideColumns(3, 5);
849  0 h2.hideColumns(9, 9);
850  0 h2.hideColumns(19, 20);
851  0 assertTrue(h.equals(h2));
852  0 assertEquals(6, h.getSize());
853    }
854   
 
855  0 toggle @Test(groups = "Functional")
856    public void testHideColumns_BitSet_range()
857    {
858  0 HiddenColumns h = new HiddenColumns();
859  0 HiddenColumns h2 = new HiddenColumns();
860   
861  0 BitSet tohide = new BitSet(25);
862  0 h.hideColumns(tohide);
863  0 assertTrue(h.equals(h2));
864   
865    // when setting bitset, first param is inclusive, second exclusive
866  0 tohide.set(3, 6);
867  0 tohide.set(9);
868  0 tohide.set(15, 21);
869  0 h.clearAndHideColumns(tohide, 5, 23);
870   
871  0 h2.hideColumns(5, 5);
872  0 h2.hideColumns(9, 9);
873  0 h2.hideColumns(15, 20);
874  0 assertTrue(h.equals(h2));
875  0 assertEquals(h.getSize(), h2.getSize());
876   
877  0 tohide.clear();
878  0 tohide.set(41);
879  0 h.clearAndHideColumns(tohide, 23, 30);
880  0 assertTrue(h.equals(h2));
881  0 assertEquals(h.getSize(), h2.getSize());
882   
883  0 tohide.set(41);
884  0 h.clearAndHideColumns(tohide, 30, 45);
885  0 h2.hideColumns(41, 41);
886  0 assertTrue(h.equals(h2));
887  0 assertEquals(h.getSize(), h2.getSize());
888   
889  0 tohide.clear();
890  0 tohide.set(25, 28);
891  0 h.clearAndHideColumns(tohide, 17, 50);
892  0 h2 = new HiddenColumns();
893  0 h2.hideColumns(5, 5);
894  0 h2.hideColumns(9, 9);
895  0 h2.hideColumns(15, 16);
896  0 h2.hideColumns(25, 27);
897  0 assertTrue(h.equals(h2));
898  0 assertEquals(h.getSize(), h2.getSize());
899   
900  0 HiddenColumns hc = new HiddenColumns();
901  0 hc.hideColumns(3, 5);
902  0 hc.hideColumns(15, 20);
903  0 hc.hideColumns(45, 60);
904   
905  0 tohide = new BitSet();
906   
907    // all unhidden if tohide is empty and range covers hidden
908  0 hc.clearAndHideColumns(tohide, 1, 70);
909  0 assertTrue(!hc.hasHiddenColumns());
910  0 assertEquals(0, hc.getSize());
911   
912  0 hc.hideColumns(3, 5);
913  0 hc.hideColumns(15, 20);
914  0 hc.hideColumns(45, 60);
915  0 assertEquals(25, hc.getSize());
916   
917    // but not if range does not cover hidden
918  0 hc.clearAndHideColumns(tohide, 23, 40);
919  0 assertTrue(hc.hasHiddenColumns());
920  0 assertEquals(25, hc.getSize());
921   
922    // and partial unhide if range partially covers
923  0 hc.clearAndHideColumns(tohide, 1, 17);
924  0 Iterator<int[]> it = hc.iterator();
925  0 assertTrue(it.hasNext());
926  0 int[] region = it.next();
927   
928  0 assertEquals(18, region[0]);
929  0 assertEquals(20, region[1]);
930   
931  0 assertTrue(it.hasNext());
932  0 region = it.next();
933   
934  0 assertEquals(45, region[0]);
935  0 assertEquals(60, region[1]);
936   
937  0 assertFalse(it.hasNext());
938  0 assertEquals(19, hc.getSize());
939    }
940   
 
941  0 toggle @Test(groups = "Functional")
942    public void testOffsetByVisibleColumns()
943    {
944  0 HiddenColumns h = new HiddenColumns();
945  0 int result = h.offsetByVisibleColumns(-1, 10);
946  0 assertEquals(9, result);
947   
948  0 h.hideColumns(7, 9);
949  0 result = h.offsetByVisibleColumns(-4, 10);
950  0 assertEquals(3, result);
951   
952  0 h.hideColumns(14, 15);
953  0 result = h.offsetByVisibleColumns(-4, 10);
954  0 assertEquals(3, result);
955   
956  0 result = h.offsetByVisibleColumns(-10, 17);
957  0 assertEquals(2, result);
958   
959  0 result = h.offsetByVisibleColumns(-1, 7);
960  0 assertEquals(5, result);
961   
962  0 result = h.offsetByVisibleColumns(-1, 8);
963  0 assertEquals(5, result);
964   
965  0 result = h.offsetByVisibleColumns(-3, 15);
966  0 assertEquals(10, result);
967   
968  0 ColumnSelection sel = new ColumnSelection();
969  0 h.revealAllHiddenColumns(sel);
970  0 h.hideColumns(0, 30);
971  0 result = h.offsetByVisibleColumns(-31, 0);
972  0 assertEquals(-31, result);
973   
974  0 HiddenColumns cs = new HiddenColumns();
975   
976    // test that without hidden columns, offsetByVisibleColumns returns
977    // position n to left of provided position
978  0 long pos = cs.offsetByVisibleColumns(-3, 10);
979  0 assertEquals(7, pos);
980   
981    // 0 returns same position
982  0 pos = cs.offsetByVisibleColumns(0, 10);
983  0 assertEquals(10, pos);
984   
985    // overflow to left returns negative number
986  0 pos = cs.offsetByVisibleColumns(-3, 0);
987  0 assertEquals(-3, pos);
988   
989    // test that with hidden columns to left of result column
990    // behaviour is the same as above
991  0 cs.hideColumns(1, 3);
992   
993    // position n to left of provided position
994  0 pos = cs.offsetByVisibleColumns(-3, 10);
995  0 assertEquals(7, pos);
996   
997    // 0 returns same position
998  0 pos = cs.offsetByVisibleColumns(0, 10);
999  0 assertEquals(10, pos);
1000   
1001    // test with one set of hidden columns between start and required position
1002  0 cs.hideColumns(12, 15);
1003  0 pos = cs.offsetByVisibleColumns(-8, 17);
1004  0 assertEquals(5, pos);
1005   
1006    // test with two sets of hidden columns between start and required position
1007  0 cs.hideColumns(20, 21);
1008  0 pos = cs.offsetByVisibleColumns(-8, 23);
1009  0 assertEquals(9, pos);
1010   
1011    // repeat last 2 tests with no hidden columns to left of required position
1012  0 ColumnSelection colsel = new ColumnSelection();
1013  0 cs.revealAllHiddenColumns(colsel);
1014   
1015    // test with one set of hidden columns between start and required position
1016  0 cs.hideColumns(12, 15);
1017  0 pos = cs.offsetByVisibleColumns(-8, 17);
1018  0 assertEquals(5, pos);
1019   
1020    // test with two sets of hidden columns between start and required position
1021  0 cs.hideColumns(20, 21);
1022  0 pos = cs.offsetByVisibleColumns(-8, 23);
1023  0 assertEquals(9, pos);
1024   
1025    // test with right (positive) offsets
1026   
1027    // test that without hidden columns, offsetByVisibleColumns returns
1028    // position n to right of provided position
1029  0 pos = cs.offsetByVisibleColumns(3, 7);
1030  0 assertEquals(10, pos);
1031   
1032    // test that with hidden columns to left of result column
1033    // behaviour is the same as above
1034  0 cs.hideColumns(1, 3);
1035   
1036    // test with one set of hidden columns between start and required position
1037  0 cs.hideColumns(12, 15);
1038  0 pos = cs.offsetByVisibleColumns(8, 5);
1039  0 assertEquals(17, pos);
1040   
1041    // test with two sets of hidden columns between start and required position
1042  0 cs.hideColumns(20, 21);
1043  0 pos = cs.offsetByVisibleColumns(8, 9);
1044  0 assertEquals(23, pos);
1045   
1046    // repeat last 2 tests with no hidden columns to left of required position
1047  0 colsel = new ColumnSelection();
1048  0 cs.revealAllHiddenColumns(colsel);
1049   
1050    // test with one set of hidden columns between start and required position
1051  0 cs.hideColumns(12, 15);
1052  0 pos = cs.offsetByVisibleColumns(8, 5);
1053  0 assertEquals(17, pos);
1054   
1055    // test with two sets of hidden columns between start and required position
1056  0 cs.hideColumns(20, 21);
1057  0 pos = cs.offsetByVisibleColumns(8, 9);
1058  0 assertEquals(23, pos);
1059    }
1060   
 
1061  0 toggle @Test(groups = "Functional")
1062    public void testBoundedIterator()
1063    {
1064  0 HiddenColumns h = new HiddenColumns();
1065  0 Iterator<int[]> it = h.getBoundedIterator(0, 10);
1066   
1067    // no hidden columns = nothing to iterate over
1068  0 assertFalse(it.hasNext());
1069   
1070    // [start,end] contains all hidden columns
1071    // all regions are returned
1072  0 h.hideColumns(3, 10);
1073  0 h.hideColumns(14, 16);
1074  0 it = h.getBoundedIterator(0, 20);
1075  0 assertTrue(it.hasNext());
1076  0 int[] next = it.next();
1077  0 assertEquals(3, next[0]);
1078  0 assertEquals(10, next[1]);
1079  0 next = it.next();
1080  0 assertEquals(14, next[0]);
1081  0 assertEquals(16, next[1]);
1082  0 assertFalse(it.hasNext());
1083   
1084    // [start,end] overlaps a region
1085    // 1 region returned
1086  0 it = h.getBoundedIterator(5, 7);
1087  0 assertTrue(it.hasNext());
1088  0 next = it.next();
1089  0 assertEquals(3, next[0]);
1090  0 assertEquals(10, next[1]);
1091  0 assertFalse(it.hasNext());
1092   
1093    // [start,end] fully contains 1 region and start of last
1094    // - 2 regions returned
1095  0 it = h.getBoundedIterator(3, 15);
1096  0 assertTrue(it.hasNext());
1097  0 next = it.next();
1098  0 assertEquals(3, next[0]);
1099  0 assertEquals(10, next[1]);
1100  0 next = it.next();
1101  0 assertEquals(14, next[0]);
1102  0 assertEquals(16, next[1]);
1103  0 assertFalse(it.hasNext());
1104   
1105    // [start,end] contains end of first region and whole of last region
1106    // - 2 regions returned
1107  0 it = h.getBoundedIterator(4, 20);
1108  0 assertTrue(it.hasNext());
1109  0 next = it.next();
1110  0 assertEquals(3, next[0]);
1111  0 assertEquals(10, next[1]);
1112  0 next = it.next();
1113  0 assertEquals(14, next[0]);
1114  0 assertEquals(16, next[1]);
1115  0 assertFalse(it.hasNext());
1116    }
1117   
 
1118  0 toggle @Test(groups = "Functional")
1119    public void testBoundedStartIterator()
1120    {
1121  0 HiddenColumns h = new HiddenColumns();
1122  0 Iterator<Integer> it = h.getStartRegionIterator(0, 10);
1123   
1124    // no hidden columns = nothing to iterate over
1125  0 assertFalse(it.hasNext());
1126   
1127    // [start,end] contains all hidden columns
1128    // all regions are returned
1129  0 h.hideColumns(3, 10);
1130  0 h.hideColumns(14, 16);
1131  0 it = h.getStartRegionIterator(0, 20);
1132  0 assertTrue(it.hasNext());
1133  0 int next = it.next();
1134  0 assertEquals(3, next);
1135  0 next = it.next();
1136  0 assertEquals(6, next);
1137  0 assertFalse(it.hasNext());
1138   
1139    // [start,end] does not contain a start of a region
1140    // no regions to iterate over
1141  0 it = h.getStartRegionIterator(4, 5);
1142  0 assertFalse(it.hasNext());
1143   
1144    // [start,end] fully contains 1 region and start of last
1145    // - 2 regions returned
1146  0 it = h.getStartRegionIterator(3, 7);
1147  0 assertTrue(it.hasNext());
1148  0 next = it.next();
1149  0 assertEquals(3, next);
1150  0 next = it.next();
1151  0 assertEquals(6, next);
1152  0 assertFalse(it.hasNext());
1153   
1154    // [start,end] contains whole of last region
1155    // - 1 region returned
1156  0 it = h.getStartRegionIterator(4, 20);
1157  0 assertTrue(it.hasNext());
1158  0 next = it.next();
1159  0 assertEquals(6, next);
1160  0 assertFalse(it.hasNext());
1161    }
1162   
 
1163  0 toggle @Test(groups = "Functional")
1164    public void testVisibleBlocksVisBoundsIterator()
1165    {
1166  0 HiddenColumns h = new HiddenColumns();
1167  0 Iterator<int[]> regions = h.getVisContigsIterator(0, 31, true);
1168   
1169    // only 1 visible region spanning 0-30 if nothing is hidden
1170  0 assertTrue(regions.hasNext());
1171  0 int[] region = regions.next();
1172  0 assertEquals(0, region[0]);
1173  0 assertEquals(30, region[1]);
1174  0 assertFalse(regions.hasNext());
1175   
1176    // hide 1 region in middle
1177    // 2 regions one on either side
1178    // second region boundary accounts for hidden columns
1179  0 h.hideColumns(10, 15);
1180  0 regions = h.getVisContigsIterator(0, 31, true);
1181   
1182  0 assertTrue(regions.hasNext());
1183  0 region = regions.next();
1184  0 assertEquals(0, region[0]);
1185  0 assertEquals(9, region[1]);
1186  0 region = regions.next();
1187  0 assertEquals(16, region[0]);
1188  0 assertEquals(36, region[1]);
1189  0 assertFalse(regions.hasNext());
1190   
1191    // single hidden region at left
1192  0 h = new HiddenColumns();
1193  0 h.hideColumns(0, 5);
1194  0 regions = h.getVisContigsIterator(0, 31, true);
1195   
1196  0 assertTrue(regions.hasNext());
1197  0 region = regions.next();
1198  0 assertEquals(6, region[0]);
1199  0 assertEquals(36, region[1]);
1200  0 assertFalse(regions.hasNext());
1201   
1202    // single hidden region at right
1203  0 h = new HiddenColumns();
1204  0 h.hideColumns(27, 30);
1205  0 regions = h.getVisContigsIterator(0, 31, true);
1206   
1207  0 assertTrue(regions.hasNext());
1208  0 region = regions.next();
1209  0 assertEquals(0, region[0]);
1210  0 assertEquals(26, region[1]);
1211  0 region = regions.next();
1212  0 assertEquals(31, region[0]);
1213  0 assertEquals(34, region[1]);
1214  0 assertFalse(regions.hasNext());
1215   
1216    // hidden region at left + hidden region in middle
1217  0 h = new HiddenColumns();
1218  0 h.hideColumns(0, 5);
1219  0 h.hideColumns(23, 25);
1220  0 regions = h.getVisContigsIterator(0, 31, true);
1221   
1222  0 assertTrue(regions.hasNext());
1223  0 region = regions.next();
1224  0 assertEquals(6, region[0]);
1225  0 assertEquals(22, region[1]);
1226  0 region = regions.next();
1227  0 assertEquals(26, region[0]);
1228  0 assertEquals(39, region[1]);
1229  0 assertFalse(regions.hasNext());
1230   
1231    // hidden region at right + hidden region in middle
1232  0 h = new HiddenColumns();
1233  0 h.hideColumns(27, 30);
1234  0 h.hideColumns(11, 14);
1235  0 regions = h.getVisContigsIterator(0, 31, true);
1236   
1237  0 assertTrue(regions.hasNext());
1238  0 region = regions.next();
1239  0 assertEquals(0, region[0]);
1240  0 assertEquals(10, region[1]);
1241  0 region = regions.next();
1242  0 assertEquals(15, region[0]);
1243  0 assertEquals(26, region[1]);
1244  0 region = regions.next();
1245  0 assertEquals(31, region[0]);
1246  0 assertEquals(38, region[1]);
1247  0 assertFalse(regions.hasNext());
1248   
1249    // hidden region at left and right
1250  0 h = new HiddenColumns();
1251  0 h.hideColumns(27, 35);
1252  0 h.hideColumns(0, 4);
1253  0 regions = h.getVisContigsIterator(0, 31, true);
1254   
1255  0 assertTrue(regions.hasNext());
1256  0 region = regions.next();
1257  0 assertEquals(5, region[0]);
1258  0 assertEquals(26, region[1]);
1259  0 region = regions.next();
1260  0 assertEquals(36, region[0]);
1261  0 assertEquals(44, region[1]);
1262  0 assertFalse(regions.hasNext());
1263   
1264    // multiple hidden regions
1265  0 h = new HiddenColumns();
1266  0 h.hideColumns(1, 1);
1267  0 h.hideColumns(3, 5);
1268  0 h.hideColumns(9, 11);
1269  0 h.hideColumns(22, 26);
1270   
1271  0 regions = h.getVisContigsIterator(0, 31, true);
1272   
1273  0 assertTrue(regions.hasNext());
1274  0 region = regions.next();
1275  0 assertEquals(0, region[0]);
1276  0 assertEquals(0, region[1]);
1277  0 region = regions.next();
1278  0 assertEquals(2, region[0]);
1279  0 assertEquals(2, region[1]);
1280  0 region = regions.next();
1281  0 assertEquals(6, region[0]);
1282  0 assertEquals(8, region[1]);
1283  0 region = regions.next();
1284  0 assertEquals(12, region[0]);
1285  0 assertEquals(21, region[1]);
1286  0 region = regions.next();
1287  0 assertEquals(27, region[0]);
1288  0 assertEquals(42, region[1]);
1289  0 assertFalse(regions.hasNext());
1290    }
1291   
1292    /*
1293    * the VisibleColsIterator is tested elsewhere, this just tests that
1294    * it can be retrieved from HiddenColumns
1295    */
 
1296  0 toggle @Test(groups = "Functional")
1297    public void testGetVisibleColsIterator()
1298    {
1299  0 HiddenColumns h = new HiddenColumns();
1300  0 Iterator<Integer> it = h.getVisibleColsIterator(0, 10);
1301   
1302  0 assertTrue(it instanceof RangeElementsIterator);
1303    }
1304   
 
1305  0 toggle @Test(groups = "Functional")
1306    public void testHashCode()
1307    {
1308  0 HiddenColumns h = new HiddenColumns();
1309  0 h.hideColumns(0, 25);
1310   
1311  0 int result = h.hashCode();
1312  0 assertTrue(result > 0);
1313   
1314  0 h.hideColumns(30, 50);
1315  0 assertTrue(h.hashCode() > 0);
1316  0 assertTrue(result != h.hashCode());
1317    }
1318    }
  • Report generated by OpenClover v 4.4.1 on Tue Mar 10 2026 14:59:17 GMT using coverage data from Thu Jan 1 1970 01:00:00 GMT.
  • OpenClover is free and open-source software.