test/jalview/analysis/FinderTest.java

   1 package jalview.analysis;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertSame;
   5 import static org.testng.Assert.assertTrue;
   6
   7 import jalview.datamodel.Alignment;
   8 import jalview.datamodel.AlignmentI;
   9 import jalview.datamodel.SearchResultMatchI;
  10 import jalview.datamodel.SearchResultsI;
  11 import jalview.datamodel.Sequence;
  12 import jalview.gui.AlignFrame;
  13 import jalview.gui.JvOptionPane;
  14 import jalview.io.FileLoader;
  15 import jalview.io.FormatAdapter;
  16
  17 import java.util.List;
  18
  19 import org.testng.annotations.BeforeClass;
  20 import org.testng.annotations.Test;
  21
  22 public class FinderTest
  23 {
  24   @BeforeClass(alwaysRun = true)
  25   public void setUpJvOptionPane()
  26   {
  27     JvOptionPane.setInteractiveMode(false);
  28     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  29   }
  30
  31   private AlignFrame af;
  32
  33   private AlignmentI al;
  34
  35   @BeforeClass(groups = "Functional")
  36   public void setUp()
  37   {
  38     String seqData = "seq1 ABCD--EF-GHI\n" + "seq2 A--BCDefHI\n"
  39             + "seq3 --bcdEFH\n" + "seq4 aa---aMMMMMaaa\n";
  40     af = new FileLoader().LoadFileWaitTillLoaded(seqData,
  41             FormatAdapter.PASTE);
  42     al = af.getViewport().getAlignment();
  43   }
  44
  45   /**
  46    * Test for find all matches of a regular expression
  47    */
  48   @Test(groups = "Functional")
  49   public void testFindAll_regex()
  50   {
  51     Finder f = new Finder(al, null);
  52     f.setFindAll(true);
  53     f.find("E.H"); // 'E, any character, H'
  54
  55     // should match seq2 efH and seq3 EFH
  56     SearchResultsI sr = f.getSearchResults();
  57     assertEquals(sr.getSize(), 2);
  58     List<SearchResultMatchI> matches = sr.getResults();
  59     assertSame(al.getSequenceAt(1), matches.get(0).getSequence());
  60     assertSame(al.getSequenceAt(2), matches.get(1).getSequence());
  61     assertEquals(matches.get(0).getStart(), 5);
  62     assertEquals(matches.get(0).getEnd(), 7);
  63     assertEquals(matches.get(1).getStart(), 4);
  64     assertEquals(matches.get(1).getEnd(), 6);
  65   }
  66
  67   /**
  68    * Test for (undocumented) find residue by position
  69    */
  70   @Test(groups = "Functional")
  71   public void testFind_residueNumber()
  72   {
  73     Finder f = new Finder(al, null);
  74     f.setFindAll(true);
  75     f.find("9");
  76
  77     // seq1 and seq4 have 9 residues; no match in other sequences
  78     SearchResultsI sr = f.getSearchResults();
  79     assertEquals(sr.getSize(), 2);
  80     List<SearchResultMatchI> matches = sr.getResults();
  81     assertSame(al.getSequenceAt(0), matches.get(0).getSequence());
  82     assertSame(al.getSequenceAt(3), matches.get(1).getSequence());
  83     assertEquals(matches.get(0).getStart(), 9);
  84     assertEquals(matches.get(0).getEnd(), 9);
  85     assertEquals(matches.get(1).getStart(), 9);
  86     assertEquals(matches.get(1).getEnd(), 9);
  87   }
  88
  89   /**
  90    * Test for find next action
  91    */
  92   @Test(groups = "Functional")
  93   public void testFindNext()
  94   {
  95     /*
  96      * start at second sequence; resIndex of -1
  97      * means sequence id / description is searched
  98      */
  99     Finder f = new Finder(al, null, 1, -1);
 100     f.find("e"); // matches id
 101
 102     assertTrue(f.getSearchResults().isEmpty());
 103     assertEquals(f.getIdMatch().size(), 1);
 104     assertSame(f.getIdMatch().get(0), al.getSequenceAt(1));
 105
 106     // resIndex is now 0 - for use in next find next
 107     assertEquals(f.getResIndex(), 0);
 108     f = new Finder(al, null, 1, 0);
 109     f.find("e"); // matches in sequence
 110     assertTrue(f.getIdMatch().isEmpty());
 111     assertEquals(f.getSearchResults().getSize(), 1);
 112     List<SearchResultMatchI> matches = f.getSearchResults().getResults();
 113     assertEquals(matches.get(0).getStart(), 5);
 114     assertEquals(matches.get(0).getEnd(), 5);
 115     assertSame(matches.get(0).getSequence(), al.getSequenceAt(1));
 116     // still in the second sequence
 117     assertEquals(f.getSeqIndex(), 1);
 118     // next residue position to search from is 5
 119     // (used as base 0 by RegEx so the same as 6 if base 1)
 120     assertEquals(f.getResIndex(), 5);
 121
 122     // find next from end of sequence - finds next sequence id
 123     f = new Finder(al, null, 1, 5);
 124     f.find("e");
 125     assertEquals(f.getIdMatch().size(), 1);
 126     assertSame(f.getIdMatch().get(0), al.getSequenceAt(2));
 127   }
 128
 129   /**
 130    * Test for matching within sequence descriptions
 131    */
 132   @Test(groups = "Functional")
 133   public void testFindAll_inDescription()
 134   {
 135     AlignmentI al2 = new Alignment(al);
 136     al2.getSequenceAt(0).setDescription("BRAF");
 137     al2.getSequenceAt(1).setDescription("braf");
 138     Finder f = new Finder(al2, null);
 139     f.setFindAll(true);
 140     f.setIncludeDescription(true);
 141
 142     f.find("rAF");
 143     assertEquals(f.getIdMatch().size(), 2);
 144     assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
 145     assertSame(f.getIdMatch().get(1), al2.getSequenceAt(1));
 146     assertTrue(f.getSearchResults().isEmpty());
 147
 148     /*
 149      * case sensitive
 150      */
 151     f = new Finder(al2, null);
 152     f.setFindAll(true);
 153     f.setCaseSensitive(true);
 154     f.setIncludeDescription(true);
 155
 156     f.find("RAF");
 157     assertEquals(f.getIdMatch().size(), 1);
 158     assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
 159     assertTrue(f.getSearchResults().isEmpty());
 160
 161     /*
 162      * match sequence id, description and sequence!
 163      */
 164     al2.getSequenceAt(0).setDescription("the efh sequence");
 165     al2.getSequenceAt(0).setName("mouseEFHkinase");
 166     al2.getSequenceAt(1).setName("humanEFHkinase");
 167     f = new Finder(al2, null);
 168     f.setFindAll(true);
 169     f.setIncludeDescription(true);
 170
 171     /*
 172      * sequence matches should have no duplicates
 173      */
 174     f.find("EFH");
 175     assertEquals(f.getIdMatch().size(), 2);
 176     assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
 177     assertSame(f.getIdMatch().get(1), al2.getSequenceAt(1));
 178
 179     assertEquals(f.getSearchResults().getSize(), 2);
 180     SearchResultMatchI match = f.getSearchResults().getResults().get(0);
 181     assertSame(al2.getSequenceAt(1), match.getSequence());
 182     assertEquals(5, match.getStart());
 183     assertEquals(7, match.getEnd());
 184     match = f.getSearchResults().getResults().get(1);
 185     assertSame(al2.getSequenceAt(2), match.getSequence());
 186     assertEquals(4, match.getStart());
 187     assertEquals(6, match.getEnd());
 188   }
 189
 190   /**
 191    * Test for matching within sequence ids
 192    */
 193   @Test(groups = "Functional")
 194   public void testFindAll_sequenceIds()
 195   {
 196     Finder f = new Finder(al, null);
 197     f.setFindAll(true);
 198
 199     /*
 200      * case insensitive
 201      */
 202     f.find("SEQ1");
 203     assertEquals(f.getIdMatch().size(), 1);
 204     assertSame(f.getIdMatch().get(0), al.getSequenceAt(0));
 205     assertTrue(f.getSearchResults().isEmpty());
 206
 207     /*
 208      * case sensitive
 209      */
 210     f = new Finder(al, null);
 211     f.setFindAll(true);
 212     f.setCaseSensitive(true);
 213     f.find("SEQ1");
 214     assertTrue(f.getSearchResults().isEmpty());
 215
 216     /*
 217      * match both sequence id and sequence
 218      */
 219     AlignmentI al2 = new Alignment(al);
 220     al2.addSequence(new Sequence("aBz", "xyzabZpqrAbZ"));
 221     f = new Finder(al2, null);
 222     f.setFindAll(true);
 223     f.find("ABZ");
 224     assertEquals(f.getIdMatch().size(), 1);
 225     assertSame(f.getIdMatch().get(0), al2.getSequenceAt(4));
 226     assertEquals(f.getSearchResults().getSize(), 2);
 227     SearchResultMatchI match = f.getSearchResults().getResults().get(0);
 228     assertSame(al2.getSequenceAt(4), match.getSequence());
 229     assertEquals(4, match.getStart());
 230     assertEquals(6, match.getEnd());
 231     match = f.getSearchResults().getResults().get(1);
 232     assertSame(al2.getSequenceAt(4), match.getSequence());
 233     assertEquals(10, match.getStart());
 234     assertEquals(12, match.getEnd());
 235   }
 236
 237   /**
 238    * Test finding all matches of a sequence pattern in an alignment
 239    */
 240   @Test(groups = "Functional")
 241   public void testFindAll_simpleMatch()
 242   {
 243     Finder f = new Finder(al, null);
 244     f.setFindAll(true);
 245
 246     /*
 247      * case insensitive first
 248      */
 249     f.find("EfH");
 250     SearchResultsI searchResults = f.getSearchResults();
 251     assertEquals(searchResults.getSize(), 2);
 252     SearchResultMatchI match = searchResults.getResults().get(0);
 253     assertSame(al.getSequenceAt(1), match.getSequence());
 254     assertEquals(5, match.getStart());
 255     assertEquals(7, match.getEnd());
 256     match = searchResults.getResults().get(1);
 257     assertSame(al.getSequenceAt(2), match.getSequence());
 258     assertEquals(4, match.getStart());
 259     assertEquals(6, match.getEnd());
 260
 261     /*
 262      * case sensitive
 263      */
 264     f = new Finder(al, null);
 265     f.setFindAll(true);
 266     f.setCaseSensitive(true);
 267     f.find("BC");
 268     searchResults = f.getSearchResults();
 269     assertEquals(searchResults.getSize(), 2);
 270     match = searchResults.getResults().get(0);
 271     assertSame(al.getSequenceAt(0), match.getSequence());
 272     assertEquals(2, match.getStart());
 273     assertEquals(3, match.getEnd());
 274     match = searchResults.getResults().get(1);
 275     assertSame(al.getSequenceAt(1), match.getSequence());
 276     assertEquals(2, match.getStart());
 277     assertEquals(3, match.getEnd());
 278   }
 279
 280   /**
 281    * Test for JAL-2302 to verify that sub-matches are not included in a find all
 282    * result
 283    */
 284   @Test(groups = "Functional")
 285   public void testFind_maximalResultOnly()
 286   {
 287     Finder f = new Finder(al, null);
 288     f.setFindAll(true);
 289     f.find("M+");
 290     SearchResultsI searchResults = f.getSearchResults();
 291     assertEquals(searchResults.getSize(), 1);
 292     SearchResultMatchI match = searchResults.getResults().get(0);
 293     assertSame(al.getSequenceAt(3), match.getSequence());
 294     assertEquals(4, match.getStart()); // dataset sequence positions
 295     assertEquals(8, match.getEnd()); // base 1
 296   }
 297 }