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