2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
21 package jalview.datamodel;
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;
28 import java.util.BitSet;
30 import org.testng.annotations.Test;
32 public class SearchResultsTest
35 @Test(groups = { "Functional" })
36 public void testToString()
38 SequenceI seq = new Sequence("", "abcdefghijklm");
39 SearchResultsI sr = new SearchResults();
40 sr.addResult(seq, 1, 1);
41 assertEquals("0a", sr.toString());
42 sr.addResult(seq, 3, 5);
43 assertEquals("0a2cde", sr.toString());
45 seq = new Sequence("", "pqrstuvwxy");
46 sr.addResult(seq, 6, 7);
47 assertEquals("0a2cde5uv", sr.toString());
50 @Test(groups = { "Functional" })
51 public void testGetCharacters()
53 SequenceI seq = new Sequence("", "abcdefghijklm");
54 SearchResults sr = new SearchResults();
55 sr.addResult(seq, 1, 1);
56 assertEquals("a", sr.getCharacters());
57 sr.addResult(seq, 3, 5);
58 assertEquals("acde", sr.getCharacters());
60 seq = new Sequence("", "pqrstuvwxy");
61 sr.addResult(seq, 6, 7);
62 assertEquals("acdeuv", sr.getCharacters());
65 @Test(groups = { "Functional" })
66 public void testEquals()
68 SequenceI seq1 = new Sequence("", "abcdefghijklm");
69 SearchResultsI sr1 = new SearchResults();
70 SearchResultsI sr2 = new SearchResults();
72 assertFalse(sr1.equals(null)); // null object
73 assertFalse(sr1.equals(seq1)); // wrong type
74 assertTrue(sr1.equals(sr1)); // self
75 assertTrue(sr1.equals(sr2)); // empty
76 assertTrue(sr2.equals(sr1)); // reflexive
79 * only one result is not empty
81 sr1.addResult(seq1, 1, 1);
82 assertTrue(sr1.equals(sr1));
83 assertFalse(sr1.equals(sr2));
84 assertFalse(sr2.equals(sr1));
89 sr2.addResult(seq1, 1, 1);
90 assertTrue(sr1.equals(sr2));
91 assertTrue(sr2.equals(sr1));
94 * both have three matches
96 sr1.addResult(seq1, 3, 4);
97 sr1.addResult(seq1, 6, 8);
98 sr2.addResult(seq1, 3, 4);
99 sr2.addResult(seq1, 6, 8);
100 assertTrue(sr1.equals(sr1));
101 assertTrue(sr2.equals(sr2));
102 assertTrue(sr1.equals(sr2));
103 assertTrue(sr2.equals(sr1));
107 * Matches that are similar but for distinct sequences are not equal
109 @Test(groups = { "Functional" })
110 public void testEquals_distinctSequences()
112 SequenceI seq1 = new Sequence("", "abcdefghijklm");
113 SequenceI seq2 = new Sequence("", "abcdefghijklm");
114 SearchResultsI sr1 = new SearchResults();
115 SearchResultsI sr2 = new SearchResults();
117 sr1.addResult(seq1, 1, 1);
118 sr2.addResult(seq2, 1, 1);
119 assertFalse(sr1.equals(sr2));
120 assertFalse(sr2.equals(sr1));
124 * Matches that are the same except for ordering are not equal
126 @Test(groups = { "Functional" })
127 public void testEquals_orderDiffers()
129 SequenceI seq1 = new Sequence("", "abcdefghijklm");
130 SearchResultsI sr1 = new SearchResults();
131 SearchResultsI sr2 = new SearchResults();
133 sr1.addResult(seq1, 1, 1);
134 sr1.addResult(seq1, 2, 2);
135 sr2.addResult(seq1, 2, 2);
136 sr2.addResult(seq1, 1, 1);
137 assertFalse(sr1.equals(sr2));
138 assertFalse(sr2.equals(sr1));
142 * Verify that hashCode matches for equal objects
144 @Test(groups = { "Functional" })
145 public void testHashcode()
147 SequenceI seq1 = new Sequence("", "abcdefghijklm");
148 SearchResultsI sr1 = new SearchResults();
149 SearchResultsI sr2 = new SearchResults();
154 assertEquals(sr1.hashCode(), sr2.hashCode());
159 sr1.addResult(seq1, 1, 1);
160 sr2.addResult(seq1, 1, 1);
161 assertEquals(sr1.hashCode(), sr2.hashCode());
166 sr1.addResult(seq1, 3, 4);
167 sr1.addResult(seq1, 6, 8);
168 sr2.addResult(seq1, 3, 4);
169 sr2.addResult(seq1, 6, 8);
170 assertEquals(sr1.hashCode(), sr2.hashCode());
174 * Verify that SearchResults$Match constructor normalises start/end to the
175 * 'forwards' direction
177 @Test(groups = { "Functional" })
178 public void testMatchConstructor()
180 SequenceI seq1 = new Sequence("", "abcdefghijklm");
181 SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
182 assertSame(seq1, m.getSequence());
183 assertEquals(2, m.getStart());
184 assertEquals(5, m.getEnd());
186 // now a reverse mapping:
187 m = new SearchResults().new Match(seq1, 5, 2);
188 assertSame(seq1, m.getSequence());
189 assertEquals(2, m.getStart());
190 assertEquals(5, m.getEnd());
194 * test markColumns for creating column selections
196 @Test(groups = { "Functional" })
197 public void testMarkColumns()
200 SequenceI seq1 = new Sequence("", "abcdefghijklm");
201 SequenceI seq2 = new Sequence("", "abcdefghijklm");
202 SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
203 s1g.addSequence(seq1, false);
204 s2g.addSequence(seq2, false);
205 sallg.addSequence(seq1, false);
206 sallg.addSequence(seq2, false);
208 SearchResultsI sr = new SearchResults();
209 BitSet bs = new BitSet();
211 sr.addResult(seq1, 1,1);
212 sr.addResult(seq2, 1,2);
214 // set start/end range for groups to cover matches
220 sallg.setStartRes(0);
226 marked = sr.markColumns(s1g, bs);
227 // check the bitset cardinality before checking the return value
228 assertEquals("Didn't mark expected number", 1, bs.cardinality());
229 assertEquals("Didn't return count of number of bits marked", 1, marked);
230 assertTrue("Didn't mark expected position", bs.get(0));
231 // now check return value for marking the same again
233 "Didn't count number of bits marked for existing marked set",
235 sr.markColumns(s1g, bs));
241 marked = sr.markColumns(s2g, bs);
242 assertEquals("Didn't mark expected number", 2, bs.cardinality());
243 assertEquals("Didn't return count of number of bits marked", 2, marked);
244 assertTrue("Didn't mark expected position (1)", bs.get(0));
245 assertTrue("Didn't mark expected position (2)", bs.get(0));
249 * should be same as seq2
251 BitSet allbs = new BitSet();
252 assertEquals(2, sr.markColumns(sallg, allbs));
253 assertEquals(bs, allbs);
255 // now check range selection
258 * limit s2g to just the second column, sallg to the first column
264 assertEquals(1, sr.markColumns(s2g, tbs = new BitSet()));
265 assertEquals(1, sr.markColumns(sallg, tbs = new BitSet()));