X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FSearchResultsTest.java;h=8059af9be0e984e89da0b580dba7dd36f1c1c7f0;hb=refs%2Fheads%2Fpatch%2FJAL-4062_sort_and_merge_contiguousregions;hp=3118d2a16a33be84f8cfe34c58d502a7927cee05;hpb=db438b70796b94abcc873a2dde1d3d46189346ed;p=jalview.git diff --git a/test/jalview/datamodel/SearchResultsTest.java b/test/jalview/datamodel/SearchResultsTest.java index 3118d2a..8059af9 100644 --- a/test/jalview/datamodel/SearchResultsTest.java +++ b/test/jalview/datamodel/SearchResultsTest.java @@ -26,40 +26,37 @@ import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; import java.util.BitSet; +import java.util.List; +import org.junit.Assert; +import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; +import jalview.gui.JvOptionPane; + public class SearchResultsTest { - @Test(groups = { "Functional" }) - public void testToString() + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() { - SequenceI seq = new Sequence("", "abcdefghijklm"); - SearchResultsI sr = new SearchResults(); - sr.addResult(seq, 1, 1); - assertEquals("0a", sr.toString()); - sr.addResult(seq, 3, 5); - assertEquals("0a2cde", sr.toString()); - - seq = new Sequence("", "pqrstuvwxy"); - sr.addResult(seq, 6, 7); - assertEquals("0a2cde5uv", sr.toString()); + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); } @Test(groups = { "Functional" }) - public void testGetCharacters() + public void testToString() { - SequenceI seq = new Sequence("", "abcdefghijklm"); - SearchResults sr = new SearchResults(); + SequenceI seq = new Sequence("Seq1", "abcdefghijklm"); + SearchResultsI sr = new SearchResults(); sr.addResult(seq, 1, 1); - assertEquals("a", sr.getCharacters()); + assertEquals("[Seq1/1-1]", sr.toString()); sr.addResult(seq, 3, 5); - assertEquals("acde", sr.getCharacters()); + assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString()); - seq = new Sequence("", "pqrstuvwxy"); + seq = new Sequence("Seq2", "pqrstuvwxy"); sr.addResult(seq, 6, 7); - assertEquals("acdeuv", sr.getCharacters()); + assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString()); } @Test(groups = { "Functional" }) @@ -76,7 +73,7 @@ public class SearchResultsTest assertTrue(sr2.equals(sr1)); // reflexive /* - * only one result is not empty + * if only one result is not empty */ sr1.addResult(seq1, 1, 1); assertTrue(sr1.equals(sr1)); @@ -190,6 +187,51 @@ public class SearchResultsTest assertEquals(5, m.getEnd()); } + @Test(groups = { "Functional" }) + public void testMatchContains() + { + SequenceI seq1 = new Sequence("", "abcdefghijklm"); + SequenceI seq2 = new Sequence("", "abcdefghijklm"); + SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5); + + assertTrue(m.contains(seq1, 2, 5)); + assertTrue(m.contains(seq1, 3, 5)); + assertTrue(m.contains(seq1, 2, 4)); + assertTrue(m.contains(seq1, 3, 3)); + + assertFalse(m.contains(seq1, 2, 6)); + assertFalse(m.contains(seq1, 1, 5)); + assertFalse(m.contains(seq1, 1, 8)); + assertFalse(m.contains(seq2, 3, 3)); + assertFalse(m.contains(null, 3, 3)); + } + + @Test(groups = { "Functional" }) + public void testMatchAdjacent() + { + SequenceI seq1 = new Sequence("", "abcdefghijklm"); + SequenceI seq2 = new Sequence("", "abcdefghijklm"); + SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5); + + assertTrue(m.adjacent(seq1, 2, 5)); + assertTrue(m.adjacent(seq1, 3, 5)); + assertTrue(m.adjacent(seq1, 2, 4)); + assertTrue(m.adjacent(seq1, 3, 3)); + + assertTrue(m.adjacent(seq1, 2, 6)); + assertTrue(m.adjacent(seq1, 1, 5)); + assertTrue(m.adjacent(seq1, 1, 8)); + assertFalse(m.adjacent(seq1, 0, 0)); + assertFalse(m.adjacent(seq1, 7, 8)); + assertTrue(m.adjacent(seq1, 6, 8)); + assertTrue(m.adjacent(seq1, 5, 8)); + assertTrue(m.adjacent(seq1, 0, 1)); + + + assertFalse(m.adjacent(seq2, 3, 3)); + assertFalse(m.adjacent(null, 3, 3)); + } + /** * test markColumns for creating column selections */ @@ -199,18 +241,24 @@ public class SearchResultsTest int marked = 0; SequenceI seq1 = new Sequence("", "abcdefghijklm"); SequenceI seq2 = new Sequence("", "abcdefghijklm"); - SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup(); + SequenceGroup s1g = new SequenceGroup(), s2g = new SequenceGroup(), + sallg = new SequenceGroup(); s1g.addSequence(seq1, false); s2g.addSequence(seq2, false); sallg.addSequence(seq1, false); sallg.addSequence(seq2, false); - + SearchResultsI sr = new SearchResults(); BitSet bs = new BitSet(); - - sr.addResult(seq1, 1,1); - sr.addResult(seq2, 1,2); - + + SearchResultMatchI srm = null; + srm = sr.addResult(seq1, 1, 1); + Assert.assertNotNull("addResult didn't return Match", srm); + srm = sr.addResult(seq2, 1, 2); + assertEquals("Sequence reference not set", seq2, srm.getSequence()); + assertEquals("match start incorrect", 1, srm.getStart()); + assertEquals("match end incorrect", 2, srm.getEnd()); + // set start/end range for groups to cover matches s1g.setStartRes(0); @@ -230,11 +278,10 @@ public class SearchResultsTest assertTrue("Didn't mark expected position", bs.get(0)); // now check return value for marking the same again assertEquals( - "Didn't count number of bits marked for existing marked set", - 0, + "Didn't count number of bits marked for existing marked set", 0, sr.markColumns(s1g, bs)); bs.clear(); - + /* * just seq2 */ @@ -242,8 +289,8 @@ public class SearchResultsTest assertEquals("Didn't mark expected number", 2, bs.cardinality()); assertEquals("Didn't return count of number of bits marked", 2, marked); assertTrue("Didn't mark expected position (1)", bs.get(0)); - assertTrue("Didn't mark expected position (2)", bs.get(0)); - + assertTrue("Didn't mark expected position (2)", bs.get(1)); + /* * both seq1 and seq2 * should be same as seq2 @@ -252,7 +299,7 @@ public class SearchResultsTest assertEquals(2, sr.markColumns(sallg, allbs)); assertEquals(bs, allbs); - // now check range selecvtion + // now check range selection /* * limit s2g to just the second column, sallg to the first column @@ -260,8 +307,163 @@ public class SearchResultsTest s2g.setStartRes(1); s2g.setEndRes(1); sallg.setEndRes(0); - BitSet tbs; - assertEquals(1, sr.markColumns(s2g, tbs = new BitSet())); - assertEquals(1, sr.markColumns(sallg, tbs = new BitSet())); + BitSet tbs = new BitSet(); + assertEquals("Group start/end didn't select columns to mark", 1, + sr.markColumns(s2g, tbs)); + assertEquals("Group start/end didn't select columns to mark", 1, + sr.markColumns(sallg, tbs)); + assertEquals( + "Didn't set expected number of columns in total for two successive marks", + 2, tbs.cardinality()); } + + /** + * Test to verify adding doesn't create duplicate results + */ + @Test(groups = { "Functional" }) + public void testAddResult() + { + SequenceI seq1 = new Sequence("", "abcdefghijklm"); + SearchResultsI sr = new SearchResults(); + sr.addResult(seq1, 3, 5); + assertEquals(1, sr.getCount()); + sr.addResult(seq1, 3, 5); + assertEquals(1, sr.getCount()); + sr.addResult(seq1, 3, 6); + assertEquals(2, sr.getCount()); + } + + /** + * Test to verify appending creates a minimal set of results + */ + @Test(groups = { "Functional" }) + public void testAppendResult() + { + SequenceI seq1 = new Sequence("", "abcdefghijklm"),seq2=new Sequence("","defdefdefdef"); + SearchResultsI sr = new SearchResults(); + sr.appendResult(seq1, 3, 5); + assertEquals(1, sr.getCount()); + sr.appendResult(seq1, 3, 6); + assertEquals(1, sr.getCount()); + sr.appendResult(seq1, 8, 8); + assertEquals(2, sr.getCount()); + sr.appendResult(seq1, 7, 7); + assertEquals(1, sr.getCount()); + sr.appendResult(seq2, 7, 7); + assertEquals(2, sr.getCount()); + sr.appendResult(seq2, 2, 7); + assertTrue(sr.appendResult(seq2, 7, 49)); + assertTrue(sr.appendResult(seq2, 0, 30)); + assertEquals(2, sr.getCount()); + int c=0; + for (SearchResultMatchI sre: sr.getResults()) + { + c++; + } + assertEquals(c,2); + + } + /** + * Test for method that checks if search results matches a sequence region + */ + @Test(groups = { "Functional" }) + public void testInvolvesSequence() + { + SequenceI dataset = new Sequence("genome", "ATGGCCCTTTAAGCAACATTT"); + // first 'exon': + SequenceI cds1 = new Sequence("cds1/1-12", "ATGGCCCTTTAA"); + cds1.setDatasetSequence(dataset); + // overlapping second 'exon': + SequenceI cds2 = new Sequence("cds2/7-18", "CTTTAAGCAACA"); + cds2.setDatasetSequence(dataset); + // unrelated sequence + SequenceI cds3 = new Sequence("cds3", "ATGGCCCTTTAAGCAACA"); + + SearchResults sr = new SearchResults(); + assertFalse(sr.involvesSequence(cds1)); + + /* + * cds1 and cds2 share the same dataset sequence, but + * only cds1 overlaps match 4:6 (fixes bug JAL-3613) + */ + sr.addResult(dataset, 4, 6); + assertTrue(sr.involvesSequence(cds1)); + assertFalse(sr.involvesSequence(cds2)); + assertFalse(sr.involvesSequence(cds3)); + + /* + * search results overlap cds2 only + */ + sr = new SearchResults(); + sr.addResult(dataset, 18, 18); + assertFalse(sr.involvesSequence(cds1)); + assertTrue(sr.involvesSequence(cds2)); + + /* + * add a search result overlapping cds1 + */ + sr.addResult(dataset, 1, 1); + assertTrue(sr.involvesSequence(cds1)); + assertTrue(sr.involvesSequence(cds2)); + + /* + * single search result overlapping both + */ + sr = new SearchResults(); + sr.addResult(dataset, 10, 12); + assertTrue(sr.involvesSequence(cds1)); + assertTrue(sr.involvesSequence(cds2)); + + /* + * search results matching aligned sequence + */ + sr = new SearchResults(); + sr.addResult(cds1, 10, 12); + assertTrue(sr.involvesSequence(cds1)); + assertFalse(sr.involvesSequence(cds2)); + sr.addResult(cds2, 1, 3); // no start-end overlap + assertFalse(sr.involvesSequence(cds2)); + sr.addResult(cds2, 7, 9); // start-end overlap + assertTrue(sr.involvesSequence(cds2)); + } + + /** + * Test extraction of Sequence objects for matched ranges on a sequence + */ + @Test(groups = { "Functional" }) + public void testGetSequences() + { + SequenceI seq1 = new Sequence("", "abcdefghijklm"); + SequenceI seq2 = new Sequence("", "nopqrstuvwxyz"); + seq2.setStart(23); + seq2.setEnd(35); + List seqres = null; + + SearchResultsI sr = new SearchResults(); + seqres = sr.getMatchingSubSequences(); + assertEquals(0, seqres.size()); + + sr.addResult(seq1, 3, 5); + seqres = sr.getMatchingSubSequences(); + + assertEquals(1, seqres.size()); + assertEquals("cde", seqres.get(0).getSequenceAsString()); + assertEquals(3, seqres.get(0).getStart()); + assertEquals(seq1, seqres.get(0).getDatasetSequence()); + + sr.addResult(seq1, 3, 6); + seqres = sr.getMatchingSubSequences(); + + assertEquals(2, seqres.size()); + assertEquals("cdef", seqres.get(1).getSequenceAsString()); + assertEquals(3, seqres.get(1).getStart()); + + // this is a quirk - match on 26-29 yields subsequence 27-30 + sr.addResult(seq2, 26, 29); + seqres = sr.getMatchingSubSequences(); + assertEquals(3, seqres.size()); + assertEquals("qrst", seqres.get(2).getSequenceAsString()); + assertEquals(26, seqres.get(2).getStart()); + } + }