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.junit.Assert;
31 import org.testng.annotations.Test;
33 public class SearchResultsTest
36 @Test(groups = { "Functional" })
37 public void testToString()
39 SequenceI seq = new Sequence("", "abcdefghijklm");
40 SearchResultsI sr = new SearchResults();
41 sr.addResult(seq, 1, 1);
42 assertEquals("0a", sr.toString());
43 sr.addResult(seq, 3, 5);
44 assertEquals("0a2cde", sr.toString());
46 seq = new Sequence("", "pqrstuvwxy");
47 sr.addResult(seq, 6, 7);
48 assertEquals("0a2cde5uv", sr.toString());
51 @Test(groups = { "Functional" })
52 public void testGetCharacters()
54 SequenceI seq = new Sequence("", "abcdefghijklm");
55 SearchResults sr = new SearchResults();
56 sr.addResult(seq, 1, 1);
57 assertEquals("a", sr.getCharacters());
58 sr.addResult(seq, 3, 5);
59 assertEquals("acde", sr.getCharacters());
61 seq = new Sequence("", "pqrstuvwxy");
62 sr.addResult(seq, 6, 7);
63 assertEquals("acdeuv", sr.getCharacters());
66 @Test(groups = { "Functional" })
67 public void testEquals()
69 SequenceI seq1 = new Sequence("", "abcdefghijklm");
70 SearchResultsI sr1 = new SearchResults();
71 SearchResultsI sr2 = new SearchResults();
73 assertFalse(sr1.equals(null)); // null object
74 assertFalse(sr1.equals(seq1)); // wrong type
75 assertTrue(sr1.equals(sr1)); // self
76 assertTrue(sr1.equals(sr2)); // empty
77 assertTrue(sr2.equals(sr1)); // reflexive
80 * only one result is not empty
82 sr1.addResult(seq1, 1, 1);
83 assertTrue(sr1.equals(sr1));
84 assertFalse(sr1.equals(sr2));
85 assertFalse(sr2.equals(sr1));
90 sr2.addResult(seq1, 1, 1);
91 assertTrue(sr1.equals(sr2));
92 assertTrue(sr2.equals(sr1));
95 * both have three matches
97 sr1.addResult(seq1, 3, 4);
98 sr1.addResult(seq1, 6, 8);
99 sr2.addResult(seq1, 3, 4);
100 sr2.addResult(seq1, 6, 8);
101 assertTrue(sr1.equals(sr1));
102 assertTrue(sr2.equals(sr2));
103 assertTrue(sr1.equals(sr2));
104 assertTrue(sr2.equals(sr1));
108 * Matches that are similar but for distinct sequences are not equal
110 @Test(groups = { "Functional" })
111 public void testEquals_distinctSequences()
113 SequenceI seq1 = new Sequence("", "abcdefghijklm");
114 SequenceI seq2 = new Sequence("", "abcdefghijklm");
115 SearchResultsI sr1 = new SearchResults();
116 SearchResultsI sr2 = new SearchResults();
118 sr1.addResult(seq1, 1, 1);
119 sr2.addResult(seq2, 1, 1);
120 assertFalse(sr1.equals(sr2));
121 assertFalse(sr2.equals(sr1));
125 * Matches that are the same except for ordering are not equal
127 @Test(groups = { "Functional" })
128 public void testEquals_orderDiffers()
130 SequenceI seq1 = new Sequence("", "abcdefghijklm");
131 SearchResultsI sr1 = new SearchResults();
132 SearchResultsI sr2 = new SearchResults();
134 sr1.addResult(seq1, 1, 1);
135 sr1.addResult(seq1, 2, 2);
136 sr2.addResult(seq1, 2, 2);
137 sr2.addResult(seq1, 1, 1);
138 assertFalse(sr1.equals(sr2));
139 assertFalse(sr2.equals(sr1));
143 * Verify that hashCode matches for equal objects
145 @Test(groups = { "Functional" })
146 public void testHashcode()
148 SequenceI seq1 = new Sequence("", "abcdefghijklm");
149 SearchResultsI sr1 = new SearchResults();
150 SearchResultsI sr2 = new SearchResults();
155 assertEquals(sr1.hashCode(), sr2.hashCode());
160 sr1.addResult(seq1, 1, 1);
161 sr2.addResult(seq1, 1, 1);
162 assertEquals(sr1.hashCode(), sr2.hashCode());
167 sr1.addResult(seq1, 3, 4);
168 sr1.addResult(seq1, 6, 8);
169 sr2.addResult(seq1, 3, 4);
170 sr2.addResult(seq1, 6, 8);
171 assertEquals(sr1.hashCode(), sr2.hashCode());
175 * Verify that SearchResults$Match constructor normalises start/end to the
176 * 'forwards' direction
178 @Test(groups = { "Functional" })
179 public void testMatchConstructor()
181 SequenceI seq1 = new Sequence("", "abcdefghijklm");
182 SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
183 assertSame(seq1, m.getSequence());
184 assertEquals(2, m.getStart());
185 assertEquals(5, m.getEnd());
187 // now a reverse mapping:
188 m = new SearchResults().new Match(seq1, 5, 2);
189 assertSame(seq1, m.getSequence());
190 assertEquals(2, m.getStart());
191 assertEquals(5, m.getEnd());
195 * test markColumns for creating column selections
197 @Test(groups = { "Functional" })
198 public void testMarkColumns()
201 SequenceI seq1 = new Sequence("", "abcdefghijklm");
202 SequenceI seq2 = new Sequence("", "abcdefghijklm");
203 SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
204 s1g.addSequence(seq1, false);
205 s2g.addSequence(seq2, false);
206 sallg.addSequence(seq1, false);
207 sallg.addSequence(seq2, false);
209 SearchResultsI sr = new SearchResults();
210 BitSet bs = new BitSet();
212 SearchResultMatchI srm = null;
213 srm = sr.addResult(seq1, 1, 1);
214 Assert.assertNotNull("addResult didn't return Match", srm);
215 srm = sr.addResult(seq2, 1, 2);
216 assertEquals("Sequence reference not set", seq2, srm.getSequence());
217 assertEquals("match start incorrect", 1, srm.getStart());
218 assertEquals("match end incorrect", 2, srm.getEnd());
220 // set start/end range for groups to cover matches
226 sallg.setStartRes(0);
232 marked = sr.markColumns(s1g, bs);
233 // check the bitset cardinality before checking the return value
234 assertEquals("Didn't mark expected number", 1, bs.cardinality());
235 assertEquals("Didn't return count of number of bits marked", 1, marked);
236 assertTrue("Didn't mark expected position", bs.get(0));
237 // now check return value for marking the same again
239 "Didn't count number of bits marked for existing marked set",
241 sr.markColumns(s1g, bs));
247 marked = sr.markColumns(s2g, bs);
248 assertEquals("Didn't mark expected number", 2, bs.cardinality());
249 assertEquals("Didn't return count of number of bits marked", 2, marked);
250 assertTrue("Didn't mark expected position (1)", bs.get(0));
251 assertTrue("Didn't mark expected position (2)", bs.get(1));
255 * should be same as seq2
257 BitSet allbs = new BitSet();
258 assertEquals(2, sr.markColumns(sallg, allbs));
259 assertEquals(bs, allbs);
261 // now check range selection
264 * limit s2g to just the second column, sallg to the first column
269 BitSet tbs = new BitSet();
270 assertEquals("Group start/end didn't select columns to mark",1, sr.markColumns(s2g, tbs));
271 assertEquals("Group start/end didn't select columns to mark", 1, sr.markColumns(sallg, tbs));
273 "Didn't set expected number of columns in total for two successive marks",
274 2, tbs.cardinality());