JAL-4062 appendResult(seq,start,end) called by structureSelectionManager sweep-search...

[jalview.git] / test / jalview / datamodel / SearchResultsTest.java

diff --git a/test/jalview/datamodel/SearchResultsTest.java b/test/jalview/datamodel/SearchResultsTest.java
index 838b259..d8c10ee 100644 (file)
--- a/test/jalview/datamodel/SearchResultsTest.java
+++ b/test/jalview/datamodel/SearchResultsTest.java
@@ -26,6 +26,7 @@ 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;
@@ -205,6 +206,32 @@ public class SearchResultsTest
     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
    */
@@ -214,15 +241,16 @@ 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();
-    
+
     SearchResultMatchI srm = null;
     srm = sr.addResult(seq1, 1, 1);
     Assert.assertNotNull("addResult didn't return Match", srm);
@@ -230,7 +258,7 @@ public class SearchResultsTest
     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);
@@ -250,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
      */
@@ -263,7 +290,7 @@ public class SearchResultsTest
     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
@@ -281,8 +308,10 @@ public class SearchResultsTest
     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("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());
@@ -305,6 +334,23 @@ public class SearchResultsTest
   }
 
   /**
+   * Test to verify appending creates a minimal set of results
+   */
+  @Test(groups = { "Functional" })
+  public void testAppendResult()
+  {
+    SequenceI seq1 = new Sequence("", "abcdefghijklm");
+    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());
+  }
+  /**
    * Test for method that checks if search results matches a sequence region
    */
   @Test(groups = { "Functional" })
@@ -367,4 +413,44 @@ public class SearchResultsTest
     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<SequenceI> 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());
+  }
+
 }