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;
29 import java.util.List;
31 import org.junit.Assert;
32 import org.testng.annotations.BeforeClass;
33 import org.testng.annotations.Test;
35 import jalview.gui.JvOptionPane;
37 public class SearchResultsTest
40 @BeforeClass(alwaysRun = true)
41 public void setUpJvOptionPane()
43 JvOptionPane.setInteractiveMode(false);
44 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
47 @Test(groups = { "Functional" })
48 public void testToString()
50 SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
51 SearchResultsI sr = new SearchResults();
52 sr.addResult(seq, 1, 1);
53 assertEquals("[Seq1/1-1]", sr.toString());
54 sr.addResult(seq, 3, 5);
55 assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
57 seq = new Sequence("Seq2", "pqrstuvwxy");
58 sr.addResult(seq, 6, 7);
59 assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
62 @Test(groups = { "Functional" })
63 public void testEquals()
65 SequenceI seq1 = new Sequence("", "abcdefghijklm");
66 SearchResultsI sr1 = new SearchResults();
67 SearchResultsI sr2 = new SearchResults();
69 assertFalse(sr1.equals(null)); // null object
70 assertFalse(sr1.equals(seq1)); // wrong type
71 assertTrue(sr1.equals(sr1)); // self
72 assertTrue(sr1.equals(sr2)); // empty
73 assertTrue(sr2.equals(sr1)); // reflexive
76 * if only one result is not empty
78 sr1.addResult(seq1, 1, 1);
79 assertTrue(sr1.equals(sr1));
80 assertFalse(sr1.equals(sr2));
81 assertFalse(sr2.equals(sr1));
86 sr2.addResult(seq1, 1, 1);
87 assertTrue(sr1.equals(sr2));
88 assertTrue(sr2.equals(sr1));
91 * both have three matches
93 sr1.addResult(seq1, 3, 4);
94 sr1.addResult(seq1, 6, 8);
95 sr2.addResult(seq1, 3, 4);
96 sr2.addResult(seq1, 6, 8);
97 assertTrue(sr1.equals(sr1));
98 assertTrue(sr2.equals(sr2));
99 assertTrue(sr1.equals(sr2));
100 assertTrue(sr2.equals(sr1));
104 * Matches that are similar but for distinct sequences are not equal
106 @Test(groups = { "Functional" })
107 public void testEquals_distinctSequences()
109 SequenceI seq1 = new Sequence("", "abcdefghijklm");
110 SequenceI seq2 = new Sequence("", "abcdefghijklm");
111 SearchResultsI sr1 = new SearchResults();
112 SearchResultsI sr2 = new SearchResults();
114 sr1.addResult(seq1, 1, 1);
115 sr2.addResult(seq2, 1, 1);
116 assertFalse(sr1.equals(sr2));
117 assertFalse(sr2.equals(sr1));
121 * Matches that are the same except for ordering are not equal
123 @Test(groups = { "Functional" })
124 public void testEquals_orderDiffers()
126 SequenceI seq1 = new Sequence("", "abcdefghijklm");
127 SearchResultsI sr1 = new SearchResults();
128 SearchResultsI sr2 = new SearchResults();
130 sr1.addResult(seq1, 1, 1);
131 sr1.addResult(seq1, 2, 2);
132 sr2.addResult(seq1, 2, 2);
133 sr2.addResult(seq1, 1, 1);
134 assertFalse(sr1.equals(sr2));
135 assertFalse(sr2.equals(sr1));
139 * Verify that hashCode matches for equal objects
141 @Test(groups = { "Functional" })
142 public void testHashcode()
144 SequenceI seq1 = new Sequence("", "abcdefghijklm");
145 SearchResultsI sr1 = new SearchResults();
146 SearchResultsI sr2 = new SearchResults();
151 assertEquals(sr1.hashCode(), sr2.hashCode());
156 sr1.addResult(seq1, 1, 1);
157 sr2.addResult(seq1, 1, 1);
158 assertEquals(sr1.hashCode(), sr2.hashCode());
163 sr1.addResult(seq1, 3, 4);
164 sr1.addResult(seq1, 6, 8);
165 sr2.addResult(seq1, 3, 4);
166 sr2.addResult(seq1, 6, 8);
167 assertEquals(sr1.hashCode(), sr2.hashCode());
171 * Verify that SearchResults$Match constructor normalises start/end to the
172 * 'forwards' direction
174 @Test(groups = { "Functional" })
175 public void testMatchConstructor()
177 SequenceI seq1 = new Sequence("", "abcdefghijklm");
178 SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
179 assertSame(seq1, m.getSequence());
180 assertEquals(2, m.getStart());
181 assertEquals(5, m.getEnd());
183 // now a reverse mapping:
184 m = new SearchResults().new Match(seq1, 5, 2);
185 assertSame(seq1, m.getSequence());
186 assertEquals(2, m.getStart());
187 assertEquals(5, m.getEnd());
190 @Test(groups = { "Functional" })
191 public void testMatchContains()
193 SequenceI seq1 = new Sequence("", "abcdefghijklm");
194 SequenceI seq2 = new Sequence("", "abcdefghijklm");
195 SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
197 assertTrue(m.contains(seq1, 2, 5));
198 assertTrue(m.contains(seq1, 3, 5));
199 assertTrue(m.contains(seq1, 2, 4));
200 assertTrue(m.contains(seq1, 3, 3));
202 assertFalse(m.contains(seq1, 2, 6));
203 assertFalse(m.contains(seq1, 1, 5));
204 assertFalse(m.contains(seq1, 1, 8));
205 assertFalse(m.contains(seq2, 3, 3));
206 assertFalse(m.contains(null, 3, 3));
209 @Test(groups = { "Functional" })
210 public void testMatchAdjacent()
212 SequenceI seq1 = new Sequence("", "abcdefghijklm");
213 SequenceI seq2 = new Sequence("", "abcdefghijklm");
214 SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
216 assertTrue(m.adjacent(seq1, 2, 5));
217 assertTrue(m.adjacent(seq1, 3, 5));
218 assertTrue(m.adjacent(seq1, 2, 4));
219 assertTrue(m.adjacent(seq1, 3, 3));
221 assertTrue(m.adjacent(seq1, 2, 6));
222 assertTrue(m.adjacent(seq1, 1, 5));
223 assertTrue(m.adjacent(seq1, 1, 8));
224 assertFalse(m.adjacent(seq1, 0, 0));
225 assertFalse(m.adjacent(seq1, 7, 8));
226 assertTrue(m.adjacent(seq1, 6, 8));
227 assertTrue(m.adjacent(seq1, 5, 8));
228 assertTrue(m.adjacent(seq1, 0, 1));
230 assertFalse(m.adjacent(seq2, 3, 3));
231 assertFalse(m.adjacent(null, 3, 3));
235 * test markColumns for creating column selections
237 @Test(groups = { "Functional" })
238 public void testMarkColumns()
241 SequenceI seq1 = new Sequence("", "abcdefghijklm");
242 SequenceI seq2 = new Sequence("", "abcdefghijklm");
243 SequenceGroup s1g = new SequenceGroup(), s2g = new SequenceGroup(),
244 sallg = new SequenceGroup();
245 s1g.addSequence(seq1, false);
246 s2g.addSequence(seq2, false);
247 sallg.addSequence(seq1, false);
248 sallg.addSequence(seq2, false);
250 SearchResultsI sr = new SearchResults();
251 BitSet bs = new BitSet();
253 SearchResultMatchI srm = null;
254 srm = sr.addResult(seq1, 1, 1);
255 Assert.assertNotNull("addResult didn't return Match", srm);
256 srm = sr.addResult(seq2, 1, 2);
257 assertEquals("Sequence reference not set", seq2, srm.getSequence());
258 assertEquals("match start incorrect", 1, srm.getStart());
259 assertEquals("match end incorrect", 2, srm.getEnd());
261 // set start/end range for groups to cover matches
267 sallg.setStartRes(0);
273 marked = sr.markColumns(s1g, bs);
274 // check the bitset cardinality before checking the return value
275 assertEquals("Didn't mark expected number", 1, bs.cardinality());
276 assertEquals("Didn't return count of number of bits marked", 1, marked);
277 assertTrue("Didn't mark expected position", bs.get(0));
278 // now check return value for marking the same again
280 "Didn't count number of bits marked for existing marked set", 0,
281 sr.markColumns(s1g, bs));
287 marked = sr.markColumns(s2g, bs);
288 assertEquals("Didn't mark expected number", 2, bs.cardinality());
289 assertEquals("Didn't return count of number of bits marked", 2, marked);
290 assertTrue("Didn't mark expected position (1)", bs.get(0));
291 assertTrue("Didn't mark expected position (2)", bs.get(1));
295 * should be same as seq2
297 BitSet allbs = new BitSet();
298 assertEquals(2, sr.markColumns(sallg, allbs));
299 assertEquals(bs, allbs);
301 // now check range selection
304 * limit s2g to just the second column, sallg to the first column
309 BitSet tbs = new BitSet();
310 assertEquals("Group start/end didn't select columns to mark", 1,
311 sr.markColumns(s2g, tbs));
312 assertEquals("Group start/end didn't select columns to mark", 1,
313 sr.markColumns(sallg, tbs));
315 "Didn't set expected number of columns in total for two successive marks",
316 2, tbs.cardinality());
320 * Test to verify adding doesn't create duplicate results
322 @Test(groups = { "Functional" })
323 public void testAddResult()
325 SequenceI seq1 = new Sequence("", "abcdefghijklm");
326 SearchResultsI sr = new SearchResults();
327 sr.addResult(seq1, 3, 5);
328 assertEquals(1, sr.getCount());
329 sr.addResult(seq1, 3, 5);
330 assertEquals(1, sr.getCount());
331 sr.addResult(seq1, 3, 6);
332 assertEquals(2, sr.getCount());
336 * Test to verify appending creates a minimal set of results
338 @Test(groups = { "Functional" })
339 public void testAppendResult()
341 SequenceI seq1 = new Sequence("", "abcdefghijklm"),
342 seq2 = new Sequence("", "defdefdefdef");
343 SearchResultsI sr = new SearchResults();
344 sr.appendResult(seq1, 3, 5);
345 assertEquals(1, sr.getCount());
346 sr.appendResult(seq1, 3, 6);
347 assertEquals(1, sr.getCount());
348 sr.appendResult(seq1, 8, 8);
349 assertEquals(2, sr.getCount());
350 sr.appendResult(seq1, 7, 7);
351 assertEquals(1, sr.getCount());
352 sr.appendResult(seq2, 7, 7);
353 assertEquals(2, sr.getCount());
354 sr.appendResult(seq2, 2, 7);
355 assertTrue(sr.appendResult(seq2, 7, 49));
356 assertTrue(sr.appendResult(seq2, 0, 30));
357 assertEquals(2, sr.getCount());
359 for (SearchResultMatchI sre : sr.getResults())
368 * Test for method that checks if search results matches a sequence region
370 @Test(groups = { "Functional" })
371 public void testInvolvesSequence()
373 SequenceI dataset = new Sequence("genome", "ATGGCCCTTTAAGCAACATTT");
375 SequenceI cds1 = new Sequence("cds1/1-12", "ATGGCCCTTTAA");
376 cds1.setDatasetSequence(dataset);
377 // overlapping second 'exon':
378 SequenceI cds2 = new Sequence("cds2/7-18", "CTTTAAGCAACA");
379 cds2.setDatasetSequence(dataset);
380 // unrelated sequence
381 SequenceI cds3 = new Sequence("cds3", "ATGGCCCTTTAAGCAACA");
383 SearchResults sr = new SearchResults();
384 assertFalse(sr.involvesSequence(cds1));
387 * cds1 and cds2 share the same dataset sequence, but
388 * only cds1 overlaps match 4:6 (fixes bug JAL-3613)
390 sr.addResult(dataset, 4, 6);
391 assertTrue(sr.involvesSequence(cds1));
392 assertFalse(sr.involvesSequence(cds2));
393 assertFalse(sr.involvesSequence(cds3));
396 * search results overlap cds2 only
398 sr = new SearchResults();
399 sr.addResult(dataset, 18, 18);
400 assertFalse(sr.involvesSequence(cds1));
401 assertTrue(sr.involvesSequence(cds2));
404 * add a search result overlapping cds1
406 sr.addResult(dataset, 1, 1);
407 assertTrue(sr.involvesSequence(cds1));
408 assertTrue(sr.involvesSequence(cds2));
411 * single search result overlapping both
413 sr = new SearchResults();
414 sr.addResult(dataset, 10, 12);
415 assertTrue(sr.involvesSequence(cds1));
416 assertTrue(sr.involvesSequence(cds2));
419 * search results matching aligned sequence
421 sr = new SearchResults();
422 sr.addResult(cds1, 10, 12);
423 assertTrue(sr.involvesSequence(cds1));
424 assertFalse(sr.involvesSequence(cds2));
425 sr.addResult(cds2, 1, 3); // no start-end overlap
426 assertFalse(sr.involvesSequence(cds2));
427 sr.addResult(cds2, 7, 9); // start-end overlap
428 assertTrue(sr.involvesSequence(cds2));
432 * Test extraction of Sequence objects for matched ranges on a sequence
434 @Test(groups = { "Functional" })
435 public void testGetSequences()
437 SequenceI seq1 = new Sequence("", "abcdefghijklm");
438 SequenceI seq2 = new Sequence("", "nopqrstuvwxyz");
441 List<SequenceI> seqres = null;
443 SearchResultsI sr = new SearchResults();
444 seqres = sr.getMatchingSubSequences();
445 assertEquals(0, seqres.size());
447 sr.addResult(seq1, 3, 5);
448 seqres = sr.getMatchingSubSequences();
450 assertEquals(1, seqres.size());
451 assertEquals("cde", seqres.get(0).getSequenceAsString());
452 assertEquals(3, seqres.get(0).getStart());
453 assertEquals(seq1, seqres.get(0).getDatasetSequence());
455 sr.addResult(seq1, 3, 6);
456 seqres = sr.getMatchingSubSequences();
458 assertEquals(2, seqres.size());
459 assertEquals("cdef", seqres.get(1).getSequenceAsString());
460 assertEquals(3, seqres.get(1).getStart());
462 // this is a quirk - match on 26-29 yields subsequence 27-30
463 sr.addResult(seq2, 26, 29);
464 seqres = sr.getMatchingSubSequences();
465 assertEquals(3, seqres.size());
466 assertEquals("qrst", seqres.get(2).getSequenceAsString());
467 assertEquals(26, seqres.get(2).getStart());