X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FAlignmentAnnotationTests.java;h=f9e99d0733e22fb2f53ae54c0d733deb7cc76230;hb=d043ce47fc710d3eb2629ba926a8a7417bd67d8c;hp=1aff519120f7793fba27fbc469028cf075f30f7b;hpb=267f5674a53a735d8e13a2a4c12a4c8d8b0c1f00;p=jalview.git diff --git a/test/jalview/datamodel/AlignmentAnnotationTests.java b/test/jalview/datamodel/AlignmentAnnotationTests.java index 1aff519..f9e99d0 100644 --- a/test/jalview/datamodel/AlignmentAnnotationTests.java +++ b/test/jalview/datamodel/AlignmentAnnotationTests.java @@ -20,16 +20,28 @@ */ package jalview.datamodel; +import static org.testng.Assert.assertNull; import static org.testng.AssertJUnit.assertEquals; -import static org.testng.AssertJUnit.assertNull; 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; public class AlignmentAnnotationTests { + + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() + { + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); + } + @Test(groups = { "Functional" }) public void testCopyConstructor() { @@ -37,6 +49,11 @@ public class AlignmentAnnotationTests createAnnotation(sq); AlignmentAnnotation alc, alo = sq.getAnnotation()[0]; alc = new AlignmentAnnotation(alo); + + // TODO: this only tests string equals (which is unreliable), should use + // refactored tests from StockholmFileTest + Assert.assertEquals(alc.toString(), alo.toString()); + for (String key : alo.getProperties()) { assertEquals("Property mismatch", alo.getProperty(key), @@ -57,8 +74,8 @@ public class AlignmentAnnotationTests 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"); @@ -81,9 +98,11 @@ public class AlignmentAnnotationTests { if (ala.annotations[p] != null) { - assertEquals("Mismatch at position " + p - + " between annotation position value and sequence" - + ala.annotations[p], (int) ala.annotations[p].value, + assertEquals( + "Mismatch at position " + p + + " between annotation position value and sequence" + + ala.annotations[p], + (int) ala.annotations[p].value, ala.sequenceRef.findPosition(p)); } } @@ -118,9 +137,9 @@ 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("STH", 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); @@ -143,8 +162,8 @@ public class AlignmentAnnotationTests AlignmentI all = new Alignment(new SequenceI[] { alSeq1, alSeq2 }); all.addAnnotation(almap1); all.addAnnotation(almap2); - System.out.println(new AppletFormatAdapter().formatSequences("STH", - all, true)); + System.out.println(new AppletFormatAdapter() + .formatSequences(FileFormat.Stockholm, all, true)); for (int p = 0; p < alSeq1.getLength(); p++) { @@ -167,12 +186,12 @@ public class AlignmentAnnotationTests "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"); - String alm2 = "" - + (almap2.annotations.length > p ? almap2.annotations[p].displayCharacter - : "Out of range"); + String alm1 = "" + (almap1.annotations.length > p + ? almap1.annotations[p].displayCharacter + : "Out of range"); + String alm2 = "" + (almap2.annotations.length > p + ? almap2.annotations[p].displayCharacter + : "Out of range"); assertEquals("Position " + p + " " + alm1 + " " + alm2, alm1, alm2); } } @@ -280,4 +299,136 @@ public class AlignmentAnnotationTests ann.getDefaultRnaHelixSymbol(i)); } } -} \ No newline at end of file + + public static Annotation newAnnotation(String ann) + { + float val = 0f; + try + { + val = Float.parseFloat(ann); + } catch (NumberFormatException q) + { + } + ; + return new Annotation(ann, ann, '\0', val); + } + + @Test(groups = { "Functional" }) + public void testIsQuantitative() + { + AlignmentAnnotation ann = null; + + ann = new AlignmentAnnotation("an", "some an", null); + 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(), + "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(), + "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(), + "Mixed 'E' annotation set should be quantitative."); + } + + @Test(groups = "Functional") + 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); + + // null annotations + AlignmentAnnotation emptyann = new AlignmentAnnotation("an", "some ann", + null); + emptyann.makeVisibleAnnotation(h); + assertNull(emptyann.annotations); + + emptyann.makeVisibleAnnotation(3, 4, h); + assertNull(emptyann.annotations); + + // without bounds, does everything + ann.makeVisibleAnnotation(h); + assertEquals(12, ann.annotations.length); + assertNull(ann.annotations[0]); + assertNull(ann.annotations[1]); + assertEquals(1.0f, ann.annotations[2].value); + assertEquals(2.0f, ann.annotations[3].value); + assertEquals(3.0f, ann.annotations[4].value); + assertNull(ann.annotations[5]); + assertNull(ann.annotations[6]); + assertEquals(4.0f, ann.annotations[7].value); + assertEquals(5.0f, ann.annotations[8].value); + assertEquals(6.0f, ann.annotations[9].value); + assertEquals(7.0f, ann.annotations[10].value); + assertEquals(8.0f, ann.annotations[11].value); + + // without hidden cols, just truncates + ann.makeVisibleAnnotation(3, 5, h); + assertEquals(3, ann.annotations.length); + assertEquals(2.0f, ann.annotations[0].value); + 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) }; + ann = new AlignmentAnnotation("an", "some an", anns); + h.hideColumns(4, 7); + ann.makeVisibleAnnotation(1, 9, h); + assertEquals(5, ann.annotations.length); + assertNull(ann.annotations[0]); + assertEquals(1.0f, ann.annotations[1].value); + assertEquals(2.0f, ann.annotations[2].value); + 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) }; + ann = new AlignmentAnnotation("an", "some an", anns); + h.hideColumns(1, 2); + ann.makeVisibleAnnotation(1, 9, h); + assertEquals(3, ann.annotations.length); + assertEquals(2.0f, ann.annotations[0].value); + 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) }; + ann = new AlignmentAnnotation("an", "some an", anns); + h = new HiddenColumns(); + h.hideColumns(5, 18); + h.hideColumns(20, 21); + ann.makeVisibleAnnotation(1, 21, h); + assertEquals(5, ann.annotations.length); + assertEquals(1.0f, ann.annotations[1].value); + assertEquals(2.0f, ann.annotations[2].value); + assertEquals(3.0f, ann.annotations[3].value); + assertNull(ann.annotations[0]); + assertNull(ann.annotations[4]); + } +}