JAL-4313 Test makeVisibleAnnotations

diff --git a/test/jalview/datamodel/AlignmentAnnotationTests.java b/test/jalview/datamodel/AlignmentAnnotationTests.java
index f9e99d0..6ffbfa9 100644 (file)
--- a/test/jalview/datamodel/AlignmentAnnotationTests.java
+++ b/test/jalview/datamodel/AlignmentAnnotationTests.java
@@ -20,18 +20,22 @@
  */
 package jalview.datamodel;
 
-import static org.testng.Assert.assertNull;
-import static org.testng.AssertJUnit.assertEquals;
-
 import jalview.analysis.AlignSeq;
 import jalview.gui.JvOptionPane;
 import jalview.io.AppletFormatAdapter;
 import jalview.io.FileFormat;
-
 import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import static jalview.datamodel.Annotation.EMPTY_ANNOTATION;
+import static jalview.testutils.Matchers.matchesAnnotations;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.testng.Assert.assertNull;
+import static org.testng.AssertJUnit.assertEquals;
+
 public class AlignmentAnnotationTests
 {
 
@@ -57,7 +61,7 @@ public class AlignmentAnnotationTests
     for (String key : alo.getProperties())
     {
       assertEquals("Property mismatch", alo.getProperty(key),
-              alc.getProperty(key));
+          alc.getProperty(key));
     }
   }
 
@@ -71,11 +75,11 @@ public class AlignmentAnnotationTests
     Annotation[] al = new Annotation[sq.getLength()];
     for (int i = 0; i < al.length; i++)
     {
-      al[i] = new Annotation(new Annotation("" + sq.getCharAt(i), "",
-              (char) 0, sq.findPosition(i)));
+      al[i] = new Annotation(new Annotation("" + sq.getCharAt(i), "", (char) 0,
+          sq.findPosition(i)));
     }
-    AlignmentAnnotation alan = new AlignmentAnnotation(
-            "For " + sq.getName(), "Fake alignment annot", al);
+    AlignmentAnnotation alan = new AlignmentAnnotation("For " + sq.getName(),
+        "Fake alignment annot", al);
     // create a sequence mapping for the annotation vector in its current state
     alan.createSequenceMapping(sq, sq.getStart(), false);
     alan.setProperty("CreatedBy", "createAnnotation");
@@ -90,20 +94,18 @@ public class AlignmentAnnotationTests
    */
   public static void testAnnotTransfer(AlignmentAnnotation ala)
   {
-    assertEquals(
-            "Failed - need annotation created by createAnnotation method",
-            ala.description, "Fake alignment annot");
+    assertEquals("Failed - need annotation created by createAnnotation method",
+        ala.description, "Fake alignment annot");
     ala.adjustForAlignment();
     for (int p = 0; p < ala.annotations.length; p++)
     {
       if (ala.annotations[p] != null)
       {
         assertEquals(
-                "Mismatch at position " + p
-                        + " between annotation position value and sequence"
-                        + ala.annotations[p],
-                (int) ala.annotations[p].value,
-                ala.sequenceRef.findPosition(p));
+            "Mismatch at position " + p
+                + " between annotation position value and sequence"
+                + ala.annotations[p],
+            (int) ala.annotations[p].value, ala.sequenceRef.findPosition(p));
       }
     }
   }
@@ -127,8 +129,7 @@ public class AlignmentAnnotationTests
     AlignmentAnnotation origTo = sqTo.getAnnotation()[0];
     createAnnotation(sqFrom);
     AlignmentAnnotation origFrom = sqFrom.getAnnotation()[0];
-    AlignSeq align = AlignSeq.doGlobalNWAlignment(sqFrom, sqTo,
-            AlignSeq.PEP);
+    AlignSeq align = AlignSeq.doGlobalNWAlignment(sqFrom, sqTo, AlignSeq.PEP);
     SequenceI alSeq1 = new Sequence(sqFrom.getName(), align.getAStr1());
     alSeq1.setStart(sqFrom.getStart() + align.getSeq1Start() - 1);
     alSeq1.setEnd(sqFrom.getStart() + align.getSeq1End() - 1);
@@ -137,21 +138,23 @@ public class AlignmentAnnotationTests
     alSeq2.setStart(sqTo.getStart() + align.getSeq2Start() - 1);
     alSeq2.setEnd(sqTo.getStart() + align.getSeq2End() - 1);
     alSeq2.setDatasetSequence(sqTo);
-    System.out.println(new AppletFormatAdapter().formatSequences(
-            FileFormat.Stockholm, new Alignment(new SequenceI[]
-            { sqFrom, alSeq1, sqTo, alSeq2 }), true));
+    System.out
+        .println(new AppletFormatAdapter()
+            .formatSequences(FileFormat.Stockholm,
+                new Alignment(new SequenceI[] { sqFrom, alSeq1, sqTo, alSeq2 }),
+                true));
 
     Mapping mp = align.getMappingFromS1(false);
 
     AlignmentAnnotation almap1 = new AlignmentAnnotation(
-            sqTo.getAnnotation()[0]);
+        sqTo.getAnnotation()[0]);
     almap1.liftOver(sqFrom, mp);
     assertEquals(almap1.sequenceRef, sqFrom);
     alSeq1.addAlignmentAnnotation(almap1);
     almap1.setSequenceRef(alSeq1);
     almap1.adjustForAlignment();
     AlignmentAnnotation almap2 = new AlignmentAnnotation(
-            sqFrom.getAnnotation()[0]);
+        sqFrom.getAnnotation()[0]);
     almap2.liftOver(sqTo, mp);
     assertEquals(almap2.sequenceRef, sqTo);
 
@@ -162,15 +165,15 @@ public class AlignmentAnnotationTests
     AlignmentI all = new Alignment(new SequenceI[] { alSeq1, alSeq2 });
     all.addAnnotation(almap1);
     all.addAnnotation(almap2);
-    System.out.println(new AppletFormatAdapter()
+    System.out
+        .println(new AppletFormatAdapter()
             .formatSequences(FileFormat.Stockholm, all, true));
 
     for (int p = 0; p < alSeq1.getLength(); p++)
     {
       Annotation orig1, trans1, orig2, trans2;
       trans2 = almap2.annotations[p];
-      orig2 = origFrom.annotations[alSeq1.findPosition(p)
-              - sqFrom.getStart()];
+      orig2 = origFrom.annotations[alSeq1.findPosition(p) - sqFrom.getStart()];
       orig1 = origTo.annotations[alSeq2.findPosition(p) - sqTo.getStart()];
       trans1 = almap1.annotations[p];
       if (trans1 == trans2)
@@ -178,20 +181,18 @@ public class AlignmentAnnotationTests
         System.out.println("Pos " + p + " mismatch");
         continue;
       }
-      assertEquals(
-              "Mismatch on Original From and transferred annotation on 2",
-              (orig2 != null) ? orig2.toString() : null,
-              (trans2 != null) ? trans2.toString() : null);
-      assertEquals(
-              "Mismatch on Original To and transferred annotation on 1",
-              (orig1 != null) ? orig1.toString() : null,
-              (trans1 != null) ? trans1.toString() : null);
+      assertEquals("Mismatch on Original From and transferred annotation on 2",
+          (orig2 != null) ? orig2.toString() : null,
+          (trans2 != null) ? trans2.toString() : null);
+      assertEquals("Mismatch on Original To and transferred annotation on 1",
+          (orig1 != null) ? orig1.toString() : null,
+          (trans1 != null) ? trans1.toString() : null);
       String alm1 = "" + (almap1.annotations.length > p
-              ? almap1.annotations[p].displayCharacter
-              : "Out of range");
+          ? almap1.annotations[p].displayCharacter
+          : "Out of range");
       String alm2 = "" + (almap2.annotations.length > p
-              ? almap2.annotations[p].displayCharacter
-              : "Out of range");
+          ? almap2.annotations[p].displayCharacter
+          : "Out of range");
       assertEquals("Position " + p + " " + alm1 + " " + alm2, alm1, alm2);
     }
   }
@@ -205,10 +206,10 @@ public class AlignmentAnnotationTests
     /*
      * Annotate positions 3/4/5 (CDE) with values 1/2/3
      */
-    Annotation[] anns = new Annotation[] { null, null, new Annotation(1),
-        new Annotation(2), new Annotation(3) };
+    Annotation[] anns = new Annotation[] {
+        null, null, new Annotation(1), new Annotation(2), new Annotation(3) };
     AlignmentAnnotation ann = new AlignmentAnnotation("SS",
-            "secondary structure", anns);
+        "secondary structure", anns);
     seq.addAlignmentAnnotation(ann);
 
     /*
@@ -247,7 +248,7 @@ public class AlignmentAnnotationTests
   public void testGetDefaultRnaHelixSymbol()
   {
     AlignmentAnnotation ann = new AlignmentAnnotation("SS",
-            "secondary structure", null);
+        "secondary structure", null);
     assertEquals("(", ann.getDefaultRnaHelixSymbol(4));
 
     Annotation[] anns = new Annotation[20];
@@ -276,7 +277,7 @@ public class AlignmentAnnotationTests
     for (int i = 0; i < expected.length(); i++)
     {
       assertEquals("column " + i, String.valueOf(expected.charAt(i)),
-              ann.getDefaultRnaHelixSymbol(i));
+          ann.getDefaultRnaHelixSymbol(i));
     }
 
     /*
@@ -296,7 +297,7 @@ public class AlignmentAnnotationTests
     for (int i = 0; i < expected.length(); i++)
     {
       assertEquals("column " + i, String.valueOf(expected.charAt(i)),
-              ann.getDefaultRnaHelixSymbol(i));
+          ann.getDefaultRnaHelixSymbol(i));
     }
   }
 
@@ -319,28 +320,32 @@ public class AlignmentAnnotationTests
     AlignmentAnnotation ann = null;
 
     ann = new AlignmentAnnotation("an", "some an", null);
-    Assert.assertFalse(ann.isQuantitative(),
+    Assert
+        .assertFalse(ann.isQuantitative(),
             "Empty annotation set should not be quantitative.");
 
     ann = new AlignmentAnnotation("an", "some an",
-            new Annotation[]
-            { newAnnotation("4"), newAnnotation("1"), newAnnotation("1"),
-                newAnnotation("0.1"), newAnnotation("0.3") });
-    Assert.assertTrue(ann.isQuantitative(),
+        new Annotation[] {
+            newAnnotation("4"), newAnnotation("1"), newAnnotation("1"),
+            newAnnotation("0.1"), newAnnotation("0.3") });
+    Assert
+        .assertTrue(ann.isQuantitative(),
             "All numbers annotation set should be quantitative.");
 
     ann = new AlignmentAnnotation("an", "some an",
-            new Annotation[]
-            { newAnnotation("E"), newAnnotation("E"), newAnnotation("E"),
-                newAnnotation("E"), newAnnotation("E") });
-    Assert.assertFalse(ann.isQuantitative(),
+        new Annotation[] {
+            newAnnotation("E"), newAnnotation("E"), newAnnotation("E"),
+            newAnnotation("E"), newAnnotation("E") });
+    Assert
+        .assertFalse(ann.isQuantitative(),
             "All 'E' annotation set should not be quantitative.");
 
     ann = new AlignmentAnnotation("an", "some an",
-            new Annotation[]
-            { newAnnotation("E"), newAnnotation("1"), newAnnotation("2"),
-                newAnnotation("3"), newAnnotation("E") });
-    Assert.assertTrue(ann.isQuantitative(),
+        new Annotation[] {
+            newAnnotation("E"), newAnnotation("1"), newAnnotation("2"),
+            newAnnotation("3"), newAnnotation("E") });
+    Assert
+        .assertTrue(ann.isQuantitative(),
             "Mixed 'E' annotation set should be quantitative.");
   }
 
@@ -348,16 +353,15 @@ public class AlignmentAnnotationTests
   public void testMakeVisibleAnnotation()
   {
     HiddenColumns h = new HiddenColumns();
-    Annotation[] anns = new Annotation[] { null, null, new Annotation(1),
-        new Annotation(2), new Annotation(3), null, null, new Annotation(4),
-        new Annotation(5), new Annotation(6), new Annotation(7),
-        new Annotation(8) };
-    AlignmentAnnotation ann = new AlignmentAnnotation("an", "some an",
-            anns);
+    Annotation[] anns = new Annotation[] {
+        null, null, new Annotation(1), new Annotation(2), new Annotation(3),
+        null, null, new Annotation(4), new Annotation(5), new Annotation(6),
+        new Annotation(7), new Annotation(8) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("an", "some an", anns);
 
     // null annotations
     AlignmentAnnotation emptyann = new AlignmentAnnotation("an", "some ann",
-            null);
+        null);
     emptyann.makeVisibleAnnotation(h);
     assertNull(emptyann.annotations);
 
@@ -387,10 +391,10 @@ public class AlignmentAnnotationTests
     assertEquals(3.0f, ann.annotations[1].value);
     assertNull(ann.annotations[2]);
 
-    anns = new Annotation[] { null, null, new Annotation(1),
-        new Annotation(2), new Annotation(3), null, null, new Annotation(4),
-        new Annotation(5), new Annotation(6), new Annotation(7),
-        new Annotation(8) };
+    anns = new Annotation[] {
+        null, null, new Annotation(1), new Annotation(2), new Annotation(3),
+        null, null, new Annotation(4), new Annotation(5), new Annotation(6),
+        new Annotation(7), new Annotation(8) };
     ann = new AlignmentAnnotation("an", "some an", anns);
     h.hideColumns(4, 7);
     ann.makeVisibleAnnotation(1, 9, h);
@@ -401,10 +405,10 @@ public class AlignmentAnnotationTests
     assertEquals(5.0f, ann.annotations[3].value);
     assertEquals(6.0f, ann.annotations[4].value);
 
-    anns = new Annotation[] { null, null, new Annotation(1),
-        new Annotation(2), new Annotation(3), null, null, new Annotation(4),
-        new Annotation(5), new Annotation(6), new Annotation(7),
-        new Annotation(8) };
+    anns = new Annotation[] {
+        null, null, new Annotation(1), new Annotation(2), new Annotation(3),
+        null, null, new Annotation(4), new Annotation(5), new Annotation(6),
+        new Annotation(7), new Annotation(8) };
     ann = new AlignmentAnnotation("an", "some an", anns);
     h.hideColumns(1, 2);
     ann.makeVisibleAnnotation(1, 9, h);
@@ -413,12 +417,12 @@ public class AlignmentAnnotationTests
     assertEquals(5.0f, ann.annotations[1].value);
     assertEquals(6.0f, ann.annotations[2].value);
 
-    anns = new Annotation[] { null, null, new Annotation(1),
-        new Annotation(2), new Annotation(3), null, null, new Annotation(4),
-        new Annotation(5), new Annotation(6), new Annotation(7),
-        new Annotation(8), new Annotation(9), new Annotation(10),
-        new Annotation(11), new Annotation(12), new Annotation(13),
-        new Annotation(14), new Annotation(15) };
+    anns = new Annotation[] {
+        null, null, new Annotation(1), new Annotation(2), new Annotation(3),
+        null, null, new Annotation(4), new Annotation(5), new Annotation(6),
+        new Annotation(7), new Annotation(8), new Annotation(9),
+        new Annotation(10), new Annotation(11), new Annotation(12),
+        new Annotation(13), new Annotation(14), new Annotation(15) };
     ann = new AlignmentAnnotation("an", "some an", anns);
     h = new HiddenColumns();
     h.hideColumns(5, 18);
@@ -431,4 +435,154 @@ public class AlignmentAnnotationTests
     assertNull(ann.annotations[0]);
     assertNull(ann.annotations[4]);
   }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_NullAnnotationsAndNoColsHidden()
+  {
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", null);
+    HiddenColumns hc = new HiddenColumns();
+    ann.makeVisibleAnnotation(hc);
+    assertThat(ann.annotations, is(nullValue()));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_NullAnnotationsAndTrim()
+  {
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", null);
+    HiddenColumns hc = new HiddenColumns();
+    ann.makeVisibleAnnotation(3, 5, hc);
+    assertThat(ann.annotations, is(nullValue()));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_NoColsHidden()
+  {
+    Annotation[] annots = new Annotation[] {
+        EMPTY_ANNOTATION, EMPTY_ANNOTATION, new Annotation(1),
+        new Annotation(2), new Annotation(3), EMPTY_ANNOTATION,
+        EMPTY_ANNOTATION, new Annotation(4), new Annotation(5),
+        EMPTY_ANNOTATION, new Annotation(6), new Annotation(7),
+        new Annotation(8) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    ann.makeVisibleAnnotation(hc);
+    assertThat(ann.annotations, matchesAnnotations(annots));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_HideCols()
+  {
+    Annotation[] annots = new Annotation[] {
+        new Annotation(0), new Annotation(1), new Annotation(2),
+        new Annotation(3), new Annotation(4), new Annotation(5),
+        new Annotation(6), new Annotation(7), new Annotation(8) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(2, 6);
+    ann.makeVisibleAnnotation(hc);
+    var expected = new Annotation[] {
+        new Annotation(0), new Annotation(1), new Annotation(7),
+        new Annotation(8) };
+    assertThat(ann.annotations, matchesAnnotations(expected));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_ExplicitFullWidthAndHideCols()
+  {
+    Annotation[] annots = new Annotation[] {
+        new Annotation(0), new Annotation(1), new Annotation(2),
+        new Annotation(3), new Annotation(4), new Annotation(5),
+        new Annotation(6), new Annotation(7), new Annotation(8),
+        new Annotation(9), new Annotation(10), new Annotation(11) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(4, 7);
+    ann.makeVisibleAnnotation(0, 11, hc);
+    assertThat(ann.annotations,
+        matchesAnnotations(new Annotation(0), new Annotation(1),
+            new Annotation(2), new Annotation(3), new Annotation(8),
+            new Annotation(9), new Annotation(10), new Annotation(11)));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_ExplicitFullWidthAndHideCols2()
+  {
+    Annotation[] annots = new Annotation[] {
+        new Annotation(0), new Annotation(1), new Annotation(2),
+        new Annotation(3), new Annotation(4), new Annotation(5),
+        new Annotation(6), new Annotation(7), new Annotation(8), };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(4, 7);
+    ann.makeVisibleAnnotation(0, 8, hc);
+    assertThat(ann.annotations,
+        matchesAnnotations(new Annotation(0), new Annotation(1),
+            new Annotation(2), new Annotation(3), new Annotation(8)));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_HideColsWithEmptyAnnots()
+  {
+    Annotation[] annots = new Annotation[] {
+        EMPTY_ANNOTATION, EMPTY_ANNOTATION, new Annotation(1),
+        new Annotation(2), new Annotation(3), EMPTY_ANNOTATION,
+        EMPTY_ANNOTATION, new Annotation(4), new Annotation(5),
+        EMPTY_ANNOTATION, new Annotation(6), new Annotation(7),
+        new Annotation(8) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(1, 3);
+    hc.hideColumns(8, 9);
+    ann.makeVisibleAnnotation(hc);
+    var expected = new Annotation[] {
+        EMPTY_ANNOTATION, new Annotation(3), EMPTY_ANNOTATION, EMPTY_ANNOTATION,
+        new Annotation(4), new Annotation(6), new Annotation(7),
+        new Annotation(8) };
+    assertThat(ann.annotations, matchesAnnotations(expected));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_HideColsWithNullAnnots()
+  {
+    Annotation[] annots = new Annotation[] {
+        null, null, new Annotation(2), null, new Annotation(4),
+        new Annotation(5), null, null };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(2, 4);
+    ann.makeVisibleAnnotation(hc);
+    var expected = new Annotation[] {
+        null, null, new Annotation(5), null, null };
+    assertThat(ann.annotations, matchesAnnotations(expected));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_Truncate()
+  {
+    Annotation[] annots = new Annotation[] {
+        new Annotation(0), new Annotation(1), new Annotation(2),
+        new Annotation(3), new Annotation(4), new Annotation(5),
+        new Annotation(6), new Annotation(7) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    ann.makeVisibleAnnotation(3, 6, new HiddenColumns());
+    assertThat(ann.annotations, matchesAnnotations(new Annotation(3),
+        new Annotation(4), new Annotation(5), new Annotation(6)));
+  }
+
+  @Test(groups = "Functional")
+  public void testMakeVisibleAnnotation_TruncateAndHideColumns()
+  {
+    Annotation[] annots = new Annotation[] {
+        new Annotation(0), new Annotation(1), new Annotation(2),
+        new Annotation(3), new Annotation(4), new Annotation(5),
+        new Annotation(6), new Annotation(7), new Annotation(8),
+        new Annotation(9), new Annotation(10), new Annotation(11) };
+    AlignmentAnnotation ann = new AlignmentAnnotation("label", "desc", annots);
+    HiddenColumns hc = new HiddenColumns();
+    hc.hideColumns(4, 7);
+    ann.makeVisibleAnnotation(1, 9, hc);
+    assertThat(ann.annotations,
+        matchesAnnotations(new Annotation(1), new Annotation(2),
+            new Annotation(3), new Annotation(8), new Annotation(9)));
+  }
 }