Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
SearchResultsTest	37	228	14	0.00%	Show methods

Class SearchResultsTest

Class SearchResultsTest	Line # 37	Total Statements 228	Complexity 14	TOTAL Coverage 0.00%
setUpJvOptionPane() : void   setUpJvOptionPane() : void	4040	2.02	1.01	0.0 0.00%
testToString() : void   testToString() : void	4747	9.09	1.01	0.0 0.00%
testEquals() : void   testEquals() : void	6262	23.023	1.01	0.0 0.00%
testEquals_distinctSequences() : void   testEquals_distinctSequences() : void	106106	8.08	1.01	0.0 0.00%
testEquals_orderDiffers() : void   testEquals_orderDiffers() : void	123123	9.09	1.01	0.0 0.00%
testHashcode() : void   testHashcode() : void	141141	12.012	1.01	0.0 0.00%
testMatchConstructor() : void   testMatchConstructor() : void	174174	9.09	1.01	0.0 0.00%
testMatchContains() : void   testMatchContains() : void	190190	12.012	1.01	0.0 0.00%
testMatchAdjacent() : void   testMatchAdjacent() : void	209209	17.017	1.01	0.0 0.00%
testMarkColumns() : void   testMarkColumns() : void	237237	44.044	1.01	0.0 0.00%
testAddResult() : void   testAddResult() : void	322322	8.08	1.01	0.0 0.00%
testAppendResult() : void   testAppendResult() : void	338338	20.020	1.01	0.0 0.00%
testInvolvesSequence() : void   testInvolvesSequence() : void	370370	31.031	1.01	0.0 0.00%
testGetSequences() : void   testGetSequences() : void	434434	24.024	1.01	0.0 0.00%

 

Contributing tests

Source view

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 java.util.BitSet;
29		import java.util.List;
30
31		import org.junit.Assert;
32		import org.testng.annotations.BeforeClass;
33		import org.testng.annotations.Test;
34
35		import jalview.gui.JvOptionPane;
36
		0% Uncovered Elements: 242 (242) Complexity: 14 Complexity Density: 0.06
37		public class SearchResultsTest
38		{
39
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
40	0	@BeforeClass(alwaysRun = true)...
41		public void setUpJvOptionPane()
42		{
43	0	JvOptionPane.setInteractiveMode(false);
44	0	JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
45		}
46
		0% Uncovered Elements: 9 (9) Complexity: 1 Complexity Density: 0.11 4-
47	0	@Test(groups = { "Functional" })...
48		public void testToString()
49		{
50	0	SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
51	0	SearchResultsI sr = new SearchResults();
52	0	sr.addResult(seq, 1, 1);
53	0	assertEquals("[Seq1/1-1]", sr.toString());
54	0	sr.addResult(seq, 3, 5);
55	0	assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
56
57	0	seq = new Sequence("Seq2", "pqrstuvwxy");
58	0	sr.addResult(seq, 6, 7);
59	0	assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
60		}
61
		0% Uncovered Elements: 23 (23) Complexity: 1 Complexity Density: 0.04 4-
62	0	@Test(groups = { "Functional" })...
63		public void testEquals()
64		{
65	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
66	0	SearchResultsI sr1 = new SearchResults();
67	0	SearchResultsI sr2 = new SearchResults();
68
69	0	assertFalse(sr1.equals(null)); // null object
70	0	assertFalse(sr1.equals(seq1)); // wrong type
71	0	assertTrue(sr1.equals(sr1)); // self
72	0	assertTrue(sr1.equals(sr2)); // empty
73	0	assertTrue(sr2.equals(sr1)); // reflexive
74
75		/*
76		* if only one result is not empty
77		*/
78	0	sr1.addResult(seq1, 1, 1);
79	0	assertTrue(sr1.equals(sr1));
80	0	assertFalse(sr1.equals(sr2));
81	0	assertFalse(sr2.equals(sr1));
82
83		/*
84		* both the same
85		*/
86	0	sr2.addResult(seq1, 1, 1);
87	0	assertTrue(sr1.equals(sr2));
88	0	assertTrue(sr2.equals(sr1));
89
90		/*
91		* both have three matches
92		*/
93	0	sr1.addResult(seq1, 3, 4);
94	0	sr1.addResult(seq1, 6, 8);
95	0	sr2.addResult(seq1, 3, 4);
96	0	sr2.addResult(seq1, 6, 8);
97	0	assertTrue(sr1.equals(sr1));
98	0	assertTrue(sr2.equals(sr2));
99	0	assertTrue(sr1.equals(sr2));
100	0	assertTrue(sr2.equals(sr1));
101		}
102
103		/**
104		* Matches that are similar but for distinct sequences are not equal
105		*/
		0% Uncovered Elements: 8 (8) Complexity: 1 Complexity Density: 0.12 4-
106	0	@Test(groups = { "Functional" })...
107		public void testEquals_distinctSequences()
108		{
109	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
110	0	SequenceI seq2 = new Sequence("", "abcdefghijklm");
111	0	SearchResultsI sr1 = new SearchResults();
112	0	SearchResultsI sr2 = new SearchResults();
113
114	0	sr1.addResult(seq1, 1, 1);
115	0	sr2.addResult(seq2, 1, 1);
116	0	assertFalse(sr1.equals(sr2));
117	0	assertFalse(sr2.equals(sr1));
118		}
119
120		/**
121		* Matches that are the same except for ordering are not equal
122		*/
		0% Uncovered Elements: 9 (9) Complexity: 1 Complexity Density: 0.11 4-
123	0	@Test(groups = { "Functional" })...
124		public void testEquals_orderDiffers()
125		{
126	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
127	0	SearchResultsI sr1 = new SearchResults();
128	0	SearchResultsI sr2 = new SearchResults();
129
130	0	sr1.addResult(seq1, 1, 1);
131	0	sr1.addResult(seq1, 2, 2);
132	0	sr2.addResult(seq1, 2, 2);
133	0	sr2.addResult(seq1, 1, 1);
134	0	assertFalse(sr1.equals(sr2));
135	0	assertFalse(sr2.equals(sr1));
136		}
137
138		/**
139		* Verify that hashCode matches for equal objects
140		*/
		0% Uncovered Elements: 12 (12) Complexity: 1 Complexity Density: 0.08 4-
141	0	@Test(groups = { "Functional" })...
142		public void testHashcode()
143		{
144	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
145	0	SearchResultsI sr1 = new SearchResults();
146	0	SearchResultsI sr2 = new SearchResults();
147
148		/*
149		* both empty
150		*/
151	0	assertEquals(sr1.hashCode(), sr2.hashCode());
152
153		/*
154		* both one match
155		*/
156	0	sr1.addResult(seq1, 1, 1);
157	0	sr2.addResult(seq1, 1, 1);
158	0	assertEquals(sr1.hashCode(), sr2.hashCode());
159
160		/*
161		* both three matches
162		*/
163	0	sr1.addResult(seq1, 3, 4);
164	0	sr1.addResult(seq1, 6, 8);
165	0	sr2.addResult(seq1, 3, 4);
166	0	sr2.addResult(seq1, 6, 8);
167	0	assertEquals(sr1.hashCode(), sr2.hashCode());
168		}
169
170		/**
171		* Verify that SearchResults$Match constructor normalises start/end to the
172		* 'forwards' direction
173		*/
		0% Uncovered Elements: 9 (9) Complexity: 1 Complexity Density: 0.11 4-
174	0	@Test(groups = { "Functional" })...
175		public void testMatchConstructor()
176		{
177	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
178	0	SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
179	0	assertSame(seq1, m.getSequence());
180	0	assertEquals(2, m.getStart());
181	0	assertEquals(5, m.getEnd());
182
183		// now a reverse mapping:
184	0	m = new SearchResults().new Match(seq1, 5, 2);
185	0	assertSame(seq1, m.getSequence());
186	0	assertEquals(2, m.getStart());
187	0	assertEquals(5, m.getEnd());
188		}
189
		0% Uncovered Elements: 12 (12) Complexity: 1 Complexity Density: 0.08 4-
190	0	@Test(groups = { "Functional" })...
191		public void testMatchContains()
192		{
193	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
194	0	SequenceI seq2 = new Sequence("", "abcdefghijklm");
195	0	SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
196
197	0	assertTrue(m.contains(seq1, 2, 5));
198	0	assertTrue(m.contains(seq1, 3, 5));
199	0	assertTrue(m.contains(seq1, 2, 4));
200	0	assertTrue(m.contains(seq1, 3, 3));
201
202	0	assertFalse(m.contains(seq1, 2, 6));
203	0	assertFalse(m.contains(seq1, 1, 5));
204	0	assertFalse(m.contains(seq1, 1, 8));
205	0	assertFalse(m.contains(seq2, 3, 3));
206	0	assertFalse(m.contains(null, 3, 3));
207		}
208
		0% Uncovered Elements: 17 (17) Complexity: 1 Complexity Density: 0.06 4-
209	0	@Test(groups = { "Functional" })...
210		public void testMatchAdjacent()
211		{
212	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
213	0	SequenceI seq2 = new Sequence("", "abcdefghijklm");
214	0	SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
215
216	0	assertTrue(m.adjacent(seq1, 2, 5));
217	0	assertTrue(m.adjacent(seq1, 3, 5));
218	0	assertTrue(m.adjacent(seq1, 2, 4));
219	0	assertTrue(m.adjacent(seq1, 3, 3));
220
221	0	assertTrue(m.adjacent(seq1, 2, 6));
222	0	assertTrue(m.adjacent(seq1, 1, 5));
223	0	assertTrue(m.adjacent(seq1, 1, 8));
224	0	assertFalse(m.adjacent(seq1, 0, 0));
225	0	assertFalse(m.adjacent(seq1, 7, 8));
226	0	assertTrue(m.adjacent(seq1, 6, 8));
227	0	assertTrue(m.adjacent(seq1, 5, 8));
228	0	assertTrue(m.adjacent(seq1, 0, 1));
229
230	0	assertFalse(m.adjacent(seq2, 3, 3));
231	0	assertFalse(m.adjacent(null, 3, 3));
232		}
233
234		/**
235		* test markColumns for creating column selections
236		*/
		0% Uncovered Elements: 44 (44) Complexity: 1 Complexity Density: 0.02 4-
237	0	@Test(groups = { "Functional" })...
238		public void testMarkColumns()
239		{
240	0	int marked = 0;
241	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
242	0	SequenceI seq2 = new Sequence("", "abcdefghijklm");
243	0	SequenceGroup s1g = new SequenceGroup(), s2g = new SequenceGroup(),
244		sallg = new SequenceGroup();
245	0	s1g.addSequence(seq1, false);
246	0	s2g.addSequence(seq2, false);
247	0	sallg.addSequence(seq1, false);
248	0	sallg.addSequence(seq2, false);
249
250	0	SearchResultsI sr = new SearchResults();
251	0	BitSet bs = new BitSet();
252
253	0	SearchResultMatchI srm = null;
254	0	srm = sr.addResult(seq1, 1, 1);
255	0	Assert.assertNotNull("addResult didn't return Match", srm);
256	0	srm = sr.addResult(seq2, 1, 2);
257	0	assertEquals("Sequence reference not set", seq2, srm.getSequence());
258	0	assertEquals("match start incorrect", 1, srm.getStart());
259	0	assertEquals("match end incorrect", 2, srm.getEnd());
260
261		// set start/end range for groups to cover matches
262
263	0	s1g.setStartRes(0);
264	0	s1g.setEndRes(5);
265	0	s2g.setStartRes(0);
266	0	s2g.setEndRes(5);
267	0	sallg.setStartRes(0);
268	0	sallg.setEndRes(5);
269
270		/*
271		* just seq1
272		*/
273	0	marked = sr.markColumns(s1g, bs);
274		// check the bitset cardinality before checking the return value
275	0	assertEquals("Didn't mark expected number", 1, bs.cardinality());
276	0	assertEquals("Didn't return count of number of bits marked", 1, marked);
277	0	assertTrue("Didn't mark expected position", bs.get(0));
278		// now check return value for marking the same again
279	0	assertEquals(
280		"Didn't count number of bits marked for existing marked set", 0,
281		sr.markColumns(s1g, bs));
282	0	bs.clear();
283
284		/*
285		* just seq2
286		*/
287	0	marked = sr.markColumns(s2g, bs);
288	0	assertEquals("Didn't mark expected number", 2, bs.cardinality());
289	0	assertEquals("Didn't return count of number of bits marked", 2, marked);
290	0	assertTrue("Didn't mark expected position (1)", bs.get(0));
291	0	assertTrue("Didn't mark expected position (2)", bs.get(1));
292
293		/*
294		* both seq1 and seq2
295		* should be same as seq2
296		*/
297	0	BitSet allbs = new BitSet();
298	0	assertEquals(2, sr.markColumns(sallg, allbs));
299	0	assertEquals(bs, allbs);
300
301		// now check range selection
302
303		/*
304		* limit s2g to just the second column, sallg to the first column
305		*/
306	0	s2g.setStartRes(1);
307	0	s2g.setEndRes(1);
308	0	sallg.setEndRes(0);
309	0	BitSet tbs = new BitSet();
310	0	assertEquals("Group start/end didn't select columns to mark", 1,
311		sr.markColumns(s2g, tbs));
312	0	assertEquals("Group start/end didn't select columns to mark", 1,
313		sr.markColumns(sallg, tbs));
314	0	assertEquals(
315		"Didn't set expected number of columns in total for two successive marks",
316		2, tbs.cardinality());
317		}
318
319		/**
320		* Test to verify adding doesn't create duplicate results
321		*/
		0% Uncovered Elements: 8 (8) Complexity: 1 Complexity Density: 0.12 4-
322	0	@Test(groups = { "Functional" })...
323		public void testAddResult()
324		{
325	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
326	0	SearchResultsI sr = new SearchResults();
327	0	sr.addResult(seq1, 3, 5);
328	0	assertEquals(1, sr.getCount());
329	0	sr.addResult(seq1, 3, 5);
330	0	assertEquals(1, sr.getCount());
331	0	sr.addResult(seq1, 3, 6);
332	0	assertEquals(2, sr.getCount());
333		}
334
335		/**
336		* Test to verify appending creates a minimal set of results
337		*/
		0% Uncovered Elements: 20 (20) Complexity: 1 Complexity Density: 0.05 4-
338	0	@Test(groups = { "Functional" })...
339		public void testAppendResult()
340		{
341	0	SequenceI seq1 = new Sequence("", "abcdefghijklm"),
342		seq2 = new Sequence("", "defdefdefdef");
343	0	SearchResultsI sr = new SearchResults();
344	0	sr.appendResult(seq1, 3, 5);
345	0	assertEquals(1, sr.getCount());
346	0	sr.appendResult(seq1, 3, 6);
347	0	assertEquals(1, sr.getCount());
348	0	sr.appendResult(seq1, 8, 8);
349	0	assertEquals(2, sr.getCount());
350	0	sr.appendResult(seq1, 7, 7);
351	0	assertEquals(1, sr.getCount());
352	0	sr.appendResult(seq2, 7, 7);
353	0	assertEquals(2, sr.getCount());
354	0	sr.appendResult(seq2, 2, 7);
355	0	assertTrue(sr.appendResult(seq2, 7, 49));
356	0	assertTrue(sr.appendResult(seq2, 0, 30));
357	0	assertEquals(2, sr.getCount());
358	0	int c = 0;
359	0	for (SearchResultMatchI sre : sr.getResults())
360		{
361	0	c++;
362		}
363	0	assertEquals(c, 2);
364
365		}
366
367		/**
368		* Test for method that checks if search results matches a sequence region
369		*/
		0% Uncovered Elements: 31 (31) Complexity: 1 Complexity Density: 0.03 4-
370	0	@Test(groups = { "Functional" })...
371		public void testInvolvesSequence()
372		{
373	0	SequenceI dataset = new Sequence("genome", "ATGGCCCTTTAAGCAACATTT");
374		// first 'exon':
375	0	SequenceI cds1 = new Sequence("cds1/1-12", "ATGGCCCTTTAA");
376	0	cds1.setDatasetSequence(dataset);
377		// overlapping second 'exon':
378	0	SequenceI cds2 = new Sequence("cds2/7-18", "CTTTAAGCAACA");
379	0	cds2.setDatasetSequence(dataset);
380		// unrelated sequence
381	0	SequenceI cds3 = new Sequence("cds3", "ATGGCCCTTTAAGCAACA");
382
383	0	SearchResults sr = new SearchResults();
384	0	assertFalse(sr.involvesSequence(cds1));
385
386		/*
387		* cds1 and cds2 share the same dataset sequence, but
388		* only cds1 overlaps match 4:6 (fixes bug JAL-3613)
389		*/
390	0	sr.addResult(dataset, 4, 6);
391	0	assertTrue(sr.involvesSequence(cds1));
392	0	assertFalse(sr.involvesSequence(cds2));
393	0	assertFalse(sr.involvesSequence(cds3));
394
395		/*
396		* search results overlap cds2 only
397		*/
398	0	sr = new SearchResults();
399	0	sr.addResult(dataset, 18, 18);
400	0	assertFalse(sr.involvesSequence(cds1));
401	0	assertTrue(sr.involvesSequence(cds2));
402
403		/*
404		* add a search result overlapping cds1
405		*/
406	0	sr.addResult(dataset, 1, 1);
407	0	assertTrue(sr.involvesSequence(cds1));
408	0	assertTrue(sr.involvesSequence(cds2));
409
410		/*
411		* single search result overlapping both
412		*/
413	0	sr = new SearchResults();
414	0	sr.addResult(dataset, 10, 12);
415	0	assertTrue(sr.involvesSequence(cds1));
416	0	assertTrue(sr.involvesSequence(cds2));
417
418		/*
419		* search results matching aligned sequence
420		*/
421	0	sr = new SearchResults();
422	0	sr.addResult(cds1, 10, 12);
423	0	assertTrue(sr.involvesSequence(cds1));
424	0	assertFalse(sr.involvesSequence(cds2));
425	0	sr.addResult(cds2, 1, 3); // no start-end overlap
426	0	assertFalse(sr.involvesSequence(cds2));
427	0	sr.addResult(cds2, 7, 9); // start-end overlap
428	0	assertTrue(sr.involvesSequence(cds2));
429		}
430
431		/**
432		* Test extraction of Sequence objects for matched ranges on a sequence
433		*/
		0% Uncovered Elements: 24 (24) Complexity: 1 Complexity Density: 0.04 4-
434	0	@Test(groups = { "Functional" })...
435		public void testGetSequences()
436		{
437	0	SequenceI seq1 = new Sequence("", "abcdefghijklm");
438	0	SequenceI seq2 = new Sequence("", "nopqrstuvwxyz");
439	0	seq2.setStart(23);
440	0	seq2.setEnd(35);
441	0	List<SequenceI> seqres = null;
442
443	0	SearchResultsI sr = new SearchResults();
444	0	seqres = sr.getMatchingSubSequences();
445	0	assertEquals(0, seqres.size());
446
447	0	sr.addResult(seq1, 3, 5);
448	0	seqres = sr.getMatchingSubSequences();
449
450	0	assertEquals(1, seqres.size());
451	0	assertEquals("cde", seqres.get(0).getSequenceAsString());
452	0	assertEquals(3, seqres.get(0).getStart());
453	0	assertEquals(seq1, seqres.get(0).getDatasetSequence());
454
455	0	sr.addResult(seq1, 3, 6);
456	0	seqres = sr.getMatchingSubSequences();
457
458	0	assertEquals(2, seqres.size());
459	0	assertEquals("cdef", seqres.get(1).getSequenceAsString());
460	0	assertEquals(3, seqres.get(1).getStart());
461
462		// this is a quirk - match on 26-29 yields subsequence 27-30
463	0	sr.addResult(seq2, 26, 29);
464	0	seqres = sr.getMatchingSubSequences();
465	0	assertEquals(3, seqres.size());
466	0	assertEquals("qrst", seqres.get(2).getSequenceAsString());
467	0	assertEquals(26, seqres.get(2).getStart());
468		}
469
470		}