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.BeforeClass;
32 import org.testng.annotations.Test;
34 import jalview.gui.JvOptionPane;
36 public class SearchResultsTest
39 @BeforeClass(alwaysRun = true)
40 public void setUpJvOptionPane()
42 JvOptionPane.setInteractiveMode(false);
43 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
46 @Test(groups = { "Functional" })
47 public void testToString()
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());
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());
61 @Test(groups = { "Functional" })
62 public void testEquals()
64 SequenceI seq1 = new Sequence("", "abcdefghijklm");
65 SearchResultsI sr1 = new SearchResults();
66 SearchResultsI sr2 = new SearchResults();
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
75 * if only one result is not empty
77 sr1.addResult(seq1, 1, 1);
78 assertTrue(sr1.equals(sr1));
79 assertFalse(sr1.equals(sr2));
80 assertFalse(sr2.equals(sr1));
85 sr2.addResult(seq1, 1, 1);
86 assertTrue(sr1.equals(sr2));
87 assertTrue(sr2.equals(sr1));
90 * both have three matches
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));
103 * Matches that are similar but for distinct sequences are not equal
105 @Test(groups = { "Functional" })
106 public void testEquals_distinctSequences()
108 SequenceI seq1 = new Sequence("", "abcdefghijklm");
109 SequenceI seq2 = new Sequence("", "abcdefghijklm");
110 SearchResultsI sr1 = new SearchResults();
111 SearchResultsI sr2 = new SearchResults();
113 sr1.addResult(seq1, 1, 1);
114 sr2.addResult(seq2, 1, 1);
115 assertFalse(sr1.equals(sr2));
116 assertFalse(sr2.equals(sr1));
120 * Matches that are the same except for ordering are not equal
122 @Test(groups = { "Functional" })
123 public void testEquals_orderDiffers()
125 SequenceI seq1 = new Sequence("", "abcdefghijklm");
126 SearchResultsI sr1 = new SearchResults();
127 SearchResultsI sr2 = new SearchResults();
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));
138 * Verify that hashCode matches for equal objects
140 @Test(groups = { "Functional" })
141 public void testHashcode()
143 SequenceI seq1 = new Sequence("", "abcdefghijklm");
144 SearchResultsI sr1 = new SearchResults();
145 SearchResultsI sr2 = new SearchResults();
150 assertEquals(sr1.hashCode(), sr2.hashCode());
155 sr1.addResult(seq1, 1, 1);
156 sr2.addResult(seq1, 1, 1);
157 assertEquals(sr1.hashCode(), sr2.hashCode());
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());
170 * Verify that SearchResults$Match constructor normalises start/end to the
171 * 'forwards' direction
173 @Test(groups = { "Functional" })
174 public void testMatchConstructor()
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());
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());
189 @Test(groups = { "Functional" })
190 public void testMatchContains()
192 SequenceI seq1 = new Sequence("", "abcdefghijklm");
193 SequenceI seq2 = new Sequence("", "abcdefghijklm");
194 SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
196 assertTrue(m.contains(seq1, 2, 5));
197 assertTrue(m.contains(seq1, 3, 5));
198 assertTrue(m.contains(seq1, 2, 4));
199 assertTrue(m.contains(seq1, 3, 3));
201 assertFalse(m.contains(seq1, 2, 6));
202 assertFalse(m.contains(seq1, 1, 5));
203 assertFalse(m.contains(seq1, 1, 8));
204 assertFalse(m.contains(seq2, 3, 3));
205 assertFalse(m.contains(null, 3, 3));
209 * test markColumns for creating column selections
211 @Test(groups = { "Functional" })
212 public void testMarkColumns()
215 SequenceI seq1 = new Sequence("", "abcdefghijklm");
216 SequenceI seq2 = new Sequence("", "abcdefghijklm");
217 SequenceGroup s1g = new SequenceGroup(), s2g = new SequenceGroup(),
218 sallg = new SequenceGroup();
219 s1g.addSequence(seq1, false);
220 s2g.addSequence(seq2, false);
221 sallg.addSequence(seq1, false);
222 sallg.addSequence(seq2, false);
224 SearchResultsI sr = new SearchResults();
225 BitSet bs = new BitSet();
227 SearchResultMatchI srm = null;
228 srm = sr.addResult(seq1, 1, 1);
229 Assert.assertNotNull("addResult didn't return Match", srm);
230 srm = sr.addResult(seq2, 1, 2);
231 assertEquals("Sequence reference not set", seq2, srm.getSequence());
232 assertEquals("match start incorrect", 1, srm.getStart());
233 assertEquals("match end incorrect", 2, srm.getEnd());
235 // set start/end range for groups to cover matches
241 sallg.setStartRes(0);
247 marked = sr.markColumns(s1g, bs);
248 // check the bitset cardinality before checking the return value
249 assertEquals("Didn't mark expected number", 1, bs.cardinality());
250 assertEquals("Didn't return count of number of bits marked", 1, marked);
251 assertTrue("Didn't mark expected position", bs.get(0));
252 // now check return value for marking the same again
254 "Didn't count number of bits marked for existing marked set", 0,
255 sr.markColumns(s1g, bs));
261 marked = sr.markColumns(s2g, bs);
262 assertEquals("Didn't mark expected number", 2, bs.cardinality());
263 assertEquals("Didn't return count of number of bits marked", 2, marked);
264 assertTrue("Didn't mark expected position (1)", bs.get(0));
265 assertTrue("Didn't mark expected position (2)", bs.get(1));
269 * should be same as seq2
271 BitSet allbs = new BitSet();
272 assertEquals(2, sr.markColumns(sallg, allbs));
273 assertEquals(bs, allbs);
275 // now check range selection
278 * limit s2g to just the second column, sallg to the first column
283 BitSet tbs = new BitSet();
284 assertEquals("Group start/end didn't select columns to mark", 1,
285 sr.markColumns(s2g, tbs));
286 assertEquals("Group start/end didn't select columns to mark", 1,
287 sr.markColumns(sallg, tbs));
289 "Didn't set expected number of columns in total for two successive marks",
290 2, tbs.cardinality());
294 * Test to verify adding doesn't create duplicate results
296 @Test(groups = { "Functional" })
297 public void testAddResult()
299 SequenceI seq1 = new Sequence("", "abcdefghijklm");
300 SearchResultsI sr = new SearchResults();
301 sr.addResult(seq1, 3, 5);
302 assertEquals(1, sr.getCount());
303 sr.addResult(seq1, 3, 5);
304 assertEquals(1, sr.getCount());
305 sr.addResult(seq1, 3, 6);
306 assertEquals(2, sr.getCount());
310 * Test for method that checks if search results matches a sequence region
312 @Test(groups = { "Functional" })
313 public void testInvolvesSequence()
315 SequenceI dataset = new Sequence("genome", "ATGGCCCTTTAAGCAACATTT");
317 SequenceI cds1 = new Sequence("cds1/1-12", "ATGGCCCTTTAA");
318 cds1.setDatasetSequence(dataset);
319 // overlapping second 'exon':
320 SequenceI cds2 = new Sequence("cds2/7-18", "CTTTAAGCAACA");
321 cds2.setDatasetSequence(dataset);
322 // unrelated sequence
323 SequenceI cds3 = new Sequence("cds3", "ATGGCCCTTTAAGCAACA");
325 SearchResults sr = new SearchResults();
326 assertFalse(sr.involvesSequence(cds1));
329 * cds1 and cds2 share the same dataset sequence, but
330 * only cds1 overlaps match 4:6 (fixes bug JAL-3613)
332 sr.addResult(dataset, 4, 6);
333 assertTrue(sr.involvesSequence(cds1));
334 assertFalse(sr.involvesSequence(cds2));
335 assertFalse(sr.involvesSequence(cds3));
338 * search results overlap cds2 only
340 sr = new SearchResults();
341 sr.addResult(dataset, 18, 18);
342 assertFalse(sr.involvesSequence(cds1));
343 assertTrue(sr.involvesSequence(cds2));
346 * add a search result overlapping cds1
348 sr.addResult(dataset, 1, 1);
349 assertTrue(sr.involvesSequence(cds1));
350 assertTrue(sr.involvesSequence(cds2));
353 * single search result overlapping both
355 sr = new SearchResults();
356 sr.addResult(dataset, 10, 12);
357 assertTrue(sr.involvesSequence(cds1));
358 assertTrue(sr.involvesSequence(cds2));
361 * search results matching aligned sequence
363 sr = new SearchResults();
364 sr.addResult(cds1, 10, 12);
365 assertTrue(sr.involvesSequence(cds1));
366 assertFalse(sr.involvesSequence(cds2));
367 sr.addResult(cds2, 1, 3); // no start-end overlap
368 assertFalse(sr.involvesSequence(cds2));
369 sr.addResult(cds2, 7, 9); // start-end overlap
370 assertTrue(sr.involvesSequence(cds2));