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 6730626..2916199 100644 (file)
--- a/test/jalview/datamodel/HiddenColumnsTest.java
+++ b/test/jalview/datamodel/HiddenColumnsTest.java
@@ -273,6 +273,7 @@ public class HiddenColumnsTest
     Iterator<int[]> regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[5, 5]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 1);
 
     colsel.hideSelectedColumns(3, al.getHiddenColumns());
     regions = cs.iterator();
@@ -280,6 +281,7 @@ public class HiddenColumnsTest
     // two hidden ranges, in order:
     assertEquals("[3, 3]", Arrays.toString(regions.next()));
     assertEquals("[5, 5]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 2);
 
     // hiding column 4 expands [3, 3] to [3, 4]
     // and merges to [5, 5] to make [3, 5]
@@ -287,16 +289,19 @@ public class HiddenColumnsTest
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[3, 5]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 3);
 
     // clear hidden columns (note they are added to selected)
     cs.revealAllHiddenColumns(colsel);
     // it is now actually null but getter returns an empty list
     assertEquals(0, cs.getNumberOfRegions());
+    assertEquals(cs.getSize(), 0);
 
     cs.hideColumns(3, 6);
     regions = cs.iterator();
     int[] firstHiddenRange = regions.next();
     assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
+    assertEquals(cs.getSize(), 4);
 
     // adding a subrange of already hidden should do nothing
     cs.hideColumns(4, 5);
@@ -304,45 +309,53 @@ public class HiddenColumnsTest
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[3, 6]",
             Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 4);
     cs.hideColumns(3, 5);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[3, 6]",
             Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 4);
     cs.hideColumns(4, 6);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[3, 6]",
             Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 4);
     cs.hideColumns(3, 6);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[3, 6]",
             Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 4);
 
     cs.revealAllHiddenColumns(colsel);
     cs.hideColumns(2, 4);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[2, 4]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 3);
 
     // extend contiguous with 2 positions overlap
     cs.hideColumns(3, 5);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[2, 5]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 4);
 
     // extend contiguous with 1 position overlap
     cs.hideColumns(5, 6);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[2, 6]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 5);
 
     // extend contiguous with overlap both ends:
     cs.hideColumns(1, 7);
     regions = cs.iterator();
     assertEquals(1, cs.getNumberOfRegions());
     assertEquals("[1, 7]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 7);
 
     cs.revealAllHiddenColumns(colsel);
     cs.hideColumns(15, 18);
@@ -353,6 +366,7 @@ public class HiddenColumnsTest
     assertEquals("[2, 4]", Arrays.toString(regions.next()));
     assertEquals("[7, 9]", Arrays.toString(regions.next()));
     assertEquals("[15, 18]", Arrays.toString(regions.next()));
+    assertEquals(cs.getSize(), 10);
   }
 
   /**
@@ -442,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));
@@ -474,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
@@ -492,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,
@@ -509,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" })
@@ -523,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));
@@ -548,6 +572,7 @@ public class HiddenColumnsTest
     one.clear(1);
     cs = new HiddenColumns();
     cs.hideColumns(one);
+    assertEquals(1, cs.getSize());
 
     assertEquals(1, cs.getNumberOfRegions());
 
@@ -558,46 +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());
-
-    hc.hideColumns(3, 5);
-    hc.hideColumns(15, 20);
-    hc.hideColumns(45, 60);
-
-    // but not if range does not cover hidden
-    hc.hideColumns(tohide, 23, 40);
-    assertTrue(hc.hasHiddenColumns());
-
-    // 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());
-  }
-
-  @Test(groups = { "Functional" })
   public void testRegionsToString()
   {
     HiddenColumns hc = new HiddenColumns();
@@ -754,7 +739,7 @@ public class HiddenColumnsTest
   }
 
   @Test(groups = "Functional")
-  public void testGetHiddenBoundaryLeft()
+  public void testGetNextHiddenBoundary_Left()
   {
     HiddenColumns h = new HiddenColumns();
 
@@ -772,7 +757,7 @@ public class HiddenColumnsTest
   }
 
   @Test(groups = "Functional")
-  public void testGetNextHiddenBoundary()
+  public void testGetNextHiddenBoundary_Right()
   {
     HiddenColumns h = new HiddenColumns();
 
@@ -867,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")
@@ -881,38 +868,84 @@ 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));
 
-    // when setting bitset, first param is invlusive, second exclusive
+    // when setting bitset, first param is inclusive, second exclusive
     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);
     h2.hideColumns(15, 20);
     assertTrue(h.equals(h2));
+    assertEquals(h.getSize(), h2.getSize());
 
     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(17, 20);
+    h2.hideColumns(5, 5);
+    h2.hideColumns(9, 9);
+    h2.hideColumns(15, 16);
     h2.hideColumns(25, 27);
-    h2.hideColumns(41, 41);
+    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")
@@ -1096,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());
@@ -1105,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);
@@ -1115,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);
@@ -1130,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);
@@ -1276,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")