1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.surefire.booter;
20
21 import java.io.File;
22 import java.lang.reflect.Method;
23 import java.util.ArrayList;
24 import java.util.Collections;
25 import java.util.HashMap;
26
27 import junit.framework.TestCase;
28 import org.apache.maven.surefire.api.booter.BaseProviderFactory;
29 import org.apache.maven.surefire.api.provider.ProviderParameters;
30 import org.apache.maven.surefire.api.provider.SurefireProvider;
31 import org.apache.maven.surefire.api.report.ReporterConfiguration;
32 import org.apache.maven.surefire.api.report.ReporterFactory;
33 import org.apache.maven.surefire.api.report.TestOutputReportEntry;
34 import org.apache.maven.surefire.api.report.TestReportListener;
35 import org.apache.maven.surefire.api.suite.RunResult;
36 import org.apache.maven.surefire.api.testset.DirectoryScannerParameters;
37 import org.apache.maven.surefire.api.testset.RunOrderParameters;
38 import org.apache.maven.surefire.api.testset.TestArtifactInfo;
39 import org.apache.maven.surefire.api.testset.TestListResolver;
40 import org.apache.maven.surefire.api.testset.TestRequest;
41 import org.apache.maven.surefire.api.util.RunOrder;
42
43 import static java.util.Arrays.asList;
44 import static org.apache.maven.surefire.api.cli.CommandLineOption.LOGGING_LEVEL_DEBUG;
45 import static org.apache.maven.surefire.api.cli.CommandLineOption.SHOW_ERRORS;
46
47
48
49
50 public class SurefireReflectorTest extends TestCase {
51 public void testShouldCreateFactoryWithoutException() {
52 ReporterFactory factory = new ReporterFactory() {
53 @Override
54 public TestReportListener<TestOutputReportEntry> createTestReportListener() {
55 return null;
56 }
57
58 @Override
59 public RunResult close() {
60 return null;
61 }
62 };
63 ClassLoader cl = Thread.currentThread().getContextClassLoader();
64 SurefireReflector reflector = new SurefireReflector(cl);
65 BaseProviderFactory bpf = (BaseProviderFactory) reflector.createBooterConfiguration(cl, true);
66 bpf.setReporterFactory(factory);
67 assertNotNull(bpf.getReporterFactory());
68 assertSame(factory, bpf.getReporterFactory());
69 }
70
71 public void testSetDirectoryScannerParameters() {
72 SurefireReflector surefireReflector = getReflector();
73 Object foo = getFoo();
74
75 DirectoryScannerParameters directoryScannerParameters = new DirectoryScannerParameters(
76 new File("ABC"), new ArrayList<String>(), new ArrayList<String>(), new ArrayList<String>(), "hourly");
77 surefireReflector.setDirectoryScannerParameters(foo, directoryScannerParameters);
78 assertTrue(isCalled(foo));
79 assertNotNull(((Foo) foo).getDirectoryScannerParameters());
80 }
81
82 public void testNullSetDirectoryScannerParameters() {
83 SurefireReflector surefireReflector = getReflector();
84 Object foo = getFoo();
85
86 surefireReflector.setDirectoryScannerParameters(foo, null);
87 assertTrue(isCalled(foo));
88 assertNull(((Foo) foo).getDirectoryScannerParameters());
89 }
90
91 public void testSetIfDirScannerAware() {
92 SurefireReflector surefireReflector = getReflector();
93 Object foo = getFoo();
94
95 DirectoryScannerParameters directoryScannerParameters = new DirectoryScannerParameters(
96 new File("ABC"), new ArrayList<String>(), new ArrayList<String>(), new ArrayList<String>(), "hourly");
97 surefireReflector.setIfDirScannerAware(foo, directoryScannerParameters);
98 assertTrue(isCalled(foo));
99 }
100
101 public void testRunOrderParameters() {
102 SurefireReflector surefireReflector = getReflector();
103 Object foo = getFoo();
104
105 RunOrderParameters runOrderParameters = new RunOrderParameters(RunOrder.DEFAULT, new File("."));
106 surefireReflector.setRunOrderParameters(foo, runOrderParameters);
107 assertTrue(isCalled(foo));
108 }
109
110 public void testRunOrderParametersWithRunOrderRandomSeed() {
111 SurefireReflector surefireReflector = getReflector();
112 Object foo = getFoo();
113
114
115 Long runOrderRandomSeed = 5L;
116
117 RunOrderParameters runOrderParameters =
118 new RunOrderParameters(RunOrder.DEFAULT, new File("."), runOrderRandomSeed);
119 surefireReflector.setRunOrderParameters(foo, runOrderParameters);
120 assertTrue(isCalled(foo));
121 }
122
123 public void testNullRunOrderParameters() {
124 SurefireReflector surefireReflector = getReflector();
125 Object foo = getFoo();
126
127 surefireReflector.setRunOrderParameters(foo, null);
128 assertTrue(isCalled(foo));
129 try {
130 ((Foo) foo).getRunOrderCalculator();
131 } catch (NullPointerException e) {
132 return;
133 }
134 fail();
135 }
136
137 public void testTestSuiteDefinition() {
138 SurefireReflector surefireReflector = getReflector();
139 Object foo = getFoo();
140
141 TestRequest testSuiteDefinition = new TestRequest(
142 asList(new File("file1"), new File("file2")),
143 new File("TestSOurce"),
144 new TestListResolver("aUserRequestedTest#aMethodRequested"));
145 surefireReflector.setTestSuiteDefinition(foo, testSuiteDefinition);
146 assertTrue(isCalled(foo));
147 assertNotNull(((Foo) foo).getTestRequest());
148 }
149
150 public void testNullTestSuiteDefinition() {
151 SurefireReflector surefireReflector = getReflector();
152 Object foo = getFoo();
153 surefireReflector.setTestSuiteDefinition(foo, null);
154 assertTrue(isCalled(foo));
155 assertNull(((Foo) foo).getTestRequest());
156 }
157
158 public void testProviderProperties() {
159 SurefireReflector surefireReflector = getReflector();
160 Object foo = getFoo();
161
162 surefireReflector.setProviderProperties(foo, new HashMap<>());
163 assertTrue(isCalled(foo));
164 }
165
166 public void testReporterConfiguration() {
167 SurefireReflector surefireReflector = getReflector();
168 Object foo = getFoo();
169
170 ReporterConfiguration reporterConfiguration = getReporterConfiguration();
171 surefireReflector.setReporterConfigurationAware(foo, reporterConfiguration);
172 assertTrue(isCalled(foo));
173 }
174
175 private ReporterConfiguration getReporterConfiguration() {
176 return new ReporterConfiguration(new File("CDE"), true);
177 }
178
179 public void testTestClassLoader() {
180 SurefireReflector surefireReflector = getReflector();
181 Object foo = getFoo();
182
183 surefireReflector.setTestClassLoader(foo, getClass().getClassLoader());
184 assertTrue(isCalled(foo));
185 }
186
187 public void testTestClassLoaderAware() {
188 SurefireReflector surefireReflector = getReflector();
189 Object foo = getFoo();
190
191 surefireReflector.setTestClassLoaderAware(foo, getClass().getClassLoader());
192 assertTrue(isCalled(foo));
193 }
194
195 public void testArtifactInfo() {
196 SurefireReflector surefireReflector = getReflector();
197 Object foo = getFoo();
198
199 TestArtifactInfo testArtifactInfo = new TestArtifactInfo("12.3", "test");
200 surefireReflector.setTestArtifactInfo(foo, testArtifactInfo);
201 assertTrue(isCalled(foo));
202 }
203
204 public void testNullArtifactInfo() {
205 SurefireReflector surefireReflector = getReflector();
206 Object foo = getFoo();
207
208 surefireReflector.setTestArtifactInfo(foo, null);
209 assertTrue(isCalled(foo));
210 assertNull(((Foo) foo).getTestArtifactInfo());
211 }
212
213 public void testArtifactInfoAware() {
214 SurefireReflector surefireReflector = getReflector();
215 Object foo = getFoo();
216
217 TestArtifactInfo testArtifactInfo = new TestArtifactInfo("12.3", "test");
218 surefireReflector.setTestArtifactInfoAware(foo, testArtifactInfo);
219 assertTrue(isCalled(foo));
220 assertEquals(testArtifactInfo.getClassifier(), "test");
221 assertEquals(testArtifactInfo.getVersion(), "12.3");
222 }
223
224 public void testReporterFactory() {
225 SurefireReflector surefireReflector = getReflector();
226 Object foo = getFoo();
227
228 ReporterFactory reporterFactory = new ReporterFactory() {
229 @Override
230 public TestReportListener<TestOutputReportEntry> createTestReportListener() {
231 return null;
232 }
233
234 @Override
235 public RunResult close() {
236 return null;
237 }
238 };
239
240 surefireReflector.setReporterFactory(foo, reporterFactory);
241 assertTrue(isCalled(foo));
242 }
243
244 public void testReporterFactoryAware() {
245 SurefireReflector surefireReflector = getReflector();
246 Object foo = getFoo();
247
248 ReporterFactory reporterFactory = new ReporterFactory() {
249 @Override
250 public TestReportListener<TestOutputReportEntry> createTestReportListener() {
251 return null;
252 }
253
254 @Override
255 public RunResult close() {
256 return null;
257 }
258 };
259
260 surefireReflector.setReporterFactoryAware(foo, reporterFactory);
261 assertTrue(isCalled(foo));
262 assertSame(((Foo) foo).getReporterFactory(), reporterFactory);
263 }
264
265 @SuppressWarnings("checkstyle:magicnumber")
266 public void testConvertIfRunResult() {
267 RunResult runResult = new RunResult(20, 1, 2, 3, 4, "IOException", true);
268 SurefireReflector reflector =
269 new SurefireReflector(Thread.currentThread().getContextClassLoader());
270 RunResult obj = (RunResult) reflector.convertIfRunResult(runResult);
271 assertEquals(obj.getCompletedCount(), 20);
272 assertEquals(obj.getErrors(), 1);
273 assertEquals(obj.getFailures(), 2);
274 assertEquals(obj.getSkipped(), 3);
275 assertFalse(obj.isErrorFree());
276 assertFalse(obj.isInternalError());
277 assertEquals(obj.getFailsafeCode(), (Integer) RunResult.FAILURE);
278
279 assertNull(reflector.convertIfRunResult(null));
280 assertEquals(reflector.convertIfRunResult(""), "");
281 }
282
283 public void testInstantiateProvider() {
284 SurefireReflector reflector =
285 new SurefireReflector(Thread.currentThread().getContextClassLoader());
286 Object booterParams = getFoo();
287 Object provider = reflector.instantiateProvider(DummyProvider.class.getName(), booterParams);
288 assertNotNull(provider);
289 assertEquals(provider.getClass(), DummyProvider.class);
290 }
291
292 public void testSetMainCliOptions() {
293 SurefireReflector reflector =
294 new SurefireReflector(Thread.currentThread().getContextClassLoader());
295 Object booterParams = getFoo();
296 reflector.setMainCliOptions(booterParams, asList(SHOW_ERRORS, LOGGING_LEVEL_DEBUG));
297 assertEquals(((BaseProviderFactory) booterParams).getMainCliOptions().size(), 2);
298 assertEquals(((BaseProviderFactory) booterParams).getMainCliOptions().get(0), SHOW_ERRORS);
299 assertEquals(((BaseProviderFactory) booterParams).getMainCliOptions().get(1), LOGGING_LEVEL_DEBUG);
300 }
301
302 public void testSetSkipAfterFailureCount() {
303 SurefireReflector reflector =
304 new SurefireReflector(Thread.currentThread().getContextClassLoader());
305 Foo booterParams = (Foo) getFoo();
306 assertEquals(booterParams.getSkipAfterFailureCount(), 0);
307 reflector.setSkipAfterFailureCount(booterParams, 5);
308 assertEquals(booterParams.getSkipAfterFailureCount(), 5);
309 }
310
311 @SuppressWarnings("checkstyle:magicnumber")
312 public void testSetSystemExitTimeout() {
313 SurefireReflector reflector =
314 new SurefireReflector(Thread.currentThread().getContextClassLoader());
315 Foo booterParams = (Foo) getFoo();
316 assertNull(booterParams.getSystemExitTimeout());
317 reflector.setSystemExitTimeout(booterParams, 60);
318 assertEquals(booterParams.getSystemExitTimeout(), (Integer) 60);
319 }
320
321 public void testSetTestSuiteDefinitionAware() {
322 SurefireReflector reflector =
323 new SurefireReflector(Thread.currentThread().getContextClassLoader());
324 Foo booterParams = (Foo) getFoo();
325 TestRequest request = new TestRequest(Collections.emptyList(), null, null);
326 reflector.setTestSuiteDefinitionAware(booterParams, request);
327 assertTrue(booterParams.isCalled());
328 assertNotNull(booterParams.getTestRequest());
329 assertTrue(booterParams.getTestRequest().getSuiteXmlFiles().isEmpty());
330 assertNull(booterParams.getTestRequest().getTestSourceDirectory());
331 assertNull(booterParams.getTestRequest().getTestListResolver());
332 assertEquals(booterParams.getTestRequest().getRerunFailingTestsCount(), 0);
333 }
334
335 public void testSetProviderPropertiesAware() {
336 SurefireReflector reflector =
337 new SurefireReflector(Thread.currentThread().getContextClassLoader());
338 Foo booterParams = (Foo) getFoo();
339 reflector.setProviderPropertiesAware(booterParams, Collections.singletonMap("k", "v"));
340 assertTrue(booterParams.isCalled());
341 assertNotNull(booterParams.getProviderProperties());
342 assertEquals(booterParams.getProviderProperties().size(), 1);
343 assertEquals(booterParams.getProviderProperties().get("k"), "v");
344 }
345
346 private SurefireReflector getReflector() {
347 return new SurefireReflector(getClass().getClassLoader());
348 }
349
350 private Object getFoo() {
351 return new Foo();
352 }
353
354 private Boolean isCalled(Object foo) {
355 final Method isCalled;
356 try {
357 isCalled = foo.getClass().getMethod("isCalled");
358 return (Boolean) isCalled.invoke(foo);
359 } catch (ReflectiveOperationException e) {
360 throw new RuntimeException(e);
361 }
362 }
363
364
365
366
367 public static final class DummyProvider implements SurefireProvider {
368 public DummyProvider(ProviderParameters providerParameters) {}
369
370 @Override
371 public Iterable<Class<?>> getSuites() {
372 return null;
373 }
374
375 @Override
376 public RunResult invoke(Object forkTestSet) {
377 return null;
378 }
379
380 @Override
381 public void cancel() {}
382 }
383 }