Merge branch 'releases/Release_2_10_4_Branch'

[jalview.git] / test / jalview / datamodel / HiddenColumnsTest.java

diff --git a/test/jalview/datamodel/HiddenColumnsTest.java b/test/jalview/datamodel/HiddenColumnsTest.java
index 45df6da..2916199 100644 (file)
--- a/test/jalview/datamodel/HiddenColumnsTest.java
+++ b/test/jalview/datamodel/HiddenColumnsTest.java
@@ -456,6 +456,8 @@ public class HiddenColumnsTest
   public void testIsVisible()
   {
     HiddenColumns cs = new HiddenColumns();
+    assertTrue(cs.isVisible(5));
+
     cs.hideColumns(2, 4);
     cs.hideColumns(6, 7);
     assertTrue(cs.isVisible(0));
@@ -488,11 +490,13 @@ public class HiddenColumnsTest
     assertEquals(2, cs.getNumberOfRegions());
     assertEquals("[49, 59]", Arrays.toString(regions.next()));
     assertEquals("[69, 79]", Arrays.toString(regions.next()));
+    assertEquals(22, cs.getSize());
 
     cs.hideColumns(48, 80);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[48, 80]", Arrays.toString(regions.next()));
+    assertEquals(33, cs.getSize());
 
     /*
      * another...joining hidden ranges
@@ -506,6 +510,7 @@ public class HiddenColumnsTest
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[10, 60]", Arrays.toString(regions.next()));
+    assertEquals(51, cs.getSize());
 
     /*
      * another...left overlap, subsumption, right overlap,
@@ -523,6 +528,7 @@ public class HiddenColumnsTest
     assertEquals(2, cs.getNumberOfRegions());
     assertEquals("[10, 50]", Arrays.toString(regions.next()));
     assertEquals("[60, 70]", Arrays.toString(regions.next()));
+    assertEquals(52, cs.getSize());
   }
 
   @Test(groups = { "Functional" })
@@ -537,22 +543,26 @@ public class HiddenColumnsTest
     cs = new HiddenColumns();
     cs.hideColumns(one);
     assertEquals(1, cs.getNumberOfRegions());
+    assertEquals(1, cs.getSize());
 
     one.set(2);
     cs = new HiddenColumns();
     cs.hideColumns(one);
     assertEquals(1, cs.getNumberOfRegions());
+    assertEquals(2, cs.getSize());
 
     one.set(3);
     cs = new HiddenColumns();
     cs.hideColumns(one);
     assertEquals(1, cs.getNumberOfRegions());
+    assertEquals(3, cs.getSize());
 
     // split
     one.clear(2);
     cs = new HiddenColumns();
     cs.hideColumns(one);
     assertEquals(2, cs.getNumberOfRegions());
+    assertEquals(2, cs.getSize());
 
     assertEquals(0, cs.visibleToAbsoluteColumn(0));
     assertEquals(2, cs.visibleToAbsoluteColumn(1));
@@ -562,6 +572,7 @@ public class HiddenColumnsTest
     one.clear(1);
     cs = new HiddenColumns();
     cs.hideColumns(one);
+    assertEquals(1, cs.getSize());
 
     assertEquals(1, cs.getNumberOfRegions());
 
@@ -572,50 +583,6 @@ public class HiddenColumnsTest
   }
 
   @Test(groups = { "Functional" })
-  public void hideColumns_BitSetAndRange()
-  {
-    HiddenColumns hc = new HiddenColumns();
-    hc.hideColumns(3, 5);
-    hc.hideColumns(15, 20);
-    hc.hideColumns(45, 60);
-
-    BitSet tohide = new BitSet();
-
-    // all unhidden if tohide is empty and range covers hidden
-    hc.hideColumns(tohide, 1, 70);
-    assertTrue(!hc.hasHiddenColumns());
-    assertEquals(0, hc.getSize());
-
-    hc.hideColumns(3, 5);
-    hc.hideColumns(15, 20);
-    hc.hideColumns(45, 60);
-    assertEquals(25, hc.getSize());
-
-    // but not if range does not cover hidden
-    hc.hideColumns(tohide, 23, 40);
-    assertTrue(hc.hasHiddenColumns());
-    assertEquals(25, hc.getSize());
-
-    // and partial unhide if range partially covers
-    hc.hideColumns(tohide, 1, 17);
-    Iterator<int[]> it = hc.iterator();
-    assertTrue(it.hasNext());
-    int[] region = it.next();
-
-    assertEquals(18, region[0]);
-    assertEquals(20, region[1]);
-
-    assertTrue(it.hasNext());
-    region = it.next();
-
-    assertEquals(45, region[0]);
-    assertEquals(60, region[1]);
-
-    assertFalse(it.hasNext());
-    assertEquals(19, hc.getSize());
-  }
-
-  @Test(groups = { "Functional" })
   public void testRegionsToString()
   {
     HiddenColumns hc = new HiddenColumns();
@@ -772,7 +739,7 @@ public class HiddenColumnsTest
   }
 
   @Test(groups = "Functional")
-  public void testGetHiddenBoundaryLeft()
+  public void testGetNextHiddenBoundary_Left()
   {
     HiddenColumns h = new HiddenColumns();
 
@@ -790,7 +757,7 @@ public class HiddenColumnsTest
   }
 
   @Test(groups = "Functional")
-  public void testGetNextHiddenBoundary()
+  public void testGetNextHiddenBoundary_Right()
   {
     HiddenColumns h = new HiddenColumns();
 
@@ -885,12 +852,14 @@ public class HiddenColumnsTest
 
     h.hideList(seq2.getInsertions());
     assertTrue(h.equals(h2));
+    assertEquals(0, h.getSize());
 
     h.hideList(seq1.getInsertions());
     h2.hideColumns(3, 5);
     h2.hideColumns(9, 9);
     h2.hideColumns(19, 20);
     assertTrue(h.equals(h2));
+    assertEquals(6, h.getSize());
   }
 
   @Test(groups = "Functional")
@@ -899,7 +868,7 @@ public class HiddenColumnsTest
     HiddenColumns h = new HiddenColumns();
     HiddenColumns h2 = new HiddenColumns();
 
-    BitSet tohide = new BitSet(21);
+    BitSet tohide = new BitSet(25);
     h.hideColumns(tohide);
     assertTrue(h.equals(h2));
 
@@ -907,7 +876,7 @@ public class HiddenColumnsTest
     tohide.set(3, 6);
     tohide.set(9);
     tohide.set(15, 21);
-    h.hideColumns(tohide, 5, 23);
+    h.clearAndHideColumns(tohide, 5, 23);
 
     h2.hideColumns(5, 5);
     h2.hideColumns(9, 9);
@@ -917,19 +886,19 @@ public class HiddenColumnsTest
 
     tohide.clear();
     tohide.set(41);
-    h.hideColumns(tohide, 23, 30);
+    h.clearAndHideColumns(tohide, 23, 30);
     assertTrue(h.equals(h2));
     assertEquals(h.getSize(), h2.getSize());
 
     tohide.set(41);
-    h.hideColumns(tohide, 30, 45);
+    h.clearAndHideColumns(tohide, 30, 45);
     h2.hideColumns(41, 41);
     assertTrue(h.equals(h2));
     assertEquals(h.getSize(), h2.getSize());
 
     tohide.clear();
     tohide.set(25, 28);
-    h.hideColumns(tohide, 17, 50);
+    h.clearAndHideColumns(tohide, 17, 50);
     h2 = new HiddenColumns();
     h2.hideColumns(5, 5);
     h2.hideColumns(9, 9);
@@ -937,6 +906,46 @@ public class HiddenColumnsTest
     h2.hideColumns(25, 27);
     assertTrue(h.equals(h2));
     assertEquals(h.getSize(), h2.getSize());
+
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(3, 5);
+    hc.hideColumns(15, 20);
+    hc.hideColumns(45, 60);
+
+    tohide = new BitSet();
+
+    // all unhidden if tohide is empty and range covers hidden
+    hc.clearAndHideColumns(tohide, 1, 70);
+    assertTrue(!hc.hasHiddenColumns());
+    assertEquals(0, hc.getSize());
+
+    hc.hideColumns(3, 5);
+    hc.hideColumns(15, 20);
+    hc.hideColumns(45, 60);
+    assertEquals(25, hc.getSize());
+
+    // but not if range does not cover hidden
+    hc.clearAndHideColumns(tohide, 23, 40);
+    assertTrue(hc.hasHiddenColumns());
+    assertEquals(25, hc.getSize());
+
+    // and partial unhide if range partially covers
+    hc.clearAndHideColumns(tohide, 1, 17);
+    Iterator<int[]> it = hc.iterator();
+    assertTrue(it.hasNext());
+    int[] region = it.next();
+
+    assertEquals(18, region[0]);
+    assertEquals(20, region[1]);
+
+    assertTrue(it.hasNext());
+    region = it.next();
+
+    assertEquals(45, region[0]);
+    assertEquals(60, region[1]);
+
+    assertFalse(it.hasNext());
+    assertEquals(19, hc.getSize());
   }
 
   @Test(groups = "Functional")
@@ -1120,7 +1129,7 @@ public class HiddenColumnsTest
   public void testBoundedStartIterator()
   {
     HiddenColumns h = new HiddenColumns();
-    Iterator<Integer> it = h.getBoundedStartIterator(0, 10);
+    Iterator<Integer> it = h.getStartRegionIterator(0, 10);
 
     // no hidden columns = nothing to iterate over
     assertFalse(it.hasNext());
@@ -1129,7 +1138,7 @@ public class HiddenColumnsTest
     // all regions are returned
     h.hideColumns(3, 10);
     h.hideColumns(14, 16);
-    it = h.getBoundedStartIterator(0, 20);
+    it = h.getStartRegionIterator(0, 20);
     assertTrue(it.hasNext());
     int next = it.next();
     assertEquals(3, next);
@@ -1139,12 +1148,12 @@ public class HiddenColumnsTest
 
     // [start,end] does not contain a start of a region
     // no regions to iterate over
-    it = h.getBoundedStartIterator(4, 5);
+    it = h.getStartRegionIterator(4, 5);
     assertFalse(it.hasNext());
 
     // [start,end] fully contains 1 region and start of last
     // - 2 regions returned
-    it = h.getBoundedStartIterator(3, 7);
+    it = h.getStartRegionIterator(3, 7);
     assertTrue(it.hasNext());
     next = it.next();
     assertEquals(3, next);
@@ -1154,7 +1163,7 @@ public class HiddenColumnsTest
 
     // [start,end] contains whole of last region
     // - 1 region returned
-    it = h.getBoundedStartIterator(4, 20);
+    it = h.getStartRegionIterator(4, 20);
     assertTrue(it.hasNext());
     next = it.next();
     assertEquals(6, next);
@@ -1300,7 +1309,7 @@ public class HiddenColumnsTest
     HiddenColumns h = new HiddenColumns();
     Iterator<Integer> it = h.getVisibleColsIterator(0, 10);
 
-    assertTrue(it instanceof VisibleColsIterator);
+    assertTrue(it instanceof RangeElementsIterator);
   }
 
   @Test(groups = "Functional")