import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
+import java.util.Iterator;
import java.util.List;
import java.util.Random;
HiddenColumns cs = new HiddenColumns();
int[] visible = cs.getVisibleContigs(3, 10);
- assertEquals("[]", Arrays.toString(visible));
+ assertEquals("[3, 9]", Arrays.toString(visible));
cs.hideColumns(3, 6);
cs.hideColumns(8, 9);
Arrays.toString(cs2.getHiddenColumnsCopy().get(1)));
}
+ @Test(groups = "Functional")
+ public void testCopyConstructor2()
+ {
+ HiddenColumns cs = new HiddenColumns();
+ cs.hideColumns(10, 11);
+ cs.hideColumns(5, 7);
+
+ HiddenColumns cs2 = new HiddenColumns(cs, 3, 9, 1);
+ assertTrue(cs2.hasHiddenColumns());
+
+ // only [5,7] returned, offset by 1
+ assertEquals("[4, 6]",
+ Arrays.toString(cs2.getHiddenColumnsCopy().get(0)));
+ assertEquals(3, cs2.getSize());
+
+ cs2 = new HiddenColumns(cs, 8, 15, 4);
+ assertTrue(cs2.hasHiddenColumns());
+
+ // only [10,11] returned, offset by 4
+ assertEquals("[6, 7]",
+ Arrays.toString(cs2.getHiddenColumnsCopy().get(0)));
+ assertEquals(2, cs2.getSize());
+
+ cs2 = new HiddenColumns(cs, 6, 10, 4);
+ assertFalse(cs2.hasHiddenColumns());
+ }
+
/**
* Test the code used to locate the reference sequence ruler origin
*/
{
HiddenColumns hc = new HiddenColumns();
- List<Integer> positions = hc.findHiddenRegionPositions();
+ List<Integer> positions = hc.findHiddenRegionPositions(0, 20);
assertTrue(positions.isEmpty());
hc.hideColumns(3, 7);
hc.hideColumns(10, 10);
hc.hideColumns(14, 15);
- positions = hc.findHiddenRegionPositions();
+ positions = hc.findHiddenRegionPositions(0, 20);
assertEquals(3, positions.size());
assertEquals(3, positions.get(0).intValue());
assertEquals(5, positions.get(1).intValue());
assertEquals(8, positions.get(2).intValue());
+
+ positions = hc.findHiddenRegionPositions(7, 20);
+ assertEquals(2, positions.size());
+ assertEquals(5, positions.get(0).intValue());
+ assertEquals(8, positions.get(1).intValue());
+
+ positions = hc.findHiddenRegionPositions(11, 13);
+ assertEquals(0, positions.size());
+
+ positions = hc.findHiddenRegionPositions(7, 20);
+ assertEquals(2, positions.size());
+ assertEquals(5, positions.get(0).intValue());
+ assertEquals(8, positions.get(1).intValue());
+
+ positions = hc.findHiddenRegionPositions(0, 1);
+ assertEquals(0, positions.size());
+
+ positions = hc.findHiddenRegionPositions(17, 20);
+ assertEquals(0, positions.size());
+
+ positions = hc.findHiddenRegionPositions(10, 15);
+ assertEquals(2, positions.size());
+ assertEquals(5, positions.get(0).intValue());
+ assertEquals(8, positions.get(1).intValue());
}
@Test(groups = { "Functional" })
assertEquals(4, h.adjustForHiddenColumns(2));
}
- /*@Test(groups = "Functional")
- public void testCompensateForEdit()
- {
- HiddenColumns2 h = new HiddenColumns2();
-
- ColumnSelection sel = new ColumnSelection();
- assertNull(h.compensateForEdit(10, 3, sel));
-
- h.hideColumns(3, 4);
- List<int[]> result = h.compensateForEdit(10, 3, sel);
- assertEquals(0, result.size());
-
- // edit partially overlapping hidden
-
- h = new HiddenColumns2();
- h.hideColumns(15, 17);
- result = h.compensateForEdit(10, 6, sel);
- assertEquals(0, result.size());
-
- HiddenColumns2 h2 = new HiddenColumns2();
- h2.hideColumns(9, 11);
- assertTrue(h.equals(h2));
-
- // edit fully overlapping hidden
-
- h = new HiddenColumns2();
- h.hideColumns(15, 17);
- result = h.compensateForEdit(10, 8, sel);
- assertEquals(result.get(0)[0], 15);
- assertEquals(result.get(0)[1], 17);
- assertFalse(h.hasHiddenColumns());
-
- // edit at start
-
- h = new HiddenColumns2();
- h.hideColumns(0, 3);
- result = h.compensateForEdit(0, 4, sel);
- assertEquals(0, result.size());
- assertEquals(sel.getSelected().size(), 4);
- assertFalse(h.hasHiddenColumns());
- }*/
-
- /*@Test(groups = "Functional")
- public void testCompensateForDelEdits()
- {
- HiddenColumns2 h = new HiddenColumns2();
- HiddenColumns2 h2 = new HiddenColumns2();
-
- h.compensateForDelEdits(10, 3);
- assertFalse(h.hasHiddenColumns());
-
- h = new HiddenColumns2();
- h.hideColumns(3, 4);
- h.compensateForDelEdits(10, 3);
- h2.hideColumns(3, 4);
- assertTrue(h.equals(h2));
-
- h = new HiddenColumns2();
- h.hideColumns(15, 17);
- h.compensateForDelEdits(10, 6);
- h2 = new HiddenColumns2();
- h2.hideColumns(9, 11);
- assertTrue(h.equals(h2));
-
- h = new HiddenColumns2();
- h.hideColumns(15, 17);
- h.compensateForDelEdits(10, 8);
- h2 = new HiddenColumns2();
- h2.hideColumns(7, 9);
- assertTrue(h.equals(h2));
-
- h = new HiddenColumns2();
- h.hideColumns(0, 3);
- h.compensateForDelEdits(0, 4);
- h2 = new HiddenColumns2();
- h2.hideColumns(0, 0);
- assertTrue(h.equals(h2));
- }*/
-
@Test(groups = "Functional")
public void testGetHiddenBoundaryLeft()
{
ColumnSelection sel = new ColumnSelection();
h.revealAllHiddenColumns(sel);
h.hideColumns(0, 30);
- result = h.subtractVisibleColumns(31, 13);
- assertEquals(-18, result);
-
result = h.subtractVisibleColumns(31, 0);
assertEquals(-31, result);
+ }
+ @Test(groups = "Functional")
+ public void testBoundedIterator()
+ {
+ HiddenColumns h = new HiddenColumns();
+ Iterator<int[]> it = h.getBoundedIterator(0, 10, false);
+
+ // no hidden columns = nothing to iterate over
+ assertFalse(it.hasNext());
+
+ // [start,end] contains all hidden columns
+ // all regions are returned
+ h.hideColumns(3, 10);
+ h.hideColumns(14, 16);
+ it = h.getBoundedIterator(0, 20, false);
+ assertTrue(it.hasNext());
+ int[] next = it.next();
+ assertEquals(3, next[0]);
+ assertEquals(10, next[1]);
+ next = it.next();
+ assertEquals(14, next[0]);
+ assertEquals(16, next[1]);
+ assertFalse(it.hasNext());
+
+ // [start,end] overlaps a region
+ // 1 region returned
+ it = h.getBoundedIterator(5, 7, false);
+ assertTrue(it.hasNext());
+ next = it.next();
+ assertEquals(3, next[0]);
+ assertEquals(10, next[1]);
+ assertFalse(it.hasNext());
+
+ // [start,end] fully contains 1 region and start of last
+ // - 2 regions returned
+ it = h.getBoundedIterator(3, 15, false);
+ assertTrue(it.hasNext());
+ next = it.next();
+ assertEquals(3, next[0]);
+ assertEquals(10, next[1]);
+ next = it.next();
+ assertEquals(14, next[0]);
+ assertEquals(16, next[1]);
+ assertFalse(it.hasNext());
+
+ // [start,end] contains end of first region and whole of last region
+ // - 2 regions returned
+ it = h.getBoundedIterator(4, 20, false);
+ assertTrue(it.hasNext());
+ next = it.next();
+ assertEquals(3, next[0]);
+ assertEquals(10, next[1]);
+ next = it.next();
+ assertEquals(14, next[0]);
+ assertEquals(16, next[1]);
+ assertFalse(it.hasNext());
}
+ @Test(groups = "Functional")
+ public void testBoundedStartIterator()
+ {
+ HiddenColumns h = new HiddenColumns();
+ Iterator<Integer> it = h.getBoundedStartIterator(0, 10, false);
+
+ // no hidden columns = nothing to iterate over
+ assertFalse(it.hasNext());
+
+ // [start,end] contains all hidden columns
+ // all regions are returned
+ h.hideColumns(3, 10);
+ h.hideColumns(14, 16);
+ it = h.getBoundedStartIterator(0, 20, false);
+ assertTrue(it.hasNext());
+ int next = it.next();
+ assertEquals(3, next);
+ next = it.next();
+ assertEquals(6, next);
+ assertFalse(it.hasNext());
+
+ // [start,end] does not contain a start of a region
+ // no regions to iterate over
+ it = h.getBoundedStartIterator(4, 5, false);
+ assertFalse(it.hasNext());
+
+ // [start,end] fully contains 1 region and start of last
+ // - 2 regions returned
+ it = h.getBoundedStartIterator(3, 7, false);
+ assertTrue(it.hasNext());
+ next = it.next();
+ assertEquals(3, next);
+ next = it.next();
+ assertEquals(6, next);
+ assertFalse(it.hasNext());
+
+ // [start,end] contains whole of last region
+ // - 1 region returned
+ it = h.getBoundedStartIterator(4, 20, false);
+ assertTrue(it.hasNext());
+ next = it.next();
+ assertEquals(6, next);
+ assertFalse(it.hasNext());
+ }
}
git://source.jalview.org / jalview.git / blobdiff