Classes

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

Class SequenceGroupTest

Class SequenceGroupTest	Line # 44	Total Statements 199	Complexity 11	TOTAL Coverage 0.9855072598.6%
testAddSequence() : void   testAddSequence() : void	4646	20.020	1.01	1.0 1.0100%
testAddOrRemove() : void   testAddOrRemove() : void	7474	17.017	1.01	1.0 1.0100%
testGetColourScheme() : void   testGetColourScheme() : void	9898	8.08	1.01	1.0 1.0100%
testSetContext() : void   testSetContext() : void	113113	34.034	4.04	0.9117647 0.911764791.2%
testContains() : void   testContains() : void	179179	33.033	1.01	1.0 1.0100%
testCopyConstructor() : void   testCopyConstructor() : void	249249	53.053	1.01	1.0 1.0100%
testConstructor_list() : void   testConstructor_list() : void	326326	15.015	1.01	1.0 1.0100%
testHasSecondaryStructureAnnotation() : void   testHasSecondaryStructureAnnotation() : void	358358	19.019	1.01	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

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