From: Mateusz Warowny Date: Fri, 27 Oct 2023 13:11:57 +0000 (+0200) Subject: JAL-4313 Test makeVisibleAnnotations X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=a2e93a7f3acf8cf68ab89bc9d9af188543bdf6a3;p=jalview.git JAL-4313 Test makeVisibleAnnotations --- diff --git a/test/jalview/datamodel/AlignmentAnnotationTests.java b/test/jalview/datamodel/AlignmentAnnotationTests.java index f9e99d0..6ffbfa9 100644 --- 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))); + } }