Classes

Class	Line #	Total Statements	% Filtered	Complexity	Uncovered Elements	TOTAL Coverage	Actions
FilterTestSuite	48	14	0%	5	1	0.9473684494.7%	Show methods
FilterTestSuite.Initialized	58	0	-	0	0	-1.0 -	Show methods
FilterTestSuite.Scope	64	0	-	0	0	-1.0 -	Show methods
FilterTestSuite.TestClassRunnerForParameters	77	25	0%	15	6	0.8461538684.6%	Show methods

Class FilterTestSuite

Class FilterTestSuite	Line # 48	Total Statements 14	% Filtered 0%	Complexity 5	Uncovered Elements 1	TOTAL Coverage 0.9473684494.7%
FilterTestSuite(Class< ? >)   FilterTestSuite(Class< ? >)	184184	12.012	0.00%	3.03	1.01	0.9285714 0.928571492.9%
getChildren() : List<Runner>   getChildren() : List<Runner>	208208	1.01	0.00%	1.01	0.00	1.0 1.0100%
getDescription() : Description   getDescription() : Description	221221	1.01	0.00%	1.01	0.00	1.0 1.0100%

 

Class FilterTestSuite.Initialized

Class FilterTestSuite.Initialized	Line # 58	Total Statements 0	% Filtered -	Complexity 0	Uncovered Elements 0	TOTAL Coverage -1.0 -

 

Class FilterTestSuite.Scope

Class FilterTestSuite.Scope	Line # 64	Total Statements 0	% Filtered -	Complexity 0	Uncovered Elements 0	TOTAL Coverage -1.0 -

 

Class FilterTestSuite.TestClassRunnerForParameters

Class FilterTestSuite.TestClassRunnerForParameters	Line # 77	Total Statements 25	% Filtered 0%	Complexity 15	Uncovered Elements 6	TOTAL Coverage 0.8461538684.6%
TestClassRunnerForParameters(Class< ? >,TestConfiguration)   TestClassRunnerForParameters(Class< ? >,TestConfiguration)	8383	2.02	0.00%	1.01	0.00	1.0 1.0100%
createTest() : Object   createTest() : Object	9090	1.01	0.00%	1.01	0.00	1.0 1.0100%
getName() : String   getName() : String	9797	1.01	0.00%	2.02	1.01	0.6666667 0.666666766.7%
testName(FrameworkMethod) : String   testName(FrameworkMethod) : String	103103	1.01	0.00%	1.01	0.00	1.0 1.0100%
validateConstructor(List<Throwable>) : void   validateConstructor(List<Throwable>) : void	109109	1.01	0.00%	1.01	0.00	1.0 1.0100%
classBlock(RunNotifier) : Statement   classBlock(RunNotifier) : Statement	115115	1.01	0.00%	1.01	0.00	1.0 1.0100%
runChild(FrameworkMethod,RunNotifier) : void   runChild(FrameworkMethod,RunNotifier) : void	125125	10.010	0.00%	3.03	3.03	0.75 0.7575%
initializeComponentManager(RunNotifier) : void   initializeComponentManager(RunNotifier) : void	151151	4.04	0.00%	2.02	1.01	0.75 0.7575%
shutdownComponentManager(RunNotifier) : void   shutdownComponentManager(RunNotifier) : void	163163	3.03	0.00%	2.02	1.01	0.6666667 0.666666766.7%
getComponentManager() : ComponentManager   getComponentManager() : ComponentManager	173173	1.01	0.00%	1.01	0.00	1.0 1.0100%

 

Contributing tests

Source view

1		/*
2		* See the NOTICE file distributed with this work for additional
3		* information regarding copyright ownership.
4		*
5		* This is free software; you can redistribute it and/or modify it
6		* under the terms of the GNU Lesser General Public License as
7		* published by the Free Software Foundation; either version 2.1 of
8		* the License, or (at your option) any later version.
9		*
10		* This software is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13		* Lesser General Public License for more details.
14		*
15		* You should have received a copy of the GNU Lesser General Public
16		* License along with this software; if not, write to the Free
17		* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18		* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19		*/
20		package org.xwiki.filter.test.integration;
21
22		import java.lang.annotation.ElementType;
23		import java.lang.annotation.Retention;
24		import java.lang.annotation.RetentionPolicy;
25		import java.lang.annotation.Target;
26		import java.lang.reflect.Method;
27		import java.util.ArrayList;
28		import java.util.Collections;
29		import java.util.List;
30
31		import org.junit.runner.Description;
32		import org.junit.runner.Runner;
33		import org.junit.runner.notification.Failure;
34		import org.junit.runner.notification.RunNotifier;
35		import org.junit.runners.BlockJUnit4ClassRunner;
36		import org.junit.runners.Suite;
37		import org.junit.runners.model.FrameworkMethod;
38		import org.junit.runners.model.InitializationError;
39		import org.junit.runners.model.Statement;
40		import org.xwiki.component.manager.ComponentManager;
41		import org.xwiki.test.mockito.MockitoComponentManager;
42
43		/**
44		*
45		* @version $Id: b4cb4ec653e3f09c62877cc32290abf5e1385a84 $
46		* @since 6.2M1
47		*/
		94.7% Uncovered Elements: 1 (19) Complexity: 5 Complexity Density: 0.36
48		public class FilterTestSuite extends Suite
49		{
50		private static final TestDataGenerator GENERATOR = new TestDataGenerator();
51
52		private static final String DEFAULT_PATTERN = ".*\\.test";
53
54		private final Object klassInstance;
55
56		@Retention(RetentionPolicy.RUNTIME)
57		@Target(ElementType.METHOD)
		- Uncovered Elements: 0 (0) Complexity: 0 Complexity Density: -
58		public static @interface Initialized
59		{
60		}
61
62		@Retention(RetentionPolicy.RUNTIME)
63		@Target(ElementType.TYPE)
		- Uncovered Elements: 0 (0) Complexity: 0 Complexity Density: -
64		public static @interface Scope
65		{
66		/**
67		* @return the classpath prefix to search in
68		*/
69		String value() default "";
70
71		/**
72		* @return the regex pattern to filter *.test files to execute
73		*/
74		String pattern() default DEFAULT_PATTERN;
75		}
76
		84.6% Uncovered Elements: 6 (39) Complexity: 15 Complexity Density: 0.6
77		private class TestClassRunnerForParameters extends BlockJUnit4ClassRunner
78		{
79		private final MockitoComponentManager mockitoComponentManager = new MockitoComponentManager();
80
81		private final TestConfiguration configuration;
82
		100% Uncovered Elements: 0 (2) Complexity: 1 Complexity Density: 0.5
83	32	TestClassRunnerForParameters(Class< ? > type, TestConfiguration configuration) throws InitializationError...
84		{
85	32	super(type);
86
87	32	this.configuration = configuration;
88		}
89
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
90	32	@Override...
91		public Object createTest() throws Exception
92		{
93	32	return getTestClass().getOnlyConstructor().newInstance(
94		new Object[] {this.configuration, getComponentManager()});
95		}
96
		66.7% Uncovered Elements: 1 (3) Complexity: 2 Complexity Density: 2
97	64	@Override...
98		protected String getName()
99		{
100	64	return this.configuration.name != null ? this.configuration.name : super.getName();
101		}
102
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
103	32	@Override...
104		protected String testName(final FrameworkMethod method)
105		{
106	32	return getName();
107		}
108
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
109	32	@Override...
110		protected void validateConstructor(List<Throwable> errors)
111		{
112	32	validateOnlyOneConstructor(errors);
113		}
114
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
115	32	@Override...
116		protected Statement classBlock(RunNotifier notifier)
117		{
118	32	return childrenInvoker(notifier);
119		}
120
121		/**
122		* Initialize the Component Manager and call all methods annotated with {@link Initialized} in the suite, before
123		* each test is executed, to ensure test isolation.
124		*/
		75% Uncovered Elements: 3 (12) Complexity: 3 Complexity Density: 0.3
125	32	@Override...
126		protected void runChild(FrameworkMethod method, RunNotifier notifier)
127		{
128	32	initializeComponentManager(notifier);
129
130		// Check all methods for a ComponentManager annotation and call the found ones.
131	32	try {
132	32	for (Method klassMethod : klassInstance.getClass().getMethods()) {
133	289	Initialized componentManagerAnnotation = klassMethod.getAnnotation(Initialized.class);
134	289	if (componentManagerAnnotation != null) {
135		// Call it!
136	0	klassMethod.invoke(klassInstance, getComponentManager());
137		}
138		}
139		} catch (Exception e) {
140	0	notifier.fireTestFailure(new Failure(getDescription(), new RuntimeException(
141		"Failed to call Component Manager initialization method", e)));
142		}
143
144	32	try {
145	32	super.runChild(method, notifier);
146		} finally {
147	32	shutdownComponentManager(notifier);
148		}
149		}
150
		75% Uncovered Elements: 1 (4) Complexity: 2 Complexity Density: 0.5
151	32	private void initializeComponentManager(RunNotifier notifier)...
152		{
153	32	try {
154	32	this.mockitoComponentManager.initializeTest(klassInstance);
155	32	this.mockitoComponentManager.registerMemoryConfigurationSource();
156		} catch (Exception e) {
157	0	notifier.fireTestFailure(new Failure(getDescription(), new RuntimeException(
158		"Failed to initialize Component Manager", e)));
159		}
160
161		}
162
		66.7% Uncovered Elements: 1 (3) Complexity: 2 Complexity Density: 0.67
163	32	private void shutdownComponentManager(RunNotifier notifier)...
164		{
165	32	try {
166	32	this.mockitoComponentManager.shutdownTest();
167		} catch (Exception e) {
168	0	notifier.fireTestFailure(new Failure(getDescription(), new RuntimeException(
169		"Failed to shutdown Component Manager", e)));
170		}
171		}
172
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
173	32	private ComponentManager getComponentManager() throws Exception...
174		{
175	32	return this.mockitoComponentManager;
176		}
177		}
178
179		private final ArrayList<Runner> runners = new ArrayList<Runner>();
180
181		/**
182		* Only called reflectively. Do not use programmatically.
183		*/
		92.9% Uncovered Elements: 1 (14) Complexity: 3 Complexity Density: 0.25
184	3	public FilterTestSuite(Class< ? > klass) throws Throwable...
185		{
186	3	super(klass, Collections.<Runner> emptyList());
187
188	3	try {
189	3	this.klassInstance = klass.newInstance();
190		} catch (Exception e) {
191	0	throw new RuntimeException("Failed to construct instance of [" + klass.getName() + "]", e);
192		}
193
194		// If a Scope Annotation is present then use it to define the scope
195	3	Scope scopeAnnotation = klass.getAnnotation(Scope.class);
196	3	String packagePrefix = "";
197	3	String pattern = DEFAULT_PATTERN;
198	3	if (scopeAnnotation != null) {
199	2	packagePrefix = scopeAnnotation.value();
200	2	pattern = scopeAnnotation.pattern();
201		}
202
203	3	for (TestConfiguration testConfiguration : GENERATOR.generateData(packagePrefix, pattern)) {
204	32	this.runners.add(new TestClassRunnerForParameters(FilterTest.class, testConfiguration));
205		}
206		}
207
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
208	3	@Override...
209		protected List<Runner> getChildren()
210		{
211	3	return this.runners;
212		}
213
214		/**
215		* {@inheritDoc}
216		* <p>
217		* We override this method so that the JUnit results are not displayed in a test hierarchy with a
218		* single test result for each node (as it would be otherwise since RenderingTest has a single test method).
219		* </p>
220		*/
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
221	6	@Override...
222		public Description getDescription()
223		{
224	6	return Description.createSuiteDescription(getTestClass().getJavaClass());
225		}
226		}