Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
SequenceGroupTest	44	199	11	0.00%	Show methods

Class SequenceGroupTest

Class SequenceGroupTest	Line # 44	Total Statements 199	Complexity 11	TOTAL Coverage 0.00%
testAddSequence() : void   testAddSequence() : void	4646	20.020	1.01	0.0 0.00%
testAddOrRemove() : void   testAddOrRemove() : void	7474	17.017	1.01	0.0 0.00%
testGetColourScheme() : void   testGetColourScheme() : void	9898	8.08	1.01	0.0 0.00%
testSetContext() : void   testSetContext() : void	113113	34.034	4.04	0.0 0.00%
testContains() : void   testContains() : void	179179	33.033	1.01	0.0 0.00%
testCopyConstructor() : void   testCopyConstructor() : void	249249	53.053	1.01	0.0 0.00%
testConstructor_list() : void   testConstructor_list() : void	326326	15.015	1.01	0.0 0.00%
testHasSecondaryStructureAnnotation() : void   testHasSecondaryStructureAnnotation() : void	358358	19.019	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.Assert.assertEquals;
24		import static org.testng.Assert.assertFalse;
25		import static org.testng.Assert.assertNotNull;
26		import static org.testng.Assert.assertNotSame;
27		import static org.testng.Assert.assertNull;
28		import static org.testng.Assert.assertSame;
29		import static org.testng.Assert.assertTrue;
30		import static org.testng.Assert.fail;
31
32		import java.awt.Color;
33		import java.util.ArrayList;
34		import java.util.Collections;
35		import java.util.List;
36
37		import org.testng.annotations.Test;
38
39		import jalview.analysis.Conservation;
40		import jalview.schemes.NucleotideColourScheme;
41		import jalview.schemes.PIDColourScheme;
42		import junit.extensions.PA;
43
		0% Uncovered Elements: 207 (207) Complexity: 11 Complexity Density: 0.06
44		public class SequenceGroupTest
45		{
		0% Uncovered Elements: 20 (20) Complexity: 1 Complexity Density: 0.05 4-
46	0	@Test(groups = { "Functional" })...
47		public void testAddSequence()
48		{
49	0	SequenceGroup sg = new SequenceGroup();
50	0	assertTrue(sg.getSequences().isEmpty());
51
52	0	SequenceI seq1 = new Sequence("seq1", "abc");
53	0	SequenceI seq2 = new Sequence("seq2", "abc");
54	0	SequenceI seq3 = new Sequence(seq1);
55
56	0	sg.addSequence(null, false);
57	0	assertTrue(sg.getSequences().isEmpty());
58	0	sg.addSequence(seq1, false);
59	0	assertEquals(sg.getSequences().size(), 1);
60	0	assertTrue(sg.getSequences().contains(seq1));
61		// adding the same sequence again does nothing
62	0	sg.addSequence(seq1, false);
63	0	assertEquals(sg.getSequences().size(), 1);
64	0	assertTrue(sg.getSequences().contains(seq1));
65	0	sg.addSequence(seq2, false);
66	0	sg.addSequence(seq2, false);
67	0	sg.addSequence(seq3, false);
68	0	assertEquals(sg.getSequences().size(), 3);
69	0	assertTrue(sg.getSequences().contains(seq1));
70	0	assertTrue(sg.getSequences().contains(seq2));
71	0	assertTrue(sg.getSequences().contains(seq3));
72		}
73
		0% Uncovered Elements: 17 (17) Complexity: 1 Complexity Density: 0.06 4-
74	0	@Test(groups = { "Functional" })...
75		public void testAddOrRemove()
76		{
77	0	SequenceGroup sg = new SequenceGroup();
78	0	assertTrue(sg.getSequences().isEmpty());
79
80	0	SequenceI seq1 = new Sequence("seq1", "abc");
81	0	SequenceI seq2 = new Sequence("seq2", "abc");
82	0	SequenceI seq3 = new Sequence(seq1);
83
84	0	sg.addOrRemove(seq1, false);
85	0	assertEquals(sg.getSequences().size(), 1);
86	0	sg.addOrRemove(seq2, false);
87	0	assertEquals(sg.getSequences().size(), 2);
88	0	sg.addOrRemove(seq3, false);
89	0	assertEquals(sg.getSequences().size(), 3);
90	0	assertTrue(sg.getSequences().contains(seq1));
91	0	assertTrue(sg.getSequences().contains(seq2));
92	0	assertTrue(sg.getSequences().contains(seq3));
93	0	sg.addOrRemove(seq1, false);
94	0	assertEquals(sg.getSequences().size(), 2);
95	0	assertFalse(sg.getSequences().contains(seq1));
96		}
97
		0% Uncovered Elements: 8 (8) Complexity: 1 Complexity Density: 0.12 4-
98	0	@Test(groups = { "Functional" })...
99		public void testGetColourScheme()
100		{
101	0	SequenceGroup sg = new SequenceGroup();
102	0	assertNotNull(sg.getGroupColourScheme());
103	0	assertNull(sg.getColourScheme());
104
105	0	sg.setGroupColourScheme(null);
106	0	assertNull(sg.getColourScheme());
107
108	0	NucleotideColourScheme scheme = new NucleotideColourScheme();
109	0	sg.setColourScheme(scheme);
110	0	assertSame(scheme, sg.getColourScheme());
111		}
112
		0% Uncovered Elements: 34 (34) Complexity: 4 Complexity Density: 0.12 4-
113	0	@Test(groups = { "Functional" })...
114		public void testSetContext()
115		{
116	0	SequenceGroup sg1 = new SequenceGroup();
117	0	SequenceGroup sg2 = new SequenceGroup();
118	0	SequenceGroup sg3 = new SequenceGroup();
119	0	assertNull(sg1.getContext());
120	0	sg1.setContext(null);
121	0	assertNull(sg1.getContext());
122	0	try
123		{
124	0	sg1.setContext(sg1); // self-reference :-O
125	0	fail("Expected exception");
126		} catch (IllegalArgumentException e)
127		{
128		// expected
129	0	assertNull(sg1.getContext());
130		}
131	0	sg1.setContext(sg2);
132	0	assertSame(sg2, sg1.getContext());
133	0	sg2.setContext(sg3);
134	0	try
135		{
136	0	sg3.setContext(sg1); // circular reference :-O
137	0	fail("Expected exception");
138		} catch (IllegalArgumentException e)
139		{
140		// expected
141	0	assertNull(sg3.getContext());
142		}
143
144		/*
145		* use PrivilegedAccessor to 'force' a SequenceGroup with
146		* a circular context reference
147		*/
148	0	PA.setValue(sg2, "context", sg2);
149	0	try
150		{
151	0	sg3.setContext(sg2, false); // circular reference in sg2
152	0	fail("Expected exception");
153		} catch (IllegalArgumentException e)
154		{
155		// expected
156	0	assertNull(sg3.getContext());
157		}
158
159		// test isDefined setting behaviour
160	0	sg2 = new SequenceGroup();
161	0	sg1.setContext(null, false);
162	0	assertFalse(sg1.isDefined());
163
164	0	sg1.setContext(sg2, false);
165	0	assertFalse(sg1.isDefined());
166
167	0	sg1.setContext(sg2, true);
168	0	assertTrue(sg1.isDefined());
169
170		// setContext without defined parameter does not change isDefined
171	0	sg1.setContext(null);
172	0	assertTrue(sg1.isDefined());
173
174	0	sg1.setContext(null, false);
175	0	sg1.setContext(sg2);
176	0	assertFalse(sg1.isDefined());
177		}
178
		0% Uncovered Elements: 33 (33) Complexity: 1 Complexity Density: 0.03 4-
179	0	@Test(groups = { "Functional" })...
180		public void testContains()
181		{
182		/*
183		* essentially the same tests as AlignmentI.findGroup
184		* but from a particular group's perspective
185		*/
186
187	0	SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
188	0	SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
189	0	AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
190		/*
191		* add a group consisting of just "DEF"
192		*/
193	0	SequenceGroup sg1 = new SequenceGroup();
194	0	sg1.addSequence(seq1, false);
195	0	sg1.setStartRes(3);
196	0	sg1.setEndRes(5);
197
198		/*
199		* test sequence membership
200		*/
201	0	assertTrue(sg1.contains(seq1));
202	0	assertFalse(sg1.contains(seq2));
203
204		/*
205		* test sequence+position
206		*/
207
208	0	assertFalse(sg1.contains(seq1, 2)); // position not in group
209	0	assertFalse(sg1.contains(seq1, 6)); // position not in group
210	0	assertFalse(sg1.contains(seq2, 5)); // sequence not in group
211	0	assertTrue(sg1.contains(seq1, 3)); // yes
212	0	assertTrue(sg1.contains(seq1, 4));
213	0	assertTrue(sg1.contains(seq1, 5));
214
215		/*
216		* add a group consisting of
217		* EF--
218		* KLMN
219		*/
220	0	SequenceGroup sg2 = new SequenceGroup();
221	0	sg2.addSequence(seq1, false);
222	0	sg2.addSequence(seq2, false);
223	0	sg2.setStartRes(4);
224	0	sg2.setEndRes(7);
225	0	a.addGroup(sg2);
226
227		/*
228		* if a residue is in more than one group, method returns
229		* the first found (in order groups were added)
230		*/
231	0	assertTrue(sg2.contains(seq1, 4));
232	0	assertTrue(sg2.contains(seq1, 5));
233
234		/*
235		* seq2 only belongs to the second group
236		*/
237	0	assertTrue(sg2.contains(seq2, 4));
238	0	assertTrue(sg2.contains(seq2, 5));
239	0	assertTrue(sg2.contains(seq2, 6));
240	0	assertTrue(sg2.contains(seq2, 7));
241	0	assertFalse(sg2.contains(seq2, 3));
242	0	assertFalse(sg2.contains(seq2, 8));
243	0	sg2.setEndRes(8);
244	0	assertTrue(sg2.contains(seq2, 8));
245	0	sg2.deleteSequence(seq2, false);
246	0	assertFalse(sg2.contains(seq2));
247		}
248
		0% Uncovered Elements: 53 (53) Complexity: 1 Complexity Density: 0.02 4-
249	0	@Test(groups = { "Functional" })...
250		public void testCopyConstructor()
251		{
252	0	SequenceI seq = new Sequence("seq", "ABC");
253	0	SequenceGroup sg = new SequenceGroup();
254	0	sg.addSequence(seq, false);
255	0	sg.setName("g1");
256	0	sg.setDescription("desc");
257	0	sg.setColourScheme(new PIDColourScheme());
258	0	Conservation cons = new Conservation("Cons", 2,
259		Collections.<SequenceI> emptyList(), 3, 12);
260	0	PA.setValue(cons, "consSequence", new Sequence("s", "abc"));
261	0	sg.getGroupColourScheme().setConservation(cons);
262	0	sg.getGroupColourScheme().setConsensus(new Profiles(0,null));
263	0	sg.setDisplayBoxes(false);
264	0	sg.setDisplayText(false);
265	0	sg.setColourText(true);
266	0	PA.setValue(sg, "isDefined", true);
267	0	sg.setShowNonconserved(true);
268	0	sg.setOutlineColour(Color.red);
269	0	sg.setIdColour(Color.blue);
270	0	sg.thresholdTextColour = 1;
271	0	sg.textColour = Color.orange;
272	0	sg.textColour2 = Color.yellow;
273	0	sg.setIgnoreGapsConsensus(false);
274	0	sg.setshowSequenceLogo(true);
275	0	sg.setNormaliseSequenceLogo(true);
276	0	sg.setHidereps(true);
277	0	sg.setHideCols(true);
278	0	sg.setShowConsensusHistogram(true);
279	0	sg.setContext(new SequenceGroup());
280
281	0	SequenceGroup sg2 = new SequenceGroup(sg);
282	0	assertEquals(sg2.getName(), sg.getName());
283	0	assertEquals(sg2.getDescription(), sg.getDescription());
284	0	assertNotSame(sg2.getGroupColourScheme(), sg.getGroupColourScheme());
285	0	assertSame(sg2.getColourScheme(), sg.getColourScheme());
286	0	assertSame(PA.getValue(sg2.getGroupColourScheme(), "consensus"),
287		PA.getValue(sg.getGroupColourScheme(), "consensus"));
288	0	assertSame(PA.getValue(sg2.getGroupColourScheme(), "conservation"),
289		PA.getValue(sg.getGroupColourScheme(), "conservation"));
290	0	assertEquals(sg2.getDisplayBoxes(), sg.getDisplayBoxes());
291	0	assertEquals(sg2.getDisplayText(), sg.getDisplayText());
292	0	assertEquals(sg2.getColourText(), sg.getColourText());
293	0	assertEquals(sg2.getShowNonconserved(), sg.getShowNonconserved());
294	0	assertEquals(sg2.getOutlineColour(), sg.getOutlineColour());
295	0	assertEquals(sg2.getIdColour(), sg.getIdColour());
296	0	assertEquals(sg2.thresholdTextColour, sg.thresholdTextColour);
297	0	assertEquals(sg2.textColour, sg.textColour);
298	0	assertEquals(sg2.textColour2, sg.textColour2);
299	0	assertEquals(sg2.getIgnoreGapsConsensus(), sg.getIgnoreGapsConsensus());
300	0	assertEquals(sg2.isShowSequenceLogo(), sg.isShowSequenceLogo());
301	0	assertEquals(sg2.isNormaliseSequenceLogo(),
302		sg.isNormaliseSequenceLogo());
303	0	assertEquals(sg2.isHidereps(), sg.isHidereps());
304	0	assertEquals(sg2.isHideCols(), sg.isHideCols());
305	0	assertEquals(sg2.isShowConsensusHistogram(),
306		sg.isShowConsensusHistogram());
307
308		/*
309		* copy of sequences
310		*/
311	0	assertNotSame(sg2.getSequences(), sg.getSequences());
312	0	assertEquals(sg2.getSequences(), sg.getSequences());
313
314		/*
315		* isDefined should only be set true when a new group is added to
316		* an alignment, not in the copy constructor
317		*/
318	0	assertFalse(sg2.isDefined());
319
320		/*
321		* context should be set explicitly, not by copy
322		*/
323	0	assertNull(sg2.getContext());
324		}
325
		0% Uncovered Elements: 15 (15) Complexity: 1 Complexity Density: 0.07 4-
326	0	@Test(groups = { "Functional" })...
327		public void testConstructor_list()
328		{
329	0	SequenceI s1 = new Sequence("abcde", "fg");
330	0	SequenceI s2 = new Sequence("foo", "bar");
331	0	List<SequenceI> seqs = new ArrayList<>();
332	0	seqs.add(s1);
333	0	seqs.add(s2);
334	0	SequenceGroup sg = new SequenceGroup(seqs);
335
336		/*
337		* verify sg has a copy of the original list
338		*/
339	0	List<SequenceI> sgList = sg.getSequences();
340	0	assertNotSame(sgList, seqs);
341	0	assertEquals(sgList, seqs);
342
343		/*
344		* add to sgList, original is unchanged
345		*/
346	0	sg.addSequence(new Sequence("bar", "foo"), false);
347	0	assertEquals(sgList.size(), 3);
348	0	assertEquals(seqs.size(), 2);
349
350		/*
351		* delete from original, sgList is unchanged
352		*/
353	0	seqs.remove(s1);
354	0	assertEquals(sgList.size(), 3);
355	0	assertEquals(seqs.size(), 1);
356		}
357
		0% Uncovered Elements: 19 (19) Complexity: 1 Complexity Density: 0.05 4-
358	0	@Test(groups = { "Functional" })...
359		public void testHasSecondaryStructureAnnotation()
360		{
361	0	SequenceI s1 = new Sequence("abcde", "fg");
362	0	SequenceI s2 = new Sequence("foo", "bar");
363	0	List<SequenceI> seqs = new ArrayList<SequenceI>();
364	0	seqs.add(s1);
365	0	seqs.add(s2);
366	0	SequenceGroup sg = new SequenceGroup(seqs);
367
368	0	AlignmentAnnotation aa = new AlignmentAnnotation("Secondary Structure",
369		"Secondary Structure", 0.5);
370	0	Annotation ae[] = new Annotation[] { new Annotation("H", "H", 'H', 0f),
371		new Annotation("H", "H", 'H', 0f),
372		new Annotation("H", "H", 'H', 0f),
373		new Annotation("H", "H", 'H', 0f) };
374	0	aa.annotations = ae;
375	0	aa.validateRangeAndDisplay();
376	0	assertFalse(sg.isSecondaryStructurePresent());
377	0	s1.addAlignmentAnnotation(aa);
378	0	assertTrue(sg.isSecondaryStructurePresent());
379	0	s1.removeAlignmentAnnotation(aa);
380	0	assertFalse(sg.isSecondaryStructurePresent());
381	0	s2.addAlignmentAnnotation(aa);
382	0	assertTrue(sg.isSecondaryStructurePresent());
383	0	s2.removeAlignmentAnnotation(aa);
384	0	assertFalse(sg.isSecondaryStructurePresent());
385		}
386		}