1 package org.apache.maven.surefire.its;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.surefire.its.fixture.Settings;
23 import org.apache.maven.surefire.its.fixture.SurefireJUnit4IntegrationTestCase;
24 import org.apache.maven.surefire.its.fixture.SurefireLauncher;
25 import org.junit.Test;
26
27 import static org.apache.maven.surefire.its.fixture.TestFramework.*;
28 import static org.apache.maven.surefire.its.fixture.Configuration.*;
29 import static org.hamcrest.core.AnyOf.anyOf;
30 import static org.hamcrest.core.Is.is;
31 import static org.junit.Assume.assumeThat;
32
33
34
35
36 public abstract class AbstractTestMultipleMethodPatterns
37 extends SurefireJUnit4IntegrationTestCase
38 {
39 private static final String CSV_DELIMITER_SHORT = ",";
40 private static final String CSV_DELIMITER_LONG = ", ";
41 private static final String NOT_DELIMITER = "!";
42
43 protected abstract Settings getSettings();
44
45 protected abstract SurefireLauncher unpack();
46
47 protected SurefireLauncher prepare( String tests )
48 {
49 SurefireLauncher launcher = unpack().addGoal( "-P " + getSettings().profile() );
50 String[] includedExcluded = splitIncludesExcludes( tests );
51 switch ( getSettings().getConfiguration() ) {
52 case TEST:
53 launcher.setTestToRun( tests );
54 break;
55 case INCLUDES:
56 launcher.sysProp( "included", tests );
57 break;
58 case INCLUDES_EXCLUDES:
59 launcher.sysProp( "included", includedExcluded[0] );
60 launcher.sysProp( "excluded", includedExcluded[1] );
61 break;
62 default:
63 throw new IllegalArgumentException( "Unsupported configuration " + getSettings().getConfiguration() );
64 }
65 return launcher;
66 }
67
68 private static String[] splitIncludesExcludes( String patterns )
69 {
70 String included = "";
71 String excluded = "";
72 for ( String pattern : patterns.split( CSV_DELIMITER_SHORT ) )
73 {
74 pattern = pattern.trim();
75 if ( pattern.startsWith( NOT_DELIMITER ) )
76 {
77 excluded += pattern.substring( NOT_DELIMITER.length() ).trim();
78 excluded += CSV_DELIMITER_LONG;
79 }
80 else
81 {
82 included += pattern;
83 included += CSV_DELIMITER_LONG;
84 }
85 }
86 return new String[]{ trimEndComma( included ), trimEndComma( excluded ) };
87 }
88
89 private static String trimEndComma( String pattern )
90 {
91 pattern = pattern.trim();
92 return pattern.endsWith( CSV_DELIMITER_LONG )
93 ? pattern.substring( 0, pattern.length() - CSV_DELIMITER_LONG.length() ) : pattern;
94 }
95
96 @Test
97 public void simpleNameTest()
98 throws Exception
99 {
100 prepare( "TestTwo" )
101 .executeTest()
102 .verifyErrorFree( 2 )
103 .verifyErrorFreeLog()
104 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
105 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
106 }
107
108 @Test
109 public void simpleNameTestAsParallel()
110 throws Exception
111 {
112 assumeThat( getSettings().getFramework(), anyOf( is( JUNIT47 ), is( TestNG ) ) );
113 prepare( "TestTwo" )
114 .parallel( "classes" )
115 .useUnlimitedThreads()
116 .executeTest()
117 .verifyErrorFree( 2 )
118 .verifyErrorFreeLog()
119 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
120 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
121 }
122
123 @Test
124 public void simpleNameTestWithJavaExt()
125 throws Exception
126 {
127 prepare( "TestTwo.java" )
128 .executeTest()
129 .verifyErrorFree( 2 )
130 .verifyErrorFreeLog()
131 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
132 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
133 }
134
135 @Test
136 public void simpleNameTestWithWildcardPkg()
137 throws Exception
138 {
139 prepare( "**/TestTwo" )
140 .executeTest()
141 .verifyErrorFree( 2 )
142 .verifyErrorFreeLog()
143 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
144 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
145 }
146
147 @Test
148 public void simpleNameTestWithJavaExtWildcardPkg()
149 throws Exception
150 {
151 prepare( "**/TestTwo.java" )
152 .executeTest()
153 .verifyErrorFree( 2 )
154 .verifyErrorFreeLog()
155 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
156 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
157 }
158
159 @Test
160 public void fullyQualifiedTest()
161 throws Exception
162 {
163 prepare( "jiras/surefire745/TestTwo.java" )
164 .executeTest()
165 .verifyErrorFree( 2 )
166 .verifyErrorFreeLog()
167 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
168 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
169 }
170
171 @Test
172 public void shouldMatchSimpleClassNameAndMethod()
173 throws Exception
174 {
175 assumeThat( getSettings().getConfiguration(), is( TEST ) );
176 prepare( "BasicTest#testSuccessTwo" )
177 .executeTest()
178 .verifyErrorFree( 1 )
179 .verifyErrorFreeLog()
180 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
181 }
182
183
184
185
186 @Test
187 public void matchSimpleClassAndMethodWithJavaExt()
188 {
189 assumeThat( getSettings().getConfiguration(), is( TEST ) );
190 prepare( "BasicTest.java#testSuccessTwo" )
191 .executeTest()
192 .verifyErrorFree( 1 )
193 .verifyErrorFreeLog()
194 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
195 }
196
197
198
199
200 @Test
201 public void matchSimpleClassAndMethodWithWildcardPkg()
202 {
203 assumeThat( getSettings().getConfiguration(), is( TEST ) );
204 prepare( "**/BasicTest#testSuccessTwo" )
205 .executeTest()
206 .verifyErrorFree( 1 )
207 .verifyErrorFreeLog()
208 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
209 }
210
211
212
213
214 @Test
215 public void matchSimpleClassAndMethodWithJavaExtWildcardPkg()
216 {
217 assumeThat( getSettings().getConfiguration(), is( TEST ) );
218 prepare( "**/BasicTest.java#testSuccessTwo" )
219 .executeTest()
220 .verifyErrorFree( 1 )
221 .verifyErrorFreeLog()
222 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
223 }
224
225 @Test
226 public void shouldMatchWildcardPackageAndClassAndMethod()
227 throws Exception
228 {
229 assumeThat( getSettings().getConfiguration(), is( TEST ) );
230 prepare( "jiras/**/BasicTest#testSuccessTwo" )
231 .executeTest()
232 .verifyErrorFree( 1 )
233 .verifyErrorFreeLog()
234 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
235 }
236
237 @Test
238 public void regexClass()
239 throws Exception
240 {
241 prepare( "%regex[.*.TestTwo.*]" )
242 .executeTest()
243 .verifyErrorFree( 2 )
244 .verifyErrorFreeLog()
245 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
246 .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
247 }
248
249 @Test
250 public void testSuccessTwo()
251 throws Exception
252 {
253 assumeThat( getSettings().getConfiguration(), is( TEST ) );
254 prepare( "#testSuccessTwo" )
255 .maven().debugLogging()
256 .executeTest()
257 .verifyErrorFree( 5 )
258 .verifyErrorFreeLog();
259 }
260
261 @Test
262 public void testRegexSuccessTwo()
263 throws Exception
264 {
265 assumeThat( getSettings().getConfiguration(), is( TEST ) );
266 prepare( "%regex[#testSuccessTwo]" )
267 .executeTest()
268 .verifyErrorFree( 5 )
269 .verifyErrorFreeLog();
270 }
271
272 @Test
273 public void regexClassAndMethod()
274 throws Exception
275 {
276 assumeThat( getSettings().getConfiguration(), is( TEST ) );
277 prepare( "%regex[.*.BasicTest.*#testSuccessTwo]" )
278 .executeTest()
279 .verifyErrorFree( 1 )
280 .verifyErrorFreeLog()
281 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
282 }
283
284 @Test
285 public void shouldMatchExactClassAndMethodWildcard()
286 throws Exception
287 {
288 assumeThat( getSettings().getConfiguration(), is( TEST ) );
289 prepare( "BasicTest#test*One" )
290 .executeTest()
291 .verifyErrorFree( 1 )
292 .verifyErrorFreeLog()
293 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessOne" );
294 }
295
296 @Test
297 public void shouldMatchExactClassAndMethodsWildcard()
298 throws Exception
299 {
300 assumeThat( getSettings().getConfiguration(), is( TEST ) );
301 prepare( "BasicTest#testSuccess*" )
302 .executeTest()
303 .verifyErrorFree( 2 )
304 .verifyErrorFreeLog()
305 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessOne" )
306 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
307 }
308
309 @Test
310 public void shouldMatchExactClassAndMethodCharacters()
311 throws Exception
312 {
313 assumeThat( getSettings().getConfiguration(), is( TEST ) );
314 prepare( "BasicTest#test???????One" )
315 .executeTest()
316 .verifyErrorFree( 1 )
317 .verifyErrorFreeLog()
318 .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessOne" );
319 }
320
321 @Test
322 public void shouldMatchExactClassAndMethodsPostfix()
323 throws Exception
324 {
325 assumeThat( getSettings().getConfiguration(), is( TEST ) );
326 prepare( "TestFive#testSuccess???" )
327 .executeTest()
328 .verifyErrorFree( 2 )
329 .verifyErrorFreeLog()
330 .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessOne" )
331 .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessTwo" );
332 }
333
334 @Test
335 public void shouldMatchExactClassAndMethodPostfix()
336 throws Exception
337 {
338 assumeThat( getSettings().getConfiguration(), is( TEST ) );
339 prepare( "TestFive#testSuccess?????" )
340 .executeTest()
341 .verifyErrorFree( 1 )
342 .verifyErrorFreeLog()
343 .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessThree" );
344 }
345
346 @Test
347 public void shouldMatchExactClassAndMultipleMethods()
348 throws Exception
349 {
350 assumeThat( getSettings().getConfiguration(), is( TEST ) );
351 prepare( "TestFive#testSuccessOne+testSuccessThree" )
352 .executeTest()
353 .verifyErrorFree( 2 )
354 .verifyErrorFreeLog()
355 .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessOne" )
356 .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessThree" );
357 }
358
359 @Test
360 public void shouldMatchMultiplePatterns()
361 throws Exception
362 {
363 assumeThat( getSettings().getConfiguration(), is( TEST ) );
364 String test = "jiras/surefire745/BasicTest#testSuccessOne+testSuccessTwo"
365 + ',' + "jiras/**/TestTwo"
366 + ',' + "jiras/surefire745/TestThree#testSuccess*"
367 + ',' + "TestFour#testSuccess???"
368 + ',' + "jiras/surefire745/*Five#test*One";
369
370 prepare( test )
371 .executeTest()
372 .verifyErrorFree( 9 )
373 .verifyErrorFreeLog();
374 }
375
376 @Test
377 public void shouldMatchMultiplePatternsAsParallel()
378 throws Exception
379 {
380 assumeThat( getSettings().getFramework(), anyOf( is( JUNIT47 ), is( TestNG ) ) );
381 assumeThat( getSettings().getConfiguration(), is( TEST ) );
382 String test = "jiras/surefire745/BasicTest#testSuccessOne+testSuccessTwo"
383 + ',' + "jiras/**/TestTwo"
384 + ',' + "jiras/surefire745/TestThree#testSuccess*"
385 + ',' + "TestFour#testSuccess???"
386 + ',' + "jiras/surefire745/*Five#test*One";
387
388 prepare( test )
389 .parallel( "classes" )
390 .useUnlimitedThreads()
391 .executeTest()
392 .verifyErrorFree( 9 )
393 .verifyErrorFreeLog();
394 }
395
396 @Test
397 public void shouldMatchMultiplePatternsComplex()
398 throws Exception
399 {
400 assumeThat( getSettings().getConfiguration(), is( TEST ) );
401 String test = "**/BasicTest#testSuccessOne+testSuccessTwo"
402 + ',' + "jiras/**/TestTwo"
403 + ',' + "?????/surefire745/TestThree#testSuccess*"
404 + ',' + "jiras/surefire745/TestFour.java#testSuccess???"
405 + ',' + "jiras/surefire745/*Five#test*One";
406
407 prepare( test )
408 .executeTest()
409 .verifyErrorFree( 9 )
410 .verifyErrorFreeLog();
411 }
412
413 @Test
414 public void shouldMatchMultiplePatternsComplexAsParallel()
415 throws Exception
416 {
417 assumeThat( getSettings().getFramework(), anyOf( is( JUNIT47 ), is( TestNG ) ) );
418 assumeThat( getSettings().getConfiguration(), is( TEST ) );
419 String test = "**/BasicTest#testSuccessOne+testSuccessTwo"
420 + ',' + "jiras/**/TestTwo"
421 + ',' + "?????/surefire745/TestThree#testSuccess*"
422 + ',' + "jiras/surefire745/TestFour.java#testSuccess???"
423 + ',' + "jiras/surefire745/*Five#test*One";
424
425 prepare( test )
426 .parallel( "classes" )
427 .useUnlimitedThreads()
428 .executeTest()
429 .verifyErrorFree( 9 )
430 .verifyErrorFreeLog();
431 }
432
433 @Test
434 public void shouldNotRunExcludedClasses()
435 {
436 prepare( "!BasicTest, !**/TestTwo, !**/TestThree.java" )
437 .executeTest()
438 .verifyErrorFree( 6 )
439 .verifyErrorFreeLog();
440 }
441
442 @Test
443 public void shouldNotRunExcludedClassesIfIncluded()
444 {
445 prepare( "TestF*.java, !**/TestFour.java" )
446 .executeTest()
447 .verifyErrorFree( 3 )
448 .verifyErrorFreeLog();
449 }
450
451 @Test
452 public void shouldNotRunExcludedMethods()
453 {
454 assumeThat( getSettings().getConfiguration(), is( TEST ) );
455 prepare( "!#*Fail*, !%regex[#.*One], !#testSuccessThree" )
456 .executeTest()
457 .verifyErrorFree( 5 )
458 .verifyErrorFreeLog();
459 }
460
461 @Test
462 public void shouldNotRunExcludedClassesAndMethods()
463 {
464 assumeThat( getSettings().getConfiguration(), is( TEST ) );
465 prepare( "!#*Fail*, !TestFour#testSuccessTwo" )
466 .executeTest()
467 .verifyErrorFree( 11 )
468 .verifyErrorFreeLog();
469 }
470
471 @Test
472 public void negativeTest()
473 {
474 assumeThat( getSettings().getConfiguration(), anyOf( is( INCLUDES ), is( INCLUDES_EXCLUDES ),
475 is( INCLUDES_FILE ), is( INCLUDES_EXCLUDES_FILE ) ) );
476 String pattern = "TestFive#testSuccessOne+testSuccessThree";
477 prepare( pattern )
478 .failNever()
479 .executeTest()
480 .verifyTextInLog( "Method filter prohibited in includes|excludes|includesFile|excludesFile parameter: "
481 + pattern );
482 }
483 }