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