Classes

Class	Line #	Total Statements	Complexity	Uncovered Elements	TOTAL Coverage	Actions
SearchResultsTest	36	116	8	0	1.0100%	Show methods

Class SearchResultsTest

Class SearchResultsTest	Line # 36	Total Statements 116	Complexity 8	Uncovered Elements 0	TOTAL Coverage 1.0100%
setUpJvOptionPane() : void   setUpJvOptionPane() : void	3939	2.02	1.01	0.00	1.0 1.0100%
testToString() : void   testToString() : void	4646	9.09	1.01	0.00	1.0 1.0100%
testEquals() : void   testEquals() : void	6161	23.023	1.01	0.00	1.0 1.0100%
testEquals_distinctSequences() : void   testEquals_distinctSequences() : void	105105	8.08	1.01	0.00	1.0 1.0100%
testEquals_orderDiffers() : void   testEquals_orderDiffers() : void	122122	9.09	1.01	0.00	1.0 1.0100%
testHashcode() : void   testHashcode() : void	140140	12.012	1.01	0.00	1.0 1.0100%
testMatchConstructor() : void   testMatchConstructor() : void	173173	9.09	1.01	0.00	1.0 1.0100%
testMarkColumns() : void   testMarkColumns() : void	192192	44.044	1.01	0.00	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.36290324	jalview.datamodel.SearchResultsTest.testMarkColumnsjalview.datamodel.SearchResultsTest.testMarkColumns	1PASS
	0.19354838	jalview.datamodel.SearchResultsTest.testEqualsjalview.datamodel.SearchResultsTest.testEquals	1PASS
	0.10483871	jalview.datamodel.SearchResultsTest.testHashcodejalview.datamodel.SearchResultsTest.testHashcode	1PASS
	0.08064516	jalview.datamodel.SearchResultsTest.testEquals_orderDiffersjalview.datamodel.SearchResultsTest.testEquals_orderDiffers	1PASS
	0.08064516	jalview.datamodel.SearchResultsTest.testToStringjalview.datamodel.SearchResultsTest.testToString	1PASS
	0.08064516	jalview.datamodel.SearchResultsTest.testMatchConstructorjalview.datamodel.SearchResultsTest.testMatchConstructor	1PASS
	0.07258064	jalview.datamodel.SearchResultsTest.testEquals_distinctSequencesjalview.datamodel.SearchResultsTest.testEquals_distinctSequences	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 jalview.gui.JvOptionPane;
29
30		import java.util.BitSet;
31
32		import org.junit.Assert;
33		import org.testng.annotations.BeforeClass;
34		import org.testng.annotations.Test;
35
		100% Uncovered Elements: 0 (124) Complexity: 8 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
189		/**
190		* test markColumns for creating column selections
191		*/
		100% Uncovered Elements: 0 (44) Complexity: 1 Complexity Density: 0.02 1PASS
192	1	@Test(groups = { "Functional" })...
193		public void testMarkColumns()
194		{
195	1	int marked = 0;
196	1	SequenceI seq1 = new Sequence("", "abcdefghijklm");
197	1	SequenceI seq2 = new Sequence("", "abcdefghijklm");
198	1	SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
199	1	s1g.addSequence(seq1, false);
200	1	s2g.addSequence(seq2, false);
201	1	sallg.addSequence(seq1, false);
202	1	sallg.addSequence(seq2, false);
203
204	1	SearchResultsI sr = new SearchResults();
205	1	BitSet bs = new BitSet();
206
207	1	SearchResultMatchI srm = null;
208	1	srm = sr.addResult(seq1, 1, 1);
209	1	Assert.assertNotNull("addResult didn't return Match", srm);
210	1	srm = sr.addResult(seq2, 1, 2);
211	1	assertEquals("Sequence reference not set", seq2, srm.getSequence());
212	1	assertEquals("match start incorrect", 1, srm.getStart());
213	1	assertEquals("match end incorrect", 2, srm.getEnd());
214
215		// set start/end range for groups to cover matches
216
217	1	s1g.setStartRes(0);
218	1	s1g.setEndRes(5);
219	1	s2g.setStartRes(0);
220	1	s2g.setEndRes(5);
221	1	sallg.setStartRes(0);
222	1	sallg.setEndRes(5);
223
224		/*
225		* just seq1
226		*/
227	1	marked = sr.markColumns(s1g, bs);
228		// check the bitset cardinality before checking the return value
229	1	assertEquals("Didn't mark expected number", 1, bs.cardinality());
230	1	assertEquals("Didn't return count of number of bits marked", 1, marked);
231	1	assertTrue("Didn't mark expected position", bs.get(0));
232		// now check return value for marking the same again
233	1	assertEquals(
234		"Didn't count number of bits marked for existing marked set",
235		0,
236		sr.markColumns(s1g, bs));
237	1	bs.clear();
238
239		/*
240		* just seq2
241		*/
242	1	marked = sr.markColumns(s2g, bs);
243	1	assertEquals("Didn't mark expected number", 2, bs.cardinality());
244	1	assertEquals("Didn't return count of number of bits marked", 2, marked);
245	1	assertTrue("Didn't mark expected position (1)", bs.get(0));
246	1	assertTrue("Didn't mark expected position (2)", bs.get(1));
247
248		/*
249		* both seq1 and seq2
250		* should be same as seq2
251		*/
252	1	BitSet allbs = new BitSet();
253	1	assertEquals(2, sr.markColumns(sallg, allbs));
254	1	assertEquals(bs, allbs);
255
256		// now check range selection
257
258		/*
259		* limit s2g to just the second column, sallg to the first column
260		*/
261	1	s2g.setStartRes(1);
262	1	s2g.setEndRes(1);
263	1	sallg.setEndRes(0);
264	1	BitSet tbs = new BitSet();
265	1	assertEquals("Group start/end didn't select columns to mark",1, sr.markColumns(s2g, tbs));
266	1	assertEquals("Group start/end didn't select columns to mark", 1, sr.markColumns(sallg, tbs));
267	1	assertEquals(
268		"Didn't set expected number of columns in total for two successive marks",
269		2, tbs.cardinality());
270		}
271		}