X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FAlignmentTest.java;h=a3f909642282d45e403aee38918e2d5da2090ab6;hb=c794c5033adeee182b03a5ea92c0a7495a29661f;hp=7af77f54f79623c7fc35a89bc185601a2e54d173;hpb=a6875ff6ca7894443c98b1d068f78ea25c5bfc87;p=jalview.git diff --git a/test/jalview/datamodel/AlignmentTest.java b/test/jalview/datamodel/AlignmentTest.java index 7af77f5..a3f9096 100644 --- a/test/jalview/datamodel/AlignmentTest.java +++ b/test/jalview/datamodel/AlignmentTest.java @@ -27,16 +27,17 @@ import static org.testng.AssertJUnit.assertNull; import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; +import jalview.analysis.AlignmentGenerator; import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping; import jalview.gui.JvOptionPane; import jalview.io.DataSourceType; import jalview.io.FileFormat; import jalview.io.FileFormatI; import jalview.io.FormatAdapter; +import jalview.util.Comparison; import jalview.util.MapList; import java.io.IOException; -import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; @@ -247,7 +248,9 @@ public class AlignmentTest if (raiseAssert) { Assert.fail(message - + " DBRefEntry for sequence in alignment had map to sequence not in dataset"); + + " DBRefEntry " + dbr + " for sequence " + + seqds + + " in alignment has map to sequence not in dataset"); } return false; } @@ -619,6 +622,78 @@ public class AlignmentTest assertFalse(iter.hasNext()); } + /** + * Test method that returns annotations that match on reference sequence, + * label, or calcId. + */ + @Test(groups = { "Functional" }) + public void testFindAnnotations_bySeqLabelandorCalcId() + { + // TODO: finish testFindAnnotations_bySeqLabelandorCalcId test + /* Note - this is an incomplete test - need to check null or + * non-null [ matches, not matches ] behaviour for each of the three + * parameters..*/ + + // search for a single, unique calcId with wildcards on other params + Iterable anns = al.findAnnotations(null, + "CalcIdForD.melanogaster.2", null); + Iterator iter = anns.iterator(); + assertTrue(iter.hasNext()); + AlignmentAnnotation ann = iter.next(); + assertEquals("D.melanogaster.2", ann.sequenceRef.getName()); + assertFalse(iter.hasNext()); + + // save reference to test sequence reference parameter + SequenceI rseq = ann.sequenceRef; + + // search for annotation associated with a single sequence + anns = al.findAnnotations(rseq, null, null); + iter = anns.iterator(); + assertTrue(iter.hasNext()); + ann = iter.next(); + assertEquals("D.melanogaster.2", ann.sequenceRef.getName()); + assertFalse(iter.hasNext()); + + // search for annotation with a non-existant calcId + anns = al.findAnnotations(null, "CalcIdForD.melanogaster.?", null); + iter = anns.iterator(); + assertFalse(iter.hasNext()); + + // search for annotation with a particular label - expect three + anns = al.findAnnotations(null, null, "Secondary Structure"); + iter = anns.iterator(); + assertTrue(iter.hasNext()); + iter.next(); + assertTrue(iter.hasNext()); + iter.next(); + assertTrue(iter.hasNext()); + iter.next(); + // third found.. so + assertFalse(iter.hasNext()); + + // search for annotation on one sequence with a particular label - expect + // one + SequenceI sqfound; + anns = al.findAnnotations(sqfound = al.getSequenceAt(1), null, + "Secondary Structure"); + iter = anns.iterator(); + assertTrue(iter.hasNext()); + // expect reference to sequence 1 in the alignment + assertTrue(sqfound == iter.next().sequenceRef); + assertFalse(iter.hasNext()); + + // null on all parameters == find all annotations + anns = al.findAnnotations(null, null, null); + iter = anns.iterator(); + int n = al.getAlignmentAnnotation().length; + while (iter.hasNext()) + { + n--; + iter.next(); + } + assertTrue("Found " + n + " fewer annotations from search.", n == 0); + } + @Test(groups = { "Functional" }) public void testDeleteAllAnnotations_includingAutocalculated() { @@ -1045,35 +1120,6 @@ public class AlignmentTest "addSequence broke dataset reference integrity"); } - @Test(groups = "Functional") - public void getVisibleStartAndEndIndexTest() - { - Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); - AlignmentI align = new Alignment(new SequenceI[] { seq }); - ArrayList hiddenCols = new ArrayList(); - - int[] startEnd = align.getVisibleStartAndEndIndex(hiddenCols); - assertEquals(0, startEnd[0]); - assertEquals(25, startEnd[1]); - - hiddenCols.add(new int[] { 0, 0 }); - startEnd = align.getVisibleStartAndEndIndex(hiddenCols); - assertEquals(1, startEnd[0]); - assertEquals(25, startEnd[1]); - - hiddenCols.add(new int[] { 6, 9 }); - hiddenCols.add(new int[] { 11, 12 }); - startEnd = align.getVisibleStartAndEndIndex(hiddenCols); - assertEquals(1, startEnd[0]); - assertEquals(25, startEnd[1]); - - hiddenCols.add(new int[] { 24, 25 }); - startEnd = align.getVisibleStartAndEndIndex(hiddenCols); - System.out.println(startEnd[0] + " : " + startEnd[1]); - assertEquals(1, startEnd[0]); - assertEquals(23, startEnd[1]); - } - /** * Tests that dbrefs with mappings to sequence get updated if the sequence * acquires a dataset sequence @@ -1127,14 +1173,14 @@ public class AlignmentTest /* * verify peptide.cdsdbref.peptidedbref is now mapped to peptide dataset */ - DBRefEntry[] dbRefs = pep.getDBRefs(); - assertEquals(2, dbRefs.length); - assertSame(dna, dbRefs[0].map.to); - assertSame(cds, dbRefs[1].map.to); - assertEquals(1, dna.getDBRefs().length); - assertSame(pep.getDatasetSequence(), dna.getDBRefs()[0].map.to); - assertEquals(1, cds.getDBRefs().length); - assertSame(pep.getDatasetSequence(), cds.getDBRefs()[0].map.to); + List dbRefs = pep.getDBRefs(); + assertEquals(2, dbRefs.size()); + assertSame(dna, dbRefs.get(0).map.to); + assertSame(cds, dbRefs.get(1).map.to); + assertEquals(1, dna.getDBRefs().size()); + assertSame(pep.getDatasetSequence(), dna.getDBRefs().get(0).map.to); + assertEquals(1, cds.getDBRefs().size()); + assertSame(pep.getDatasetSequence(), cds.getDBRefs().get(0).map.to); } @Test(groups = { "Functional" }) @@ -1196,4 +1242,352 @@ public class AlignmentTest assertNull(a.findGroup(seq2, 8)); } + @Test(groups = { "Functional" }) + public void testDeleteSequenceByIndex() + { + // create random alignment + AlignmentGenerator gen = new AlignmentGenerator(false); + AlignmentI a = gen.generate(20, 15, 123, 5, 5); + + // delete sequence 10, alignment reduced by 1 + int height = a.getAbsoluteHeight(); + a.deleteSequence(10); + assertEquals(a.getAbsoluteHeight(), height - 1); + + // try to delete -ve index, nothing happens + a.deleteSequence(-1); + assertEquals(a.getAbsoluteHeight(), height - 1); + + // try to delete beyond end of alignment, nothing happens + a.deleteSequence(14); + assertEquals(a.getAbsoluteHeight(), height - 1); + } + + @Test(groups = { "Functional" }) + public void testDeleteSequenceBySeq() + { + // create random alignment + AlignmentGenerator gen = new AlignmentGenerator(false); + AlignmentI a = gen.generate(20, 15, 123, 5, 5); + + // delete sequence 10, alignment reduced by 1 + int height = a.getAbsoluteHeight(); + SequenceI seq = a.getSequenceAt(10); + a.deleteSequence(seq); + assertEquals(a.getAbsoluteHeight(), height - 1); + + // try to delete non-existent sequence, nothing happens + seq = new Sequence("cds", "GCCTCGGAT"); + assertEquals(a.getAbsoluteHeight(), height - 1); + } + + @Test(groups = { "Functional" }) + public void testDeleteHiddenSequence() + { + // create random alignment + AlignmentGenerator gen = new AlignmentGenerator(false); + AlignmentI a = gen.generate(20, 15, 123, 5, 5); + + // delete a sequence which is hidden, check it is NOT removed from hidden + // sequences + int height = a.getAbsoluteHeight(); + SequenceI seq = a.getSequenceAt(2); + a.getHiddenSequences().hideSequence(seq); + assertEquals(a.getHiddenSequences().getSize(), 1); + a.deleteSequence(2); + assertEquals(a.getAbsoluteHeight(), height - 1); + assertEquals(a.getHiddenSequences().getSize(), 1); + + // delete a sequence which is not hidden, check hiddenSequences are not + // affected + a.deleteSequence(10); + assertEquals(a.getAbsoluteHeight(), height - 2); + assertEquals(a.getHiddenSequences().getSize(), 1); + } + + @Test( + groups = "Functional", + expectedExceptions = { IllegalArgumentException.class }) + public void testSetDataset_selfReference() + { + SequenceI seq = new Sequence("a", "a"); + AlignmentI alignment = new Alignment(new SequenceI[] { seq }); + alignment.setDataset(alignment); + } + + @Test(groups = "Functional") + public void testAppend() + { + SequenceI seq = new Sequence("seq1", "FRMLPSRT-A--L-"); + AlignmentI alignment = new Alignment(new SequenceI[] { seq }); + alignment.setGapCharacter('-'); + SequenceI seq2 = new Sequence("seq1", "KP..L.FQII."); + AlignmentI alignment2 = new Alignment(new SequenceI[] { seq2 }); + alignment2.setGapCharacter('.'); + + alignment.append(alignment2); + + assertEquals('-', alignment.getGapCharacter()); + assertSame(seq, alignment.getSequenceAt(0)); + assertEquals("KP--L-FQII-", alignment.getSequenceAt(1) + .getSequenceAsString()); + + // todo test coverage for annotations, mappings, groups, + // hidden sequences, properties + } + + /** + * test that calcId == null on findOrCreate doesn't raise an NPE, and yields + * an annotation with a null calcId + * + */ + @Test(groups = "Functional") + public void testFindOrCreateForNullCalcId() + { + SequenceI seq = new Sequence("seq1", "FRMLPSRT-A--L-"); + AlignmentI alignment = new Alignment(new SequenceI[] { seq }); + + AlignmentAnnotation ala = alignment.findOrCreateAnnotation( + "Temperature Factor", null, false, seq, null); + assertNotNull(ala); + assertEquals(seq, ala.sequenceRef); + assertEquals("", ala.getCalcId()); + } + + @Test(groups = {"Functional"}) + public void testUpdateFromOrAddAnnotation() + { + SequenceI seq = new Sequence("seq1", "FRMLPSRT-A--L-"); + AlignmentI alignment = new Alignment(new SequenceI[] { seq }); + + AlignmentAnnotation ala = alignment.findOrCreateAnnotation( + "Temperature Factor", null, false, seq, null); + + assertNotNull(ala); + assertEquals(seq, ala.sequenceRef); + assertEquals("", ala.getCalcId()); + + // Assuming findOrCreateForNullCalcId passed then this should work + + assertTrue(ala == alignment.updateFromOrCopyAnnotation(ala)); + AlignmentAnnotation updatedAla = new AlignmentAnnotation(ala); + updatedAla.description = "updated Description"; + Assert.assertTrue( + ala == alignment.updateFromOrCopyAnnotation(updatedAla)); + Assert.assertEquals(ala.toString(), updatedAla.toString()); + updatedAla.calcId = "newCalcId"; + AlignmentAnnotation newUpdatedAla = alignment + .updateFromOrCopyAnnotation(updatedAla); + Assert.assertTrue(updatedAla != newUpdatedAla); + Assert.assertEquals(updatedAla.toString(), newUpdatedAla.toString()); + } + + @Test(groups = "Functional") + public void testPropagateInsertions() + { + // create an alignment with no gaps - this will be the profile seq and other + // JPRED seqs + AlignmentGenerator gen = new AlignmentGenerator(false); + AlignmentI al = gen.generate(25, 10, 1234, 0, 0); + + // get the profileseq + SequenceI profileseq = al.getSequenceAt(0); + SequenceI gappedseq = new Sequence(profileseq); + gappedseq.insertCharAt(5, al.getGapCharacter()); + gappedseq.insertCharAt(6, al.getGapCharacter()); + gappedseq.insertCharAt(7, al.getGapCharacter()); + gappedseq.insertCharAt(8, al.getGapCharacter()); + + // force different kinds of padding + al.getSequenceAt(3).deleteChars(2, 23); + al.getSequenceAt(4).deleteChars(2, 27); + al.getSequenceAt(5).deleteChars(10, 27); + + // create an alignment view with the gapped sequence + SequenceI[] seqs = new SequenceI[1]; + seqs[0] = gappedseq; + AlignmentI newal = new Alignment(seqs); + HiddenColumns hidden = new HiddenColumns(); + hidden.hideColumns(15, 17); + + AlignmentView view = new AlignmentView(newal, hidden, null, true, false, + false); + + // confirm that original contigs are as expected + Iterator visible = hidden.getVisContigsIterator(0, 25, false); + int[] region = visible.next(); + assertEquals("[0, 14]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[18, 24]", Arrays.toString(region)); + + // propagate insertions + HiddenColumns result = al.propagateInsertions(profileseq, view); + + // confirm that the contigs have changed to account for the gaps + visible = result.getVisContigsIterator(0, 25, false); + region = visible.next(); + assertEquals("[0, 10]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[14, 24]", Arrays.toString(region)); + + // confirm the alignment has been changed so that the other sequences have + // gaps inserted where the columns are hidden + assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[10])); + assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[11])); + assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[12])); + assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[13])); + assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[14])); + + } + + @Test(groups = "Functional") + public void testPropagateInsertionsOverlap() + { + // test propagateInsertions where gaps and hiddenColumns overlap + + // create an alignment with no gaps - this will be the profile seq and other + // JPRED seqs + AlignmentGenerator gen = new AlignmentGenerator(false); + AlignmentI al = gen.generate(20, 10, 1234, 0, 0); + + // get the profileseq + SequenceI profileseq = al.getSequenceAt(0); + SequenceI gappedseq = new Sequence(profileseq); + gappedseq.insertCharAt(5, al.getGapCharacter()); + gappedseq.insertCharAt(6, al.getGapCharacter()); + gappedseq.insertCharAt(7, al.getGapCharacter()); + gappedseq.insertCharAt(8, al.getGapCharacter()); + + // create an alignment view with the gapped sequence + SequenceI[] seqs = new SequenceI[1]; + seqs[0] = gappedseq; + AlignmentI newal = new Alignment(seqs); + + // hide columns so that some overlap with the gaps + HiddenColumns hidden = new HiddenColumns(); + hidden.hideColumns(7, 10); + + AlignmentView view = new AlignmentView(newal, hidden, null, true, false, + false); + + // confirm that original contigs are as expected + Iterator visible = hidden.getVisContigsIterator(0, 20, false); + int[] region = visible.next(); + assertEquals("[0, 6]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[11, 19]", Arrays.toString(region)); + assertFalse(visible.hasNext()); + + // propagate insertions + HiddenColumns result = al.propagateInsertions(profileseq, view); + + // confirm that the contigs have changed to account for the gaps + visible = result.getVisContigsIterator(0, 20, false); + region = visible.next(); + assertEquals("[0, 4]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[7, 19]", Arrays.toString(region)); + assertFalse(visible.hasNext()); + + // confirm the alignment has been changed so that the other sequences have + // gaps inserted where the columns are hidden + assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[4])); + assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[5])); + assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[6])); + assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[7])); + } + + @Test(groups = { "Functional" }) + public void testPadGaps() + { + SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); + SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); + SequenceI seq3 = new Sequence("seq2", "-PQR"); + AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); + a.setGapCharacter('.'); // this replaces existing gaps + assertEquals("ABCDEF..", seq1.getSequenceAsString()); + a.padGaps(); + // trailing gaps are pruned, short sequences padded with gap character + assertEquals("ABCDEF.", seq1.getSequenceAsString()); + assertEquals(".JKLMNO", seq2.getSequenceAsString()); + assertEquals(".PQR...", seq3.getSequenceAsString()); + } + + /** + * Test for setHiddenColumns, to check it returns true if the hidden columns + * have changed, else false + */ + @Test(groups = { "Functional" }) + public void testSetHiddenColumns() + { + AlignmentI al = new Alignment(new SequenceI[] {}); + assertFalse(al.getHiddenColumns().hasHiddenColumns()); + + HiddenColumns hc = new HiddenColumns(); + assertFalse(al.setHiddenColumns(hc)); // no change + assertSame(hc, al.getHiddenColumns()); + + hc.hideColumns(2, 4); + assertTrue(al.getHiddenColumns().hasHiddenColumns()); + + /* + * set a different object but with the same columns hidden + */ + HiddenColumns hc2 = new HiddenColumns(); + hc2.hideColumns(2, 4); + assertFalse(al.setHiddenColumns(hc2)); // no change + assertSame(hc2, al.getHiddenColumns()); + + assertTrue(al.setHiddenColumns(null)); + assertNull(al.getHiddenColumns()); + assertTrue(al.setHiddenColumns(hc)); + assertSame(hc, al.getHiddenColumns()); + + al.getHiddenColumns().hideColumns(10, 12); + hc2.hideColumns(10, 12); + assertFalse(al.setHiddenColumns(hc2)); // no change + + /* + * hide columns 15-16 then 17-18 in hc + * hide columns 15-18 in hc2 + * these are not now 'equal' objects even though they + * represent the same set of columns + */ + assertSame(hc2, al.getHiddenColumns()); + hc.hideColumns(15, 16); + hc.hideColumns(17, 18); + hc2.hideColumns(15, 18); + assertFalse(hc.equals(hc2)); + assertTrue(al.setHiddenColumns(hc)); // 'changed' + } + + @Test(groups = { "Functional" }) + public void testGetWidth() + { + SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); + SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); + SequenceI seq3 = new Sequence("seq2", "-PQR"); + AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); + + assertEquals(9, a.getWidth()); + + // width includes hidden columns + a.getHiddenColumns().hideColumns(2, 5); + assertEquals(9, a.getWidth()); + } + + @Test(groups = { "Functional" }) + public void testGetVisibleWidth() + { + SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); + SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); + SequenceI seq3 = new Sequence("seq2", "-PQR"); + AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); + + assertEquals(9, a.getVisibleWidth()); + + // width excludes hidden columns + a.getHiddenColumns().hideColumns(2, 5); + assertEquals(5, a.getVisibleWidth()); + } }