X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FAlignmentTest.java;h=d6e09fdb48d99129030e5c20c99b73655ed390b4;hb=refs%2Fheads%2Fbug%2FJAL-2507_rnasecstrstockholm;hp=0d6c8aeb07847ffe2e553185679e65e1f036fb28;hpb=06775313266c93eba687d73df794eba606145048;p=jalview.git diff --git a/test/jalview/datamodel/AlignmentTest.java b/test/jalview/datamodel/AlignmentTest.java index 0d6c8ae..d6e09fd 100644 --- a/test/jalview/datamodel/AlignmentTest.java +++ b/test/jalview/datamodel/AlignmentTest.java @@ -27,6 +27,7 @@ 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; @@ -619,6 +620,67 @@ 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()); + + // 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() { @@ -1137,4 +1199,135 @@ public class AlignmentTest assertSame(pep.getDatasetSequence(), cds.getDBRefs()[0].map.to); } + @Test(groups = { "Functional" }) + public void testFindGroup() + { + SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI"); + SequenceI seq2 = new Sequence("seq2", "---JKLMNO---"); + AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 }); + + assertNull(a.findGroup(null, 0)); + assertNull(a.findGroup(seq1, 1)); + assertNull(a.findGroup(seq1, -1)); + + /* + * add a group consisting of just "DEF" + */ + SequenceGroup sg1 = new SequenceGroup(); + sg1.addSequence(seq1, false); + sg1.setStartRes(3); + sg1.setEndRes(5); + a.addGroup(sg1); + + assertNull(a.findGroup(seq1, 2)); // position not in group + assertNull(a.findGroup(seq1, 6)); // position not in group + assertNull(a.findGroup(seq2, 5)); // sequence not in group + assertSame(a.findGroup(seq1, 3), sg1); // yes + assertSame(a.findGroup(seq1, 4), sg1); + assertSame(a.findGroup(seq1, 5), sg1); + + /* + * add a group consisting of + * EF-- + * KLMN + */ + SequenceGroup sg2 = new SequenceGroup(); + sg2.addSequence(seq1, false); + sg2.addSequence(seq2, false); + sg2.setStartRes(4); + sg2.setEndRes(7); + a.addGroup(sg2); + + assertNull(a.findGroup(seq1, 2)); // unchanged + assertSame(a.findGroup(seq1, 3), sg1); // unchanged + /* + * if a residue is in more than one group, method returns + * the first found (in order groups were added) + */ + assertSame(a.findGroup(seq1, 4), sg1); + assertSame(a.findGroup(seq1, 5), sg1); + + /* + * seq2 only belongs to the second group + */ + assertSame(a.findGroup(seq2, 4), sg2); + assertSame(a.findGroup(seq2, 5), sg2); + assertSame(a.findGroup(seq2, 6), sg2); + assertSame(a.findGroup(seq2, 7), sg2); + assertNull(a.findGroup(seq2, 3)); + 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); + } }