f1a6e20e740ca3d9598b858851e052060970835a
[jalview.git] / SearchResultsTest.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.datamodel;
22
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertFalse;
25 import static org.testng.AssertJUnit.assertSame;
26 import static org.testng.AssertJUnit.assertTrue;
27
28 import jalview.gui.JvOptionPane;
29
30 import java.util.BitSet;
31
32 import org.junit.Assert;
33 import org.testng.annotations.BeforeClass;
34 import org.testng.annotations.Test;
35
36 public class SearchResultsTest
37 {
38
39   @BeforeClass(alwaysRun = true)
40   public void setUpJvOptionPane()
41   {
42     JvOptionPane.setInteractiveMode(false);
43     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
44   }
45
46   @Test(groups = { "Functional" })
47   public void testToString()
48   {
49     SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
50     SearchResultsI sr = new SearchResults();
51     sr.addResult(seq, 1, 1);
52     assertEquals("[Seq1/1-1]", sr.toString());
53     sr.addResult(seq, 3, 5);
54     assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
55
56     seq = new Sequence("Seq2", "pqrstuvwxy");
57     sr.addResult(seq, 6, 7);
58     assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
59   }
60
61   @Test(groups = { "Functional" })
62   public void testEquals()
63   {
64     SequenceI seq1 = new Sequence("", "abcdefghijklm");
65     SearchResultsI sr1 = new SearchResults();
66     SearchResultsI sr2 = new SearchResults();
67
68     assertFalse(sr1.equals(null)); // null object
69     assertFalse(sr1.equals(seq1)); // wrong type
70     assertTrue(sr1.equals(sr1)); // self
71     assertTrue(sr1.equals(sr2)); // empty
72     assertTrue(sr2.equals(sr1)); // reflexive
73
74     /*
75      * if only one result is not empty
76      */
77     sr1.addResult(seq1, 1, 1);
78     assertTrue(sr1.equals(sr1));
79     assertFalse(sr1.equals(sr2));
80     assertFalse(sr2.equals(sr1));
81
82     /*
83      * both the same
84      */
85     sr2.addResult(seq1, 1, 1);
86     assertTrue(sr1.equals(sr2));
87     assertTrue(sr2.equals(sr1));
88
89     /*
90      * both have three matches
91      */
92     sr1.addResult(seq1, 3, 4);
93     sr1.addResult(seq1, 6, 8);
94     sr2.addResult(seq1, 3, 4);
95     sr2.addResult(seq1, 6, 8);
96     assertTrue(sr1.equals(sr1));
97     assertTrue(sr2.equals(sr2));
98     assertTrue(sr1.equals(sr2));
99     assertTrue(sr2.equals(sr1));
100   }
101
102   /**
103    * Matches that are similar but for distinct sequences are not equal
104    */
105   @Test(groups = { "Functional" })
106   public void testEquals_distinctSequences()
107   {
108     SequenceI seq1 = new Sequence("", "abcdefghijklm");
109     SequenceI seq2 = new Sequence("", "abcdefghijklm");
110     SearchResultsI sr1 = new SearchResults();
111     SearchResultsI sr2 = new SearchResults();
112
113     sr1.addResult(seq1, 1, 1);
114     sr2.addResult(seq2, 1, 1);
115     assertFalse(sr1.equals(sr2));
116     assertFalse(sr2.equals(sr1));
117   }
118
119   /**
120    * Matches that are the same except for ordering are not equal
121    */
122   @Test(groups = { "Functional" })
123   public void testEquals_orderDiffers()
124   {
125     SequenceI seq1 = new Sequence("", "abcdefghijklm");
126     SearchResultsI sr1 = new SearchResults();
127     SearchResultsI sr2 = new SearchResults();
128
129     sr1.addResult(seq1, 1, 1);
130     sr1.addResult(seq1, 2, 2);
131     sr2.addResult(seq1, 2, 2);
132     sr2.addResult(seq1, 1, 1);
133     assertFalse(sr1.equals(sr2));
134     assertFalse(sr2.equals(sr1));
135   }
136
137   /**
138    * Verify that hashCode matches for equal objects
139    */
140   @Test(groups = { "Functional" })
141   public void testHashcode()
142   {
143     SequenceI seq1 = new Sequence("", "abcdefghijklm");
144     SearchResultsI sr1 = new SearchResults();
145     SearchResultsI sr2 = new SearchResults();
146
147     /*
148      * both empty
149      */
150     assertEquals(sr1.hashCode(), sr2.hashCode());
151
152     /*
153      * both one match
154      */
155     sr1.addResult(seq1, 1, 1);
156     sr2.addResult(seq1, 1, 1);
157     assertEquals(sr1.hashCode(), sr2.hashCode());
158
159     /*
160      * both three matches
161      */
162     sr1.addResult(seq1, 3, 4);
163     sr1.addResult(seq1, 6, 8);
164     sr2.addResult(seq1, 3, 4);
165     sr2.addResult(seq1, 6, 8);
166     assertEquals(sr1.hashCode(), sr2.hashCode());
167   }
168
169   /**
170    * Verify that SearchResults$Match constructor normalises start/end to the
171    * 'forwards' direction
172    */
173   @Test(groups = { "Functional" })
174   public void testMatchConstructor()
175   {
176     SequenceI seq1 = new Sequence("", "abcdefghijklm");
177     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
178     assertSame(seq1, m.getSequence());
179     assertEquals(2, m.getStart());
180     assertEquals(5, m.getEnd());
181
182     // now a reverse mapping:
183     m = new SearchResults().new Match(seq1, 5, 2);
184     assertSame(seq1, m.getSequence());
185     assertEquals(2, m.getStart());
186     assertEquals(5, m.getEnd());
187   }
188
189   /**
190    * test markColumns for creating column selections
191    */
192   @Test(groups = { "Functional" })
193   public void testMarkColumns()
194   {
195     int marked = 0;
196     SequenceI seq1 = new Sequence("", "abcdefghijklm");
197     SequenceI seq2 = new Sequence("", "abcdefghijklm");
198     SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
199     s1g.addSequence(seq1, false);
200     s2g.addSequence(seq2, false);
201     sallg.addSequence(seq1, false);
202     sallg.addSequence(seq2, false);
203     
204     SearchResultsI sr = new SearchResults();
205     BitSet bs = new BitSet();
206     
207     SearchResultMatchI srm = null;
208     srm = sr.addResult(seq1, 1, 1);
209     Assert.assertNotNull("addResult didn't return Match", srm);
210     srm = sr.addResult(seq2, 1, 2);
211     assertEquals("Sequence reference not set", seq2, srm.getSequence());
212     assertEquals("match start incorrect", 1, srm.getStart());
213     assertEquals("match end incorrect", 2, srm.getEnd());
214     
215     // set start/end range for groups to cover matches
216
217     s1g.setStartRes(0);
218     s1g.setEndRes(5);
219     s2g.setStartRes(0);
220     s2g.setEndRes(5);
221     sallg.setStartRes(0);
222     sallg.setEndRes(5);
223
224     /*
225      * just seq1
226      */
227     marked = sr.markColumns(s1g, bs);
228     // check the bitset cardinality before checking the return value
229     assertEquals("Didn't mark expected number", 1, bs.cardinality());
230     assertEquals("Didn't return count of number of bits marked", 1, marked);
231     assertTrue("Didn't mark expected position", bs.get(0));
232     // now check return value for marking the same again
233     assertEquals(
234             "Didn't count number of bits marked for existing marked set",
235             0,
236             sr.markColumns(s1g, bs));
237     bs.clear();
238     
239     /*
240      * just seq2
241      */
242     marked = sr.markColumns(s2g, bs);
243     assertEquals("Didn't mark expected number", 2, bs.cardinality());
244     assertEquals("Didn't return count of number of bits marked", 2, marked);
245     assertTrue("Didn't mark expected position (1)", bs.get(0));
246     assertTrue("Didn't mark expected position (2)", bs.get(1));
247     
248     /*
249      * both seq1 and seq2 
250      * should be same as seq2
251      */
252     BitSet allbs = new BitSet();
253     assertEquals(2, sr.markColumns(sallg, allbs));
254     assertEquals(bs, allbs);
255
256     // now check range selection
257
258     /*
259      * limit s2g to just the second column, sallg to the first column
260      */
261     s2g.setStartRes(1);
262     s2g.setEndRes(1);
263     sallg.setEndRes(0);
264     BitSet tbs = new BitSet();
265     assertEquals("Group start/end didn't select columns to mark",1, sr.markColumns(s2g, tbs));
266     assertEquals("Group start/end didn't select columns to mark", 1, sr.markColumns(sallg, tbs));
267     assertEquals(
268             "Didn't set expected number of columns in total for two successive marks",
269             2, tbs.cardinality());
270   }
271 }