JAL-2759 Rename hideInsertionsFor to hideList, after review

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

diff --git a/test/jalview/datamodel/HiddenColumnsTest.java b/test/jalview/datamodel/HiddenColumnsTest.java
index edd68b2..e6c9b32 100644 (file)
--- a/test/jalview/datamodel/HiddenColumnsTest.java
+++ b/test/jalview/datamodel/HiddenColumnsTest.java
@@ -68,22 +68,22 @@ public class HiddenColumnsTest
   public void testFindColumnPosition()
   {
     HiddenColumns cs = new HiddenColumns();
-    assertEquals(5, cs.findColumnPosition(5));
+    assertEquals(5, cs.absoluteToVisibleColumn(5));
 
     // hiding column 6 makes no difference
     cs.hideColumns(6, 6);
-    assertEquals(5, cs.findColumnPosition(5));
+    assertEquals(5, cs.absoluteToVisibleColumn(5));
 
     // hiding column 4 moves column 5 to column 4
     cs.hideColumns(4, 4);
-    assertEquals(4, cs.findColumnPosition(5));
+    assertEquals(4, cs.absoluteToVisibleColumn(5));
 
     // hiding column 4 moves column 4 to position 3
-    assertEquals(3, cs.findColumnPosition(4));
+    assertEquals(3, cs.absoluteToVisibleColumn(4));
 
     // hiding columns 1 and 2 moves column 5 to column 2
     cs.hideColumns(1, 2);
-    assertEquals(2, cs.findColumnPosition(5));
+    assertEquals(2, cs.absoluteToVisibleColumn(5));
 
     // check with > 1 hidden column regions
     // where some columns are in the hidden regions
@@ -93,25 +93,25 @@ public class HiddenColumnsTest
     cs2.hideColumns(40, 44);
 
     // hiding columns 5-10 and 20-27 moves column 8 to column 4
-    assertEquals(4, cs2.findColumnPosition(8));
+    assertEquals(4, cs2.absoluteToVisibleColumn(8));
 
     // and moves column 24 to 13
-    assertEquals(13, cs2.findColumnPosition(24));
+    assertEquals(13, cs2.absoluteToVisibleColumn(24));
 
     // and moves column 28 to 14
-    assertEquals(14, cs2.findColumnPosition(28));
+    assertEquals(14, cs2.absoluteToVisibleColumn(28));
 
     // and moves column 40 to 25
-    assertEquals(25, cs2.findColumnPosition(40));
+    assertEquals(25, cs2.absoluteToVisibleColumn(40));
 
     // check when hidden columns start at 0 that the visible column
     // is returned as 0
     HiddenColumns cs3 = new HiddenColumns();
     cs3.hideColumns(0, 4);
-    assertEquals(0, cs3.findColumnPosition(2));
+    assertEquals(0, cs3.absoluteToVisibleColumn(2));
 
     // check that column after the last hidden region doesn't crash
-    assertEquals(46, cs2.findColumnPosition(65));
+    assertEquals(46, cs2.absoluteToVisibleColumn(65));
   }
 
   @Test(groups = { "Functional" })
@@ -420,9 +420,9 @@ public class HiddenColumnsTest
             new SequenceI[]
     { new Sequence("refseqGaptest", "KTDVTI----------NFI-----G----L") });
     HiddenColumns cs = new HiddenColumns();
-    cs.hideInsertionsFor(al.getSequenceAt(0));
+    cs.hideList(al.getSequenceAt(0).getInsertions());
     assertEquals("G", ""
-            + al.getSequenceAt(0).getCharAt(cs.adjustForHiddenColumns(9)));
+            + al.getSequenceAt(0).getCharAt(cs.visibleToAbsoluteColumn(9)));
 
     // KM: no idea what this is meant to be testing... seems to be an unfinished
     // test
@@ -689,40 +689,40 @@ public class HiddenColumnsTest
     // one hidden range
     one.set(1);
     cs = new HiddenColumns();
-    cs.hideMarkedBits(one);
+    cs.hideColumns(one);
     assertEquals(1, cs.getNumberOfRegions());
 
     one.set(2);
     cs = new HiddenColumns();
-    cs.hideMarkedBits(one);
+    cs.hideColumns(one);
     assertEquals(1, cs.getNumberOfRegions());
 
     one.set(3);
     cs = new HiddenColumns();
-    cs.hideMarkedBits(one);
+    cs.hideColumns(one);
     assertEquals(1, cs.getNumberOfRegions());
 
     // split
     one.clear(2);
     cs = new HiddenColumns();
-    cs.hideMarkedBits(one);
+    cs.hideColumns(one);
     assertEquals(2, cs.getNumberOfRegions());
 
-    assertEquals(0, cs.adjustForHiddenColumns(0));
-    assertEquals(2, cs.adjustForHiddenColumns(1));
-    assertEquals(4, cs.adjustForHiddenColumns(2));
+    assertEquals(0, cs.visibleToAbsoluteColumn(0));
+    assertEquals(2, cs.visibleToAbsoluteColumn(1));
+    assertEquals(4, cs.visibleToAbsoluteColumn(2));
 
     // one again
     one.clear(1);
     cs = new HiddenColumns();
-    cs.hideMarkedBits(one);
+    cs.hideColumns(one);
 
     assertEquals(1, cs.getNumberOfRegions());
 
-    assertEquals(0, cs.adjustForHiddenColumns(0));
-    assertEquals(1, cs.adjustForHiddenColumns(1));
-    assertEquals(2, cs.adjustForHiddenColumns(2));
-    assertEquals(4, cs.adjustForHiddenColumns(3));
+    assertEquals(0, cs.visibleToAbsoluteColumn(0));
+    assertEquals(1, cs.visibleToAbsoluteColumn(1));
+    assertEquals(2, cs.visibleToAbsoluteColumn(2));
+    assertEquals(4, cs.visibleToAbsoluteColumn(3));
   }
 
   @Test(groups = { "Functional" })
@@ -746,7 +746,7 @@ public class HiddenColumnsTest
         assertTrue(fromMark.isEmpty());
       }
 
-      hc.hideMarkedBits(toMark);
+      hc.hideColumns(toMark);
 
       // see if we can recover bitfield
       hc.markHiddenRegions(fromMark = new BitSet());
@@ -771,7 +771,7 @@ public class HiddenColumnsTest
   }
 
   @Test(groups = "Functional")
-  public void testGetVisibleStartAndEndIndexTest()
+  public void testGetVisibleStartAndEndIndex()
   {
     Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
     AlignmentI align = new Alignment(new SequenceI[] { seq });
@@ -1009,22 +1009,22 @@ public class HiddenColumnsTest
   {
     HiddenColumns h = new HiddenColumns();
     // returns input value when there are no hidden columns
-    assertEquals(10, h.adjustForHiddenColumns(10));
+    assertEquals(10, h.visibleToAbsoluteColumn(10));
 
     h.hideColumns(20, 30);
-    assertEquals(10, h.adjustForHiddenColumns(10));
-    assertEquals(20 + 11, h.adjustForHiddenColumns(20));
-    assertEquals(35 + 11, h.adjustForHiddenColumns(35));
+    assertEquals(10, h.visibleToAbsoluteColumn(10));
+    assertEquals(20 + 11, h.visibleToAbsoluteColumn(20));
+    assertEquals(35 + 11, h.visibleToAbsoluteColumn(35));
 
     h.hideColumns(5, 7);
-    assertEquals(10 + 3, h.adjustForHiddenColumns(10));
-    assertEquals(20 + 14, h.adjustForHiddenColumns(20));
-    assertEquals(35 + 14, h.adjustForHiddenColumns(35));
+    assertEquals(10 + 3, h.visibleToAbsoluteColumn(10));
+    assertEquals(20 + 14, h.visibleToAbsoluteColumn(20));
+    assertEquals(35 + 14, h.visibleToAbsoluteColumn(35));
 
     ColumnSelection sel = new ColumnSelection();
     h.revealAllHiddenColumns(sel);
     h.hideColumns(0, 1);
-    assertEquals(4, h.adjustForHiddenColumns(2));
+    assertEquals(4, h.visibleToAbsoluteColumn(2));
   }
 
   @Test(groups = "Functional")
@@ -1139,10 +1139,10 @@ public class HiddenColumnsTest
     SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT");
     SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
 
-    h.hideInsertionsFor(seq2);
+    h.hideList(seq2.getInsertions());
     assertTrue(h.equals(h2));
 
-    h.hideInsertionsFor(seq1);
+    h.hideList(seq1.getInsertions());
     h2.hideColumns(3, 5);
     h2.hideColumns(9, 9);
     h2.hideColumns(19, 20);
@@ -1156,14 +1156,14 @@ public class HiddenColumnsTest
     HiddenColumns h2 = new HiddenColumns();
 
     BitSet tohide = new BitSet(21);
-    h.hideMarkedBits(tohide);
+    h.hideColumns(tohide);
     assertTrue(h.equals(h2));
 
     // NB in hideMarkedBits, the last bit is not set to hidden
     tohide.set(3, 6);
     tohide.set(9);
     tohide.set(19, 21);
-    h.hideMarkedBits(tohide);
+    h.hideColumns(tohide);
 
     h2.hideColumns(3, 5);
     h2.hideColumns(9, 9);