X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FSearchResultsTest.java;h=838b259ea0c93e1df519cfc9768b9d35e75428a2;hb=3d2750d886f1b6015b2fc3f8671a6cf3e32bb07a;hp=e3cbb00765a95c74809d60df6cc25e47bd8d0396;hpb=52402128d98c6744eb6348dd788fe6e8cd34575c;p=jalview.git

diff --git a/test/jalview/datamodel/SearchResultsTest.java b/test/jalview/datamodel/SearchResultsTest.java
index e3cbb00..838b259 100644
--- a/test/jalview/datamodel/SearchResultsTest.java
+++ b/test/jalview/datamodel/SearchResultsTest.java
@@ -25,41 +25,37 @@ import static org.testng.AssertJUnit.assertFalse;
 import static org.testng.AssertJUnit.assertSame;
 import static org.testng.AssertJUnit.assertTrue;
 
-import jalview.datamodel.SearchResults.Match;
+import java.util.BitSet;
 
+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 +72,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));
@@ -189,4 +185,186 @@ public class SearchResultsTest
     assertEquals(2, m.getStart());
     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 markColumns for creating column selections
+   */
+  @Test(groups = { "Functional" })
+  public void testMarkColumns()
+  {
+    int marked = 0;
+    SequenceI seq1 = new Sequence("", "abcdefghijklm");
+    SequenceI seq2 = new Sequence("", "abcdefghijklm");
+    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();
+    
+    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);
+    s1g.setEndRes(5);
+    s2g.setStartRes(0);
+    s2g.setEndRes(5);
+    sallg.setStartRes(0);
+    sallg.setEndRes(5);
+
+    /*
+     * just seq1
+     */
+    marked = sr.markColumns(s1g, bs);
+    // check the bitset cardinality before checking the return value
+    assertEquals("Didn't mark expected number", 1, bs.cardinality());
+    assertEquals("Didn't return count of number of bits marked", 1, marked);
+    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,
+            sr.markColumns(s1g, bs));
+    bs.clear();
+    
+    /*
+     * just seq2
+     */
+    marked = sr.markColumns(s2g, bs);
+    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(1));
+    
+    /*
+     * both seq1 and seq2 
+     * should be same as seq2
+     */
+    BitSet allbs = new BitSet();
+    assertEquals(2, sr.markColumns(sallg, allbs));
+    assertEquals(bs, allbs);
+
+    // now check range selection
+
+    /*
+     * limit s2g to just the second column, sallg to the first column
+     */
+    s2g.setStartRes(1);
+    s2g.setEndRes(1);
+    sallg.setEndRes(0);
+    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 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));
+  }
 }