Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
AnnotationColourGradientTest	18	96	27	1.0100%	Show methods

Class AnnotationColourGradientTest

Class AnnotationColourGradientTest	Line # 18	Total Statements 96	Complexity 27	TOTAL Coverage 1.0100%
setUp() : void   setUp() : void	3838	10.010	2.02	1.0 1.0100%
testShadeCalculation_noThreshold() : void   testShadeCalculation_noThreshold() : void	6363	5.05	2.02	1.0 1.0100%
testShadeCalculation_aboveThreshold() : void   testShadeCalculation_aboveThreshold() : void	8383	23.023	4.04	1.0 1.0100%
testShadeCalculation_belowThreshold() : void   testShadeCalculation_belowThreshold() : void	144144	22.022	4.04	1.0 1.0100%
testFindColour_aboveThreshold() : void   testFindColour_aboveThreshold() : void	206206	12.012	5.05	1.0 1.0100%
testFindColour_belowThreshold() : void   testFindColour_belowThreshold() : void	250250	11.011	5.05	1.0 1.0100%
testFindColour_noThreshold() : void   testFindColour_noThreshold() : void	285285	6.06	2.02	1.0 1.0100%
testFindColour_originalColours() : void   testFindColour_originalColours() : void	304304	7.07	3.03	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.2112676	jalview.schemes.AnnotationColourGradientTest.testShadeCalculation_aboveThresholdjalview.schemes.AnnotationColourGradientTest.testShadeCalculation_aboveThreshold	1PASS
	0.20422535	jalview.schemes.AnnotationColourGradientTest.testShadeCalculation_belowThresholdjalview.schemes.AnnotationColourGradientTest.testShadeCalculation_belowThreshold	1PASS
	0.14788732	jalview.schemes.AnnotationColourGradientTest.testFindColour_aboveThresholdjalview.schemes.AnnotationColourGradientTest.testFindColour_aboveThreshold	1PASS
	0.14084508	jalview.schemes.AnnotationColourGradientTest.testFindColour_belowThresholdjalview.schemes.AnnotationColourGradientTest.testFindColour_belowThreshold	1PASS
	0.08450704	jalview.schemes.AnnotationColourGradientTest.testFindColour_originalColoursjalview.schemes.AnnotationColourGradientTest.testFindColour_originalColours	1PASS
	0.06338028	jalview.schemes.AnnotationColourGradientTest.testFindColour_noThresholdjalview.schemes.AnnotationColourGradientTest.testFindColour_noThreshold	1PASS
	0.056338027	jalview.schemes.AnnotationColourGradientTest.testShadeCalculation_noThresholdjalview.schemes.AnnotationColourGradientTest.testShadeCalculation_noThreshold	1PASS

 

Source view

1		package jalview.schemes;
2
3		import static org.testng.Assert.assertEquals;
4
5		import jalview.datamodel.Alignment;
6		import jalview.datamodel.AlignmentAnnotation;
7		import jalview.datamodel.AlignmentI;
8		import jalview.datamodel.Annotation;
9		import jalview.datamodel.GraphLine;
10		import jalview.datamodel.Sequence;
11		import jalview.datamodel.SequenceI;
12
13		import java.awt.Color;
14
15		import org.testng.annotations.BeforeClass;
16		import org.testng.annotations.Test;
17
		100% Uncovered Elements: 0 (142) Complexity: 27 Complexity Density: 0.28
18		public class AnnotationColourGradientTest
19		{
20		final static int WIDTH = 11;
21
22		final static int THRESHOLD_FIVE = 5;
23
24		private AlignmentAnnotation ann;
25
26		private SequenceI seq;
27
28		private AlignmentI al;
29
30		Color minColour = new Color(50, 200, 150);
31
32		Color maxColour = new Color(150, 100, 250);
33
34		/**
35		* Setup creates an annotation over 11 columns with values 0-10 and threshold
36		* 5
37		*/
		100% Uncovered Elements: 0 (12) Complexity: 2 Complexity Density: 0.2
38	1	@BeforeClass(alwaysRun = true)...
39		public void setUp()
40		{
41	1	Annotation[] anns = new Annotation[WIDTH];
42		/*
43		* set annotations with values 0-10, graded colours
44		*/
45	12	for (int col = 0; col < WIDTH; col++)
46		{
47	11	int hue = col * 20;
48	11	Color colour = new Color(hue, hue, hue);
49	11	anns[col] = new Annotation("a", "a", 'a', col, colour);
50		}
51
52	1	seq = new Sequence("Seq", "");
53	1	al = new Alignment(new SequenceI[]{ seq});
54
55		/*
56		* AlignmentAnnotation constructor works out min-max range
57		*/
58	1	ann = new AlignmentAnnotation("", "", anns);
59	1	ann.setThreshold(new GraphLine(THRESHOLD_FIVE, "", Color.RED));
60	1	seq.addAlignmentAnnotation(ann);
61		}
62
		100% Uncovered Elements: 0 (7) Complexity: 2 Complexity Density: 0.4 1PASS
63	1	@Test(groups = "Functional")...
64		public void testShadeCalculation_noThreshold()
65		{
66	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
67		minColour, maxColour, AnnotationColourGradient.NO_THRESHOLD);
68	12	for (int col = 0; col < WIDTH; col++)
69		{
70	11	Color result = testee.shadeCalculation(ann, col);
71		/*
72		* column <n> is n/10 of the way from minCol to maxCol
73		*/
74	11	Color expected = new Color(50 + 10 * col, 200 - 10 * col,
75		150 + 10 * col);
76	11	assertEquals(result, expected, "for column " + col);
77		}
78		}
79
80		/**
81		* Test the 'colour above threshold' case
82		*/
		100% Uncovered Elements: 0 (29) Complexity: 4 Complexity Density: 0.17 1PASS
83	1	@Test(groups = "Functional")...
84		public void testShadeCalculation_aboveThreshold()
85		{
86	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
87		minColour, maxColour, AnnotationColourGradient.ABOVE_THRESHOLD);
88	12	for (int col = 0; col < WIDTH; col++)
89		{
90	11	Color result = testee.shadeCalculation(ann, col);
91		/*
92		* colour is derived regardless of the threshold value
93		* (the renderer will suppress colouring if above/below threshold)
94		*/
95	11	Color expected = new Color(50 + 10 * col, 200 - 10 * col,
96		150 + 10 * col);
97	11	assertEquals(result, expected, "for column " + col);
98		}
99
100		/*
101		* now make 6-10 the span of the colour range
102		* (annotation value == column number in this test)
103		*/
104	1	testee.setThresholdIsMinMax(true);
105	6	for (int col = 0; col < THRESHOLD_FIVE; col++)
106		{
107		/*
108		* colours below the threshold are computed as before
109		*/
110	5	Color expected = new Color(50 + 10 * col, 200 - 10 * col,
111		150 + 10 * col);
112	5	Color result = testee.shadeCalculation(ann, col);
113	5	assertEquals(result, expected, "for column " + col);
114		}
115	7	for (int col = THRESHOLD_FIVE; col < WIDTH; col++)
116		{
117		/*
118		* colours for values >= threshold are graduated
119		* range is 6-10 so steps of 100/5 = 20
120		*/
121	6	int factor = col - THRESHOLD_FIVE;
122	6	Color expected = new Color(50 + 20 * factor, 200 - 20 * factor,
123		150 + 20 * factor);
124	6	Color result = testee.shadeCalculation(ann, col);
125	6	assertEquals(result, expected, "for column " + col);
126		}
127
128		/*
129		* test for boundary case threshold == graphMax (JAL-3206)
130		*/
131	1	float thresh = ann.threshold.value;
132	1	ann.threshold.value = ann.graphMax;
133	1	Color result = testee.shadeCalculation(ann, WIDTH - 1);
134	1	assertEquals(result, maxColour);
135	1	testee.setThresholdIsMinMax(false);
136	1	result = testee.shadeCalculation(ann, WIDTH - 1);
137	1	assertEquals(result, maxColour);
138	1	ann.threshold.value = thresh; // reset
139		}
140
141		/**
142		* Test the 'colour below threshold' case
143		*/
		100% Uncovered Elements: 0 (28) Complexity: 4 Complexity Density: 0.18 1PASS
144	1	@Test(groups = "Functional")...
145		public void testShadeCalculation_belowThreshold()
146		{
147	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
148		minColour, maxColour, AnnotationColourGradient.BELOW_THRESHOLD);
149
150	12	for (int col = 0; col < WIDTH; col++)
151		{
152	11	Color result = testee.shadeCalculation(ann, col);
153		/*
154		* colour is derived regardless of the threshold value
155		* (the renderer will suppress colouring if above/below threshold)
156		*/
157	11	Color expected = new Color(50 + 10 * col, 200 - 10 * col,
158		150 + 10 * col);
159	11	assertEquals(result, expected, "for column " + col);
160		}
161
162		/*
163		* now make 0-5 the span of the colour range
164		* (annotation value == column number in this test)
165		*/
166	1	testee.setThresholdIsMinMax(true);
167	6	for (int col = THRESHOLD_FIVE + 1; col < WIDTH; col++)
168		{
169		/*
170		* colours above the threshold are computed as before
171		*/
172	5	Color expected = new Color(50 + 10 * col, 200 - 10 * col,
173		150 + 10 * col);
174	5	Color result = testee.shadeCalculation(ann, col);
175	5	assertEquals(result, expected, "for column " + col);
176		}
177
178	7	for (int col = 0; col <= THRESHOLD_FIVE; col++)
179		{
180		/*
181		* colours for values <= threshold are graduated
182		* range is 0-5 so steps of 100/5 = 20
183		*/
184	6	Color expected = new Color(50 + 20 * col, 200 - 20 * col,
185		150 + 20 * col);
186	6	Color result = testee.shadeCalculation(ann, col);
187	6	assertEquals(result, expected, "for column " + col);
188		}
189
190		/*
191		* test for boundary case threshold == graphMin (JAL-3206)
192		*/
193	1	float thresh = ann.threshold.value;
194	1	ann.threshold.value = ann.graphMin;
195	1	Color result = testee.shadeCalculation(ann, 0);
196	1	assertEquals(result, minColour);
197	1	testee.setThresholdIsMinMax(false);
198	1	result = testee.shadeCalculation(ann, 0);
199	1	assertEquals(result, minColour);
200	1	ann.threshold.value = thresh; // reset
201		}
202
203		/**
204		* Test the 'colour above threshold' case
205		*/
		100% Uncovered Elements: 0 (20) Complexity: 5 Complexity Density: 0.42 1PASS
206	1	@Test(groups = "Functional")...
207		public void testFindColour_aboveThreshold()
208		{
209	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
210		minColour, maxColour, AnnotationColourGradient.ABOVE_THRESHOLD);
211	1	testee = (AnnotationColourGradient) testee.getInstance(null, al);
212
213	12	for (int col = 0; col < WIDTH; col++)
214		{
215	11	Color result = testee.findColour('a', col, seq);
216		/*
217		* expect white at or below threshold of 5
218		*/
219	11	Color expected = col <= 5 ? Color.white
220		: new Color(50 + 10 * col,
221		200 - 10 * col,
222		150 + 10 * col);
223	11	assertEquals(result, expected, "for column " + col);
224		}
225
226		/*
227		* now make 6-10 the span of the colour range
228		* (annotation value == column number in this test)
229		*/
230	1	testee.setThresholdIsMinMax(true);
231	12	for (int col = 0; col < WIDTH; col++)
232		{
233		/*
234		* colours for values > threshold are graduated
235		* range is 6-10 so steps of 100/5 = 20
236		*/
237	11	int factor = col - THRESHOLD_FIVE;
238	11	Color expected = col <= 5 ? Color.white
239		: new Color(50 + 20 * factor,
240		200 - 20 * factor,
241		150 + 20 * factor);
242	11	Color result = testee.findColour('a', col, seq);
243	11	assertEquals(result, expected, "for column " + col);
244		}
245		}
246
247		/**
248		* Test the 'colour below threshold' case
249		*/
		100% Uncovered Elements: 0 (19) Complexity: 5 Complexity Density: 0.45 1PASS
250	1	@Test(groups = "Functional")...
251		public void testFindColour_belowThreshold()
252		{
253	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
254		minColour, maxColour, AnnotationColourGradient.BELOW_THRESHOLD);
255	1	testee = (AnnotationColourGradient) testee.getInstance(null, al);
256
257	12	for (int col = 0; col < WIDTH; col++)
258		{
259	11	Color result = testee.findColour('a', col, seq);
260	11	Color expected = col >= 5 ? Color.white
261		: new Color(50 + 10 * col,
262		200 - 10 * col, 150 + 10 * col);
263	11	assertEquals(result, expected, "for column " + col);
264		}
265
266		/*
267		* now make 0-5 the span of the colour range
268		* (annotation value == column number in this test)
269		*/
270	1	testee.setThresholdIsMinMax(true);
271	12	for (int col = 0; col < WIDTH; col++)
272		{
273		/*
274		* colours for values < threshold are graduated
275		* range is 0-5 so steps of 100/5 = 20
276		*/
277	11	Color expected = col >= 5 ? Color.white
278		: new Color(50 + 20 * col,
279		200 - 20 * col, 150 + 20 * col);
280	11	Color result = testee.findColour('a', col, seq);
281	11	assertEquals(result, expected, "for column " + col);
282		}
283		}
284
		100% Uncovered Elements: 0 (8) Complexity: 2 Complexity Density: 0.33 1PASS
285	1	@Test(groups = "Functional")...
286		public void testFindColour_noThreshold()
287		{
288	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
289		minColour, maxColour, AnnotationColourGradient.NO_THRESHOLD);
290	1	testee = (AnnotationColourGradient) testee.getInstance(null, al);
291
292	12	for (int col = 0; col < WIDTH; col++)
293		{
294	11	Color result = testee.findColour('a', col, seq);
295		/*
296		* column <n> is n/10 of the way from minCol to maxCol
297		*/
298	11	Color expected = new Color(50 + 10 * col, 200 - 10 * col,
299		150 + 10 * col);
300	11	assertEquals(result, expected, "for column " + col);
301		}
302		}
303
		100% Uncovered Elements: 0 (11) Complexity: 3 Complexity Density: 0.43 1PASS
304	1	@Test(groups = "Functional")...
305		public void testFindColour_originalColours()
306		{
307	1	AnnotationColourGradient testee = new AnnotationColourGradient(ann,
308		minColour, maxColour, AnnotationColourGradient.NO_THRESHOLD);
309	1	testee = (AnnotationColourGradient) testee.getInstance(null, al);
310
311		/*
312		* flag corresponding to 'use original colours' checkbox
313		* - just use the individual annotation colours
314		*/
315	1	testee.setPredefinedColours(true);
316
317		/*
318		* the annotation colour is returned, except for column 0 where it is
319		* black - in this case the colour scheme colour overrides it
320		*/
321	12	for (int col = 0; col < WIDTH; col++)
322		{
323	11	int hue = col * 20;
324	11	Color c = col == 0 ? minColour : new Color(hue, hue, hue);
325	11	assertEquals(testee.findColour('a', col, seq), c, "for column " + col);
326		}
327		}
328		}