Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
SearchResultsTest	36	167	11	1.0100%	Show methods

Class SearchResultsTest

Class SearchResultsTest	Line # 36	Total Statements 167	Complexity 11	TOTAL Coverage 1.0100%
setUpJvOptionPane() : void   setUpJvOptionPane() : void	3939	2.02	1.01	1.0 1.0100%
testToString() : void   testToString() : void	4646	9.09	1.01	1.0 1.0100%
testEquals() : void   testEquals() : void	6161	23.023	1.01	1.0 1.0100%
testEquals_distinctSequences() : void   testEquals_distinctSequences() : void	105105	8.08	1.01	1.0 1.0100%
testEquals_orderDiffers() : void   testEquals_orderDiffers() : void	122122	9.09	1.01	1.0 1.0100%
testHashcode() : void   testHashcode() : void	140140	12.012	1.01	1.0 1.0100%
testMatchConstructor() : void   testMatchConstructor() : void	173173	9.09	1.01	1.0 1.0100%
testMatchContains() : void   testMatchContains() : void	189189	12.012	1.01	1.0 1.0100%
testMarkColumns() : void   testMarkColumns() : void	211211	44.044	1.01	1.0 1.0100%
testAddResult() : void   testAddResult() : void	294294	8.08	1.01	1.0 1.0100%
testInvolvesSequence() : void   testInvolvesSequence() : void	310310	31.031	1.01	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.252809	jalview.datamodel.SearchResultsTest.testMarkColumnsjalview.datamodel.SearchResultsTest.testMarkColumns	1PASS
	0.17977528	jalview.datamodel.SearchResultsTest.testInvolvesSequencejalview.datamodel.SearchResultsTest.testInvolvesSequence	1PASS
	0.13483146	jalview.datamodel.SearchResultsTest.testEqualsjalview.datamodel.SearchResultsTest.testEquals	1PASS
	0.073033705	jalview.datamodel.SearchResultsTest.testHashcodejalview.datamodel.SearchResultsTest.testHashcode	1PASS
	0.073033705	jalview.datamodel.SearchResultsTest.testMatchContainsjalview.datamodel.SearchResultsTest.testMatchContains	1PASS
	0.056179777	jalview.datamodel.SearchResultsTest.testEquals_orderDiffersjalview.datamodel.SearchResultsTest.testEquals_orderDiffers	1PASS
	0.056179777	jalview.datamodel.SearchResultsTest.testMatchConstructorjalview.datamodel.SearchResultsTest.testMatchConstructor	1PASS
	0.056179777	jalview.datamodel.SearchResultsTest.testToStringjalview.datamodel.SearchResultsTest.testToString	1PASS
	0.050561797	jalview.datamodel.SearchResultsTest.testEquals_distinctSequencesjalview.datamodel.SearchResultsTest.testEquals_distinctSequences	1PASS
	0.050561797	jalview.datamodel.SearchResultsTest.testAddResultjalview.datamodel.SearchResultsTest.testAddResult	1PASS

 

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