1 package org.apache.maven.surefire.common.junit48;
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.shared.utils.io.MatchPatterns;
23 import org.apache.maven.surefire.common.junit48.tests.pt.PT;
24 import org.apache.maven.surefire.testset.ResolvedTest;
25 import org.apache.maven.surefire.testset.TestListResolver;
26 import org.junit.Test;
27 import org.junit.runner.Description;
28 import org.junit.runner.JUnitCore;
29 import org.junit.runner.Request;
30 import org.junit.runner.Result;
31 import org.junit.runner.RunWith;
32 import org.junit.runner.manipulation.Filter;
33
34 import java.io.File;
35 import java.util.Arrays;
36 import java.util.Collection;
37 import java.util.Collections;
38
39 import static org.junit.runner.Description.createSuiteDescription;
40 import static org.junit.runner.Description.createTestDescription;
41 import static org.junit.Assert.*;
42
43 public class FilterFactoryTest
44 {
45 @RunWith( org.junit.runners.Suite.class )
46 @org.junit.runners.Suite.SuiteClasses( { FirstClass.class, SecondClass.class } )
47 static public class Suite
48 {
49
50 }
51
52 static public class FirstClass
53 {
54 @Test
55 public void testMethod()
56 {
57
58 }
59
60 @Test
61 public void secondTestMethod()
62 {
63
64 }
65
66 @Test
67 public void otherMethod()
68 {
69
70 }
71 }
72
73 static public class SecondClass
74 {
75 @Test
76 public void testMethod()
77 {
78
79 }
80
81 @Test
82 public void secondTestMethod()
83 {
84
85 }
86 }
87
88 static public class ThirdClass
89 {
90 @Test
91 public void testMethod()
92 {
93
94 }
95
96 @Test
97 public void secondTestMethod()
98 {
99
100 }
101 }
102
103 private static final Description testMethod = createTestDescription( FirstClass.class, "testMethod" );
104
105 private static final Description secondTestMethod = createTestDescription( FirstClass.class, "secondTestMethod" );
106
107 private static final Description otherMethod = createTestDescription( FirstClass.class, "otherMethod" );
108
109 private static final Description testMethodInSecondClass = createTestDescription( SecondClass.class, "testMethod" );
110
111 private static final Description secondTestMethodInSecondClass =
112 createTestDescription( SecondClass.class, "secondTestMethod" );
113
114 private static final String firstClassName = FirstClass.class.getName().replace( '.', '/' );
115
116 private static final String secondClassName = SecondClass.class.getName().replace( '.', '/' );
117
118 private static final String firstClassRegex = FirstClass.class.getName().replace( "$", "\\$" );
119
120 private static final String secondClassRegex = SecondClass.class.getName().replace( "$", "\\$" );
121
122 private Filter createMethodFilter( String requestString )
123 {
124 return new FilterFactory( getClass().getClassLoader() ).createMethodFilter( requestString );
125 }
126
127 @Test
128 public void testSanity()
129 {
130 ResolvedTest test = new ResolvedTest( ResolvedTest.Type.CLASS, " \t \n ", true );
131 assertNull( test.getTestClassPattern() );
132 assertNull( test.getTestMethodPattern() );
133 assertFalse( test.hasTestClassPattern() );
134 assertFalse( test.hasTestMethodPattern() );
135 assertTrue( test.isEmpty() );
136 assertTrue( test.isRegexTestClassPattern() );
137 assertFalse( test.isRegexTestMethodPattern() );
138 test = new ResolvedTest( ResolvedTest.Type.METHOD, " \n \t ", true );
139 assertNull( test.getTestClassPattern() );
140 assertNull( test.getTestMethodPattern() );
141 assertFalse( test.hasTestClassPattern() );
142 assertFalse( test.hasTestMethodPattern() );
143 assertTrue( test.isEmpty() );
144 assertFalse( test.isRegexTestClassPattern() );
145 assertTrue( test.isRegexTestMethodPattern() );
146 test = new ResolvedTest( ResolvedTest.Type.METHOD, " \n ", false );
147 assertNull( test.getTestClassPattern() );
148 assertNull( test.getTestMethodPattern() );
149 assertFalse( test.hasTestClassPattern() );
150 assertFalse( test.hasTestMethodPattern() );
151 assertTrue( test.isEmpty() );
152 assertFalse( test.isRegexTestClassPattern() );
153 assertFalse( test.isRegexTestMethodPattern() );
154 test = new ResolvedTest( " \n \t ", " \n \t ", false );
155 assertNull( test.getTestClassPattern() );
156 assertNull( test.getTestMethodPattern() );
157 assertFalse( test.hasTestClassPattern() );
158 assertFalse( test.hasTestMethodPattern() );
159 assertTrue( test.isEmpty() );
160 assertFalse( test.isRegexTestClassPattern() );
161 assertFalse( test.isRegexTestMethodPattern() );
162 }
163
164 @Test
165 public void testNegativeIllegalRegex()
166 {
167 try {
168 new TestListResolver( "#%regex[.*.Test.class]" );
169 }
170 catch ( IllegalArgumentException e )
171 {
172
173 }
174 }
175
176 @Test
177 public void testNegativeIllegalRegex2()
178 {
179 try {
180 new TestListResolver( "%regex[.*.Test.class]#" );
181 }
182 catch ( IllegalArgumentException e )
183 {
184
185 }
186 }
187
188 @Test
189 public void testNegativeEmptyRegex()
190 {
191 TestListResolver resolver = new TestListResolver( "%regex[ ]" );
192 assertTrue( resolver.getExcludedPatterns().isEmpty() );
193 assertTrue( resolver.getIncludedPatterns().isEmpty() );
194 assertTrue( resolver.isEmpty() );
195 assertEquals( 0, resolver.getPluginParameterTest().length() );
196 assertFalse( resolver.hasExcludedMethodPatterns() );
197 assertFalse( resolver.hasIncludedMethodPatterns() );
198 assertFalse( resolver.hasMethodPatterns() );
199 }
200
201 @Test
202 public void testNegativeEmptyRegexWithHash()
203 {
204 TestListResolver resolver = new TestListResolver( "%regex[# ]" );
205 assertTrue( resolver.getExcludedPatterns().isEmpty() );
206 assertTrue( resolver.getIncludedPatterns().isEmpty() );
207 assertTrue( resolver.isEmpty() );
208 assertEquals( 0, resolver.getPluginParameterTest().length() );
209 assertFalse( resolver.hasExcludedMethodPatterns() );
210 assertFalse( resolver.hasIncludedMethodPatterns() );
211 assertFalse( resolver.hasMethodPatterns() );
212 }
213
214 @Test
215 public void testNegativeRegexWithEmptyMethod()
216 {
217 TestListResolver resolver = new TestListResolver( "%regex[.*.Test.class# ]" );
218 assertFalse( resolver.isEmpty() );
219 assertTrue( resolver.getExcludedPatterns().isEmpty() );
220 assertFalse( resolver.getIncludedPatterns().isEmpty() );
221 assertEquals( 1, resolver.getIncludedPatterns().size() );
222 assertEquals( "%regex[.*.Test.class]", resolver.getPluginParameterTest() );
223 assertFalse( resolver.hasExcludedMethodPatterns() );
224 assertFalse( resolver.hasIncludedMethodPatterns() );
225 assertFalse( resolver.hasMethodPatterns() );
226 }
227
228 @Test
229 public void testBackwardsCompatibilityNullMethodFilter()
230 {
231 Filter filter = createMethodFilter( null );
232 JUnitCore core = new JUnitCore();
233 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
234 assertTrue( result.wasSuccessful() );
235 assertEquals( 5, result.getRunCount() );
236 assertEquals( 0, result.getFailureCount() );
237 assertEquals( 0, result.getIgnoreCount() );
238 }
239
240 @Test
241 public void testBackwardsCompatibilityEmptyMethodFilter()
242 {
243 Filter filter = createMethodFilter( "" );
244 JUnitCore core = new JUnitCore();
245 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
246 assertTrue( result.wasSuccessful() );
247 assertEquals( 5, result.getRunCount() );
248 assertEquals( 0, result.getFailureCount() );
249 assertEquals( 0, result.getIgnoreCount() );
250 }
251
252 @Test
253 public void testBackwardsCompatibilityBlankMethodFilter()
254 {
255 Filter filter = createMethodFilter( " \n" );
256 JUnitCore core = new JUnitCore();
257 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
258 assertTrue( result.wasSuccessful() );
259 assertEquals( 5, result.getRunCount() );
260 assertEquals( 0, result.getFailureCount() );
261 assertEquals( 0, result.getIgnoreCount() );
262 }
263
264 @Test
265 public void testBackwardsCompatibilityTestParameterClass() {
266 Filter filter = createMethodFilter( firstClassName );
267 JUnitCore core = new JUnitCore();
268 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
269 assertTrue( result.wasSuccessful() );
270 assertEquals( 3, result.getRunCount() );
271 assertEquals( 0, result.getFailureCount() );
272 assertEquals( 0, result.getIgnoreCount() );
273 }
274
275 @Test
276 public void testBackwardsCompatibilityTestParameterJavaClass() {
277 Filter filter = createMethodFilter( firstClassName + ".java" );
278 JUnitCore core = new JUnitCore();
279 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
280 assertTrue( result.wasSuccessful() );
281 assertEquals( 3, result.getRunCount() );
282 assertEquals( 0, result.getFailureCount() );
283 assertEquals( 0, result.getIgnoreCount() );
284 }
285
286 @Test
287 public void testBackwardsCompatibilityTestParameterMethod1() {
288 Filter filter = createMethodFilter( firstClassName + ".java#testMethod" );
289 JUnitCore core = new JUnitCore();
290 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
291 assertTrue( result.wasSuccessful() );
292 assertEquals( 1, result.getRunCount() );
293 assertEquals( 0, result.getFailureCount() );
294 assertEquals( 0, result.getIgnoreCount() );
295 }
296
297 @Test
298 public void testBackwardsCompatibilityTestParameterMethod2() {
299 Filter filter = createMethodFilter( firstClassName + "#testMethod" );
300 JUnitCore core = new JUnitCore();
301 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
302 assertTrue( result.wasSuccessful() );
303 assertEquals( 1, result.getRunCount() );
304 assertEquals( 0, result.getFailureCount() );
305 assertEquals( 0, result.getIgnoreCount() );
306 }
307
308 @Test
309 public void testBackwardsCompatibilityTestParameterMethod3() {
310 Filter filter = createMethodFilter( firstClassName + "#testMethod" );
311 JUnitCore core = new JUnitCore();
312 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
313 assertTrue( result.wasSuccessful() );
314 assertEquals( 1, result.getRunCount() );
315 assertEquals( 0, result.getFailureCount() );
316 assertEquals( 0, result.getIgnoreCount() );
317 }
318
319 @Test
320 public void testRegexWithWildcard() {
321 Filter filter =
322 createMethodFilter( "%regex[" + firstClassRegex + ".*]" );
323 JUnitCore core = new JUnitCore();
324 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
325 assertTrue( result.wasSuccessful() );
326 assertEquals( 3, result.getRunCount() );
327 assertEquals( 0, result.getFailureCount() );
328 assertEquals( 0, result.getIgnoreCount() );
329 }
330
331 @Test
332 public void testRegexWithWildcardClass() {
333 Filter filter =
334 createMethodFilter( "%regex[" + firstClassRegex + ".*.class]" );
335 JUnitCore core = new JUnitCore();
336 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
337 assertTrue( result.wasSuccessful() );
338 assertEquals( 3, result.getRunCount() );
339 assertEquals( 0, result.getFailureCount() );
340 assertEquals( 0, result.getIgnoreCount() );
341 }
342
343 @Test
344 public void testRegexWithExactClass() {
345 Filter filter = createMethodFilter( "%regex[" + firstClassRegex + ".class]" );
346 JUnitCore core = new JUnitCore();
347 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
348 assertTrue( result.wasSuccessful() );
349 assertEquals( 3, result.getRunCount() );
350 assertEquals( 0, result.getFailureCount() );
351 assertEquals( 0, result.getIgnoreCount() );
352 }
353
354 @Test
355 public void testRegexWithWildcardJavaClassNegativeTest() {
356 Filter filter = createMethodFilter( "%regex[" + firstClassRegex + ".*.class]" );
357 JUnitCore core = new JUnitCore();
358 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class ).filterWith( filter ) );
359 assertTrue( result.wasSuccessful() );
360 assertEquals( 3, result.getRunCount() );
361 assertEquals( 0, result.getFailureCount() );
362 assertEquals( 0, result.getIgnoreCount() );
363 }
364
365 @Test
366 public void testRegexWithTwoClasses() {
367 Filter filter = createMethodFilter( "%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".*]" );
368 JUnitCore core = new JUnitCore();
369 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
370 .filterWith( filter ) );
371 assertTrue( result.wasSuccessful() );
372 assertEquals( 5, result.getRunCount() );
373 assertEquals( 0, result.getFailureCount() );
374 assertEquals( 0, result.getIgnoreCount() );
375 }
376
377 @Test
378 public void testRegexWithTwoClassesComplement() {
379 Filter filter = createMethodFilter( "!%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".*]" );
380 JUnitCore core = new JUnitCore();
381 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
382 .filterWith( filter ) );
383 assertTrue( result.wasSuccessful() );
384 assertEquals( 2, result.getRunCount() );
385 assertEquals( 0, result.getFailureCount() );
386 assertEquals( 0, result.getIgnoreCount() );
387 }
388
389 @Test
390 public void testRegexWithTwoClassesAndOneMethod() {
391 Filter filter =
392 createMethodFilter( "%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".* # otherMethod]" );
393 JUnitCore core = new JUnitCore();
394 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
395 .filterWith( filter ) );
396 assertTrue( result.wasSuccessful() );
397 assertEquals( 1, result.getRunCount() );
398 assertEquals( 0, result.getFailureCount() );
399 assertEquals( 0, result.getIgnoreCount() );
400 }
401
402 @Test
403 public void testRegexWithTwoClassesAndOneMethodComplement() {
404 Filter filter =
405 createMethodFilter( "!%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".*# otherMethod]" );
406 JUnitCore core = new JUnitCore();
407 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
408 .filterWith( filter ) );
409 assertTrue( result.wasSuccessful() );
410 assertEquals( 6, result.getRunCount() );
411 assertEquals( 0, result.getFailureCount() );
412 assertEquals( 0, result.getIgnoreCount() );
413 }
414
415 @Test
416 public void testRegexWithTwoClassesAndWildcardMethod() {
417 Filter filter = createMethodFilter( "%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".*#test.* ]" );
418 JUnitCore core = new JUnitCore();
419 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
420 .filterWith( filter ) );
421 assertTrue( result.wasSuccessful() );
422 assertEquals( 2, result.getRunCount() );
423 assertEquals( 0, result.getFailureCount() );
424 assertEquals( 0, result.getIgnoreCount() );
425 }
426
427 @Test
428 public void testRegexWithTwoClassesAndRegexMethodComplement() {
429 Filter filter = createMethodFilter( "!%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".*#test.*]" );
430 JUnitCore core = new JUnitCore();
431 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
432 .filterWith( filter ) );
433 assertTrue( result.wasSuccessful() );
434 assertEquals( 5, result.getRunCount() );
435 assertEquals( 0, result.getFailureCount() );
436 assertEquals( 0, result.getIgnoreCount() );
437 }
438
439 @Test
440 public void testRegexWithTwoClassesAndRegexMethods() {
441 Filter filter =
442 createMethodFilter( "%regex[ " + firstClassRegex + ".*|" + secondClassRegex + ".* # test.*|other.* ]" );
443 JUnitCore core = new JUnitCore();
444 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
445 .filterWith( filter ) );
446 assertTrue( result.wasSuccessful() );
447 assertEquals( 3, result.getRunCount() );
448 assertEquals( 0, result.getFailureCount() );
449 assertEquals( 0, result.getIgnoreCount() );
450 }
451
452 @Test
453 public void testRegexWithTwoClassesAndRegexMethodsComplement() {
454 Filter filter =
455 createMethodFilter( "!%regex[" + firstClassRegex + ".*|" + secondClassRegex + ".* # test.*|other.* ]" );
456 JUnitCore core = new JUnitCore();
457 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
458 .filterWith( filter ) );
459 assertTrue( result.wasSuccessful() );
460 assertEquals( 4, result.getRunCount() );
461 assertEquals( 0, result.getFailureCount() );
462 assertEquals( 0, result.getIgnoreCount() );
463 }
464
465 @Test
466 public void testMultipleRegexClasses() {
467 Filter filter =
468 createMethodFilter( "%regex[" + firstClassRegex + ".*], %regex[" + secondClassRegex + ".*]" );
469 JUnitCore core = new JUnitCore();
470 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
471 .filterWith( filter ) );
472 assertTrue( result.wasSuccessful() );
473 assertEquals( 5, result.getRunCount() );
474 assertEquals( 0, result.getFailureCount() );
475 assertEquals( 0, result.getIgnoreCount() );
476 }
477
478 @Test
479 public void testMultipleRegexClassesComplement() {
480 Filter filter =
481 createMethodFilter( "!%regex[" + firstClassRegex + ".*] , !%regex[" + secondClassRegex + ".*]" );
482 JUnitCore core = new JUnitCore();
483 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
484 .filterWith( filter ) );
485 assertTrue( result.wasSuccessful() );
486 assertEquals( 2, result.getRunCount() );
487 assertEquals( 0, result.getFailureCount() );
488 assertEquals( 0, result.getIgnoreCount() );
489 }
490
491 @Test
492 public void testMultipleClasses() {
493 Filter filter = createMethodFilter( firstClassName + "," + secondClassName );
494 JUnitCore core = new JUnitCore();
495 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
496 .filterWith( filter ) );
497 assertTrue( result.wasSuccessful() );
498 assertEquals( 5, result.getRunCount() );
499 assertEquals( 0, result.getFailureCount() );
500 assertEquals( 0, result.getIgnoreCount() );
501 }
502
503 @Test
504 public void testMultipleClassesMethods() {
505 Filter filter = createMethodFilter( firstClassName + "#other*," + secondClassName + "#*TestMethod" );
506 JUnitCore core = new JUnitCore();
507 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
508 .filterWith( filter ) );
509 assertTrue( result.wasSuccessful() );
510 assertEquals( 2, result.getRunCount() );
511 assertEquals( 0, result.getFailureCount() );
512 assertEquals( 0, result.getIgnoreCount() );
513 }
514
515 @Test
516 public void testMultipleClassesAndMultipleMethodsWithWildcards() {
517 Filter filter = createMethodFilter( firstClassName + "#other*+second*Method,"
518 + secondClassName + "#*TestMethod" );
519 JUnitCore core = new JUnitCore();
520 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
521 .filterWith( filter ) );
522 assertTrue( result.wasSuccessful() );
523 assertEquals( 3, result.getRunCount() );
524 assertEquals( 0, result.getFailureCount() );
525 assertEquals( 0, result.getIgnoreCount() );
526 }
527
528 @Test
529 public void testMultipleClassesAndMultipleMethodsWithRegex() {
530 Filter filter = createMethodFilter( "%regex[" + firstClassRegex + ".class#other.*|second.*Method],"
531 + "%regex[" + secondClassRegex + ".class#.*TestMethod]" );
532 JUnitCore core = new JUnitCore();
533 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
534 .filterWith( filter ) );
535 assertTrue( result.wasSuccessful() );
536 assertEquals( 3, result.getRunCount() );
537 assertEquals( 0, result.getFailureCount() );
538 assertEquals( 0, result.getIgnoreCount() );
539 }
540
541 @Test
542 public void testMultipleClassesAndMultipleMethodsMix() {
543 Filter filter = createMethodFilter( "%regex[" + firstClassRegex + ".class # other.*|second.*Method],"
544 + secondClassName + "#*TestMethod" );
545 JUnitCore core = new JUnitCore();
546 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
547 .filterWith( filter ) );
548 assertTrue( result.wasSuccessful() );
549 assertEquals( 3, result.getRunCount() );
550 assertEquals( 0, result.getFailureCount() );
551 assertEquals( 0, result.getIgnoreCount() );
552 }
553
554 @Test
555 public void testMultipleClassesAndMultipleMethods() {
556 Filter filter = createMethodFilter( firstClassName + "#other*+secondTestMethod,"
557 + secondClassName + "#*TestMethod" );
558 JUnitCore core = new JUnitCore();
559 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
560 .filterWith( filter ) );
561 assertTrue( result.wasSuccessful() );
562 assertEquals( 3, result.getRunCount() );
563 assertEquals( 0, result.getFailureCount() );
564 assertEquals( 0, result.getIgnoreCount() );
565 }
566
567 @Test
568 public void testMultipleClassesComplement() {
569 Filter filter = createMethodFilter( "!" + firstClassName + ",!" + secondClassName );
570 JUnitCore core = new JUnitCore();
571 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
572 .filterWith( filter ) );
573 assertTrue( result.wasSuccessful() );
574 assertEquals( 2, result.getRunCount() );
575 assertEquals( 0, result.getFailureCount() );
576 assertEquals( 0, result.getIgnoreCount() );
577 }
578
579 @Test
580 public void testMultipleRegexClassesMethods() {
581 Filter filter =
582 createMethodFilter( "%regex[" + firstClassRegex + ".* # test.*|other.*],"
583 + "%regex[" + secondClassRegex + ".*#second.*]" );
584 JUnitCore core = new JUnitCore();
585 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
586 .filterWith( filter ) );
587 assertTrue( result.wasSuccessful() );
588 assertEquals( 3, result.getRunCount() );
589 assertEquals( 0, result.getFailureCount() );
590 assertEquals( 0, result.getIgnoreCount() );
591 }
592
593 @Test
594 public void testMultipleRegexClassesMethodsComplement() {
595 Filter filter =
596 createMethodFilter( "!%regex[" + firstClassRegex + ".* # test.*|other.*],"
597 + "!%regex[" + secondClassRegex + ".*#second.*]" );
598 JUnitCore core = new JUnitCore();
599 Result result = core.run( Request.classes( FirstClass.class, SecondClass.class, ThirdClass.class )
600 .filterWith( filter ) );
601 assertTrue( result.wasSuccessful() );
602 assertEquals( 4, result.getRunCount() );
603 assertEquals( 0, result.getFailureCount() );
604 assertEquals( 0, result.getIgnoreCount() );
605 }
606
607 @Test
608 public void testShouldMatchExactMethodName()
609 {
610 Filter exactFilter = createMethodFilter( "#testMethod" );
611 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
612 }
613
614 @Test
615 public void testShouldMatchExactMethodNameComplement()
616 {
617 Filter exactFilter = createMethodFilter( "!#testMethod" );
618 assertFalse( "should not run testMethod", exactFilter.shouldRun( testMethod ) );
619 assertTrue( "should run other than testMethod", exactFilter.shouldRun( secondTestMethod ) );
620 assertFalse( "should not run testMethod", exactFilter.shouldRun( testMethodInSecondClass ) );
621 assertTrue( "should run other than testMethod", exactFilter.shouldRun( secondTestMethodInSecondClass ) );
622
623 exactFilter = createMethodFilter( "!FilterFactoryTest$FirstClass#testMethod" );
624 assertFalse( "should not run testMethod", exactFilter.shouldRun( testMethod ) );
625 assertTrue( "should run other than testMethod", exactFilter.shouldRun( secondTestMethod ) );
626 assertTrue( "should not run testMethod", exactFilter.shouldRun( testMethodInSecondClass ) );
627 assertTrue( "should run other than testMethod", exactFilter.shouldRun( secondTestMethodInSecondClass ) );
628
629 exactFilter =
630 createMethodFilter( "!FilterFactoryTest$FirstClass#testMethod, !FilterFactoryTest$SecondClass#testMethod" );
631 assertFalse( "should not run testMethod", exactFilter.shouldRun( testMethod ) );
632 assertTrue( "should run other than testMethod", exactFilter.shouldRun( secondTestMethod ) );
633 assertFalse( "should not run testMethod", exactFilter.shouldRun( testMethodInSecondClass ) );
634 assertTrue( "should run other than testMethod", exactFilter.shouldRun( secondTestMethodInSecondClass ) );
635 }
636
637 @Test
638 public void testShouldMatchExactMethodNameWithHash()
639 {
640 final Filter exactFilter = createMethodFilter( "#testMethod" );
641 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
642 }
643
644 @Test
645 public void testShouldRunSuiteWithIncludedMethod()
646 {
647 String sourceFile = "pkg" + File.separator + "XMyTest.class";
648 assertTrue( new TestListResolver( "#testMethod" ).shouldRun( sourceFile, null ) );
649 }
650
651 @Test
652 public void testShouldNotRunDifferentMethods()
653 {
654 final Filter exactFilter = createMethodFilter( "#testMethod" );
655 Description testCase = createSuiteDescription( FirstClass.class );
656 testCase.addChild( otherMethod );
657 assertFalse( "exact match test case", exactFilter.shouldRun( testCase ) );
658 }
659
660 @Test
661 public void testShouldNotRunExactMethodWithoutClass()
662 {
663 Filter exactFilter = createMethodFilter( "#testMethod" );
664 assertFalse( "should run containing matching method", exactFilter.shouldRun( secondTestMethod ) );
665 }
666
667 @Test
668 public void testShouldNotMatchExactOnOtherMethod()
669 {
670 Filter exactFilter = createMethodFilter( "#testMethod" );
671 assertFalse( "should not run other methods", exactFilter.shouldRun( otherMethod ) );
672 }
673
674 @Test
675 public void testShouldMatchWildCardsInMethodName()
676 {
677 Filter starAtEnd = createMethodFilter( "#test*" );
678 assertTrue( "match ending with star should run", starAtEnd.shouldRun( testMethod ) );
679
680 Filter starAtBeginning = createMethodFilter( "#*Method" );
681 assertTrue( "match starting with star should run", starAtBeginning.shouldRun( testMethod ) );
682
683 Filter starInMiddle = createMethodFilter( "#test*thod" );
684 assertTrue( "match containing star should run", starInMiddle.shouldRun( testMethod ) );
685
686 Filter questionAtEnd = createMethodFilter( "#testMetho?" );
687 assertTrue( "match ending with question mark should run", questionAtEnd.shouldRun( testMethod ) );
688
689 Filter questionAtBeginning = createMethodFilter( "#????Method" );
690 assertTrue( "match starting with question mark should run", questionAtBeginning.shouldRun( testMethod ) );
691
692 Filter questionInMiddle = createMethodFilter( "#testM?thod" );
693 assertTrue( "match containing question mark should run", questionInMiddle.shouldRun( testMethod ) );
694
695 Filter starAndQuestion = createMethodFilter( "#t?st*thod" );
696 assertTrue( "match containing star and question mark should run", starAndQuestion.shouldRun( testMethod ) );
697 }
698
699 @Test
700 public void testShouldMatchExactClassAndMethod()
701 {
702 Filter exactFilter = createMethodFilter( firstClassName + "#testMethod" );
703 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
704 }
705
706 @Test
707 public void testShouldMatchSimpleClassNameWithMethod()
708 {
709 Filter exactFilter = createMethodFilter( "FilterFactoryTest$FirstClass#testMethod" );
710 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
711 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
712 }
713
714 @Test
715 public void testShouldMatchNestedClassAsRegexWithMethod()
716 {
717 Filter exactFilter =
718 createMethodFilter( "%regex[.*.common.junit48.FilterFactoryTest\\$FirstClass.class#testMethod]" );
719 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
720 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
721 }
722
723 @Test
724 public void testShouldMatchNestedCanonicalClassAsRegexWithMethod()
725 {
726 Filter exactFilter =
727 createMethodFilter( "%regex[.*.common.junit48.FilterFactoryTest.FirstClass.class#testMethod]" );
728 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
729 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
730 }
731
732 @Test
733 public void testShouldMatchClassNameWithWildcardAndMethod()
734 {
735 Filter exactFilter = createMethodFilter( "*First*#testMethod" );
736 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
737 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
738 }
739
740 @Test
741 public void testShouldMatchClassNameWithWildcardCompletely()
742 {
743 Filter exactFilter = createMethodFilter( "First*#testMethod" );
744 assertFalse( "other method should not match", exactFilter.shouldRun( testMethod ) );
745 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
746 }
747
748 @Test
749 public void testShouldMatchMultipleMethodsSeparatedByComma()
750 {
751 Filter exactFilter = createMethodFilter( firstClassName + "#testMethod,#secondTestMethod" );
752
753 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
754 assertTrue( "exact match on name should run", exactFilter.shouldRun( secondTestMethod ) );
755 assertTrue( "exact match on name should run", exactFilter.shouldRun( secondTestMethodInSecondClass ) );
756
757 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
758 }
759
760 @Test
761 public void testShouldMatchMultipleMethodsInSameClassSeparatedByPlus()
762 {
763 Filter exactFilter = createMethodFilter( firstClassName + "#testMethod+secondTestMethod" );
764
765 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
766 assertTrue( "exact match on name should run", exactFilter.shouldRun( secondTestMethod ) );
767
768 assertFalse( "method in another class should not match",
769 exactFilter.shouldRun( secondTestMethodInSecondClass ) );
770
771 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
772 }
773
774 @Test
775 public void testShouldRunCompleteClassWhenSeparatedByCommaWithoutHash()
776 {
777 Filter exactFilter = createMethodFilter( firstClassName + "#testMethod," + secondClassName );
778
779 assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod ) );
780
781 assertFalse( "other method should not match", exactFilter.shouldRun( secondTestMethod ) );
782 assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod ) );
783
784 assertTrue( "should run complete second class", exactFilter.shouldRun( testMethodInSecondClass ) );
785 assertTrue( "should run complete second class", exactFilter.shouldRun( secondTestMethodInSecondClass ) );
786 }
787
788 @Test
789 public void testShouldRunSuitesContainingExactMethodName()
790 {
791 Description suite = Description.createSuiteDescription( Suite.class );
792 suite.addChild( testMethod );
793 suite.addChild( secondTestMethod );
794
795 Filter exactFilter = createMethodFilter( "#testMethod" );
796 assertTrue( "should run suites containing matching method", exactFilter.shouldRun( suite ) );
797 }
798
799 @Test
800 public void testShouldSkipSuitesNotContainingExactMethodName()
801 {
802 Filter exactFilter = createMethodFilter( "#otherMethod" );
803 assertFalse( "should not run method", exactFilter.shouldRun( testMethod ) );
804 assertFalse( "should not run method", exactFilter.shouldRun( secondTestMethod ) );
805 Description suite = Description.createSuiteDescription( Suite.class );
806 suite.addChild( testMethod );
807 suite.addChild( secondTestMethod );
808 assertFalse( "should not run suites containing no matches", exactFilter.shouldRun( suite ) );
809 }
810
811 @Test
812 public void testSingleMethodWithJUnitCoreSuite()
813 {
814 Filter filter = createMethodFilter( "#testMethod" );
815 JUnitCore core = new JUnitCore();
816 Result result = core.run( Request.classes( Suite.class ).filterWith( filter ) );
817 assertTrue( result.wasSuccessful() );
818 assertEquals( 2, result.getRunCount() );
819 assertEquals( 0, result.getFailureCount() );
820 assertEquals( 0, result.getIgnoreCount() );
821 }
822
823 @Test
824 public void testShouldNotRunNonExistingMethodJUnitCoreSuite()
825 {
826 Filter filter = createMethodFilter( "#nonExisting" );
827 JUnitCore core = new JUnitCore();
828 Result result = core.run( Request.classes( Suite.class ).filterWith( filter ) );
829 assertTrue( result.wasSuccessful() );
830 assertEquals( 0, result.getRunCount() );
831 assertEquals( 0, result.getFailureCount() );
832 assertEquals( 0, result.getIgnoreCount() );
833 }
834
835 @Test
836 public void testShouldRunNonExistingMethodJUnitCoreSuite()
837 {
838 Filter filter = createMethodFilter( "!#nonExisting" );
839 JUnitCore core = new JUnitCore();
840 Result result = core.run( Request.classes( Suite.class ).filterWith( filter ) );
841 assertTrue( result.wasSuccessful() );
842 assertEquals( 5, result.getRunCount() );
843 assertEquals( 0, result.getFailureCount() );
844 assertEquals( 0, result.getIgnoreCount() );
845 }
846
847 @Test
848 public void testClassAndMethodJUnitCoreSuite()
849 {
850 Filter filter = createMethodFilter( "FilterFactoryTest$FirstClass#testMethod" );
851 JUnitCore core = new JUnitCore();
852 Result result = core.run( Request.classes( Suite.class, FirstClass.class, SecondClass.class )
853 .filterWith( filter ) );
854 assertTrue( result.wasSuccessful() );
855 assertEquals( 2, result.getRunCount() );
856 assertEquals( 0, result.getFailureCount() );
857 assertEquals( 0, result.getIgnoreCount() );
858 }
859
860 @Test
861 public void testSingleMethodWithJUnitCoreFirstClass()
862 {
863 Filter filter = createMethodFilter( "#testMethod" );
864 JUnitCore core = new JUnitCore();
865 Result result = core.run( Request.classes( FirstClass.class ).filterWith( filter ) );
866 assertTrue( result.wasSuccessful() );
867 assertEquals( 1, result.getRunCount() );
868 assertEquals( 0, result.getFailureCount() );
869 assertEquals( 0, result.getIgnoreCount() );
870 }
871
872 @Test
873 public void testWithJUnitCoreFirstClassAndSingleMethod()
874 {
875 Filter filter = createMethodFilter( "FilterFactoryTest$FirstClass#testMethod" );
876 JUnitCore core = new JUnitCore();
877 Result result = core.run( Request.classes( FirstClass.class ).filterWith( filter ) );
878 assertTrue( result.wasSuccessful() );
879 assertEquals( 1, result.getRunCount() );
880 assertEquals( 0, result.getFailureCount() );
881 assertEquals( 0, result.getIgnoreCount() );
882 }
883
884 @Test
885 public void testShouldRunSuite()
886 {
887 TestListResolver filter = new TestListResolver( "Su?te" );
888 filter = TestListResolver.optionallyWildcardFilter( filter );
889 JUnitCore core = new JUnitCore();
890 Result result = core.run( Request.classes( Suite.class ).filterWith( new MethodFilter( filter ) ) );
891 assertTrue( result.wasSuccessful() );
892 assertEquals( 5, result.getRunCount() );
893 assertEquals( 0, result.getFailureCount() );
894 assertEquals( 0, result.getIgnoreCount() );
895 }
896
897 @Test
898 public void testShouldRunParameterized()
899 {
900 TestListResolver filter =
901 new TestListResolver( "#testAA[?]+testB?[?], "
902 + "PT#testC*, "
903 + "!PT.java#testCY[?],"
904 + "%regex[.*.tests.pt.PT.class#w.*|x.*T.*]" );
905 filter = TestListResolver.optionallyWildcardFilter( filter );
906 JUnitCore core = new JUnitCore();
907 Result result = core.run( Request.classes( PT.class ).filterWith( new MethodFilter( filter ) ) );
908 assertTrue( result.wasSuccessful() );
909 assertEquals( 12, result.getRunCount() );
910 assertEquals( 0, result.getFailureCount() );
911 assertEquals( 0, result.getIgnoreCount() );
912 }
913
914 @Test
915 public void testShouldRunParameterizedWithPlusDelimiter()
916 {
917
918
919
920
921
922 TestListResolver filter =
923 new TestListResolver( "%regex[.*.PT.* # w.*|x(\\d+)T(\\d+)\\[(\\d+)\\]]" );
924 filter = TestListResolver.optionallyWildcardFilter( filter );
925 JUnitCore core = new JUnitCore();
926 Result result = core.run( Request.classes( PT.class ).filterWith( new MethodFilter( filter ) ) );
927 assertTrue( result.wasSuccessful() );
928 assertEquals( 6, result.getRunCount() );
929 assertEquals( 0, result.getFailureCount() );
930 assertEquals( 0, result.getIgnoreCount() );
931 }
932
933 @Test
934 public void testTestListResolver()
935 {
936 assertFalse( new TestListResolver( "b/ATest.java" ).shouldRun( "tests/a/ATest.class", null ) );
937 assertFalse( new TestListResolver( "b/Test.java" ).shouldRun( "a/ATest.class", null ) );
938 assertTrue( new TestListResolver( "ATest.java" ).shouldRun( "tests/a/ATest.class", null ) );
939 assertTrue( new TestListResolver( "a/ATest.java" ).shouldRun( "a/ATest.class", null ) );
940 assertTrue( new TestListResolver( "**/ATest.java" ).shouldRun( "a/ATest.class", null ) );
941 Class<?> testsATest = org.apache.maven.surefire.common.junit48.tests.ATest.class;
942 Class<?> aTest = org.apache.maven.surefire.common.junit48.tests.a.ATest.class;
943 assertFalse( new TestListResolver( "b/ATest.java" ).shouldRun( testsATest, null ) );
944 assertFalse( new TestListResolver( "b/ATest.java" ).shouldRun( aTest, null ) );
945 assertTrue( new TestListResolver( "ATest.java" ).shouldRun( testsATest, null ) );
946 assertTrue( new TestListResolver( "a/ATest.java" ).shouldRun( aTest, null ) );
947 assertTrue( new TestListResolver( "**/ATest.java" ).shouldRun( aTest, null ) );
948 }
949
950 @Test
951 public void testShouldRunClassOnly()
952 {
953 Class<?> testsATest = org.apache.maven.surefire.common.junit48.tests.ATest.class;
954 TestListResolver resolver = new TestListResolver( "**/ATest.java#testSuccessTwo" );
955 assertTrue( resolver.shouldRun( testsATest, null ) );
956 resolver = new TestListResolver( "**/BTest.java#testSuccessTwo" );
957 assertFalse( resolver.shouldRun( testsATest, null ) );
958 }
959
960 @Test
961 public void testMatchPatterns()
962 {
963 String sourceFile = "pkg" + File.separator + "MyTest.class";
964 boolean matchPattern =
965 MatchPatterns.from( "**" + File.separator + "MyTest.class" ).matches( sourceFile, true );
966 assertTrue( matchPattern );
967
968 matchPattern = MatchPatterns.from( "MyTest.class" ).matches( sourceFile, true );
969 assertFalse( matchPattern );
970
971 matchPattern = MatchPatterns.from( "MyTest.class" ).matches( "MyTest.class", true );
972 assertTrue( matchPattern );
973
974 matchPattern = MatchPatterns.from( "**" + File.separator + "MyTest.class" ).matches( "MyTest.class", true );
975 assertTrue( matchPattern );
976 }
977
978 @Test
979 public void testNegativePatternOnPackageLessClass()
980 {
981 String sourceFile = "pkg" + File.separator + "XMyTest.class";
982 assertFalse( new TestListResolver( "**/MyTest.java" ).shouldRun( sourceFile, null ) );
983 assertFalse( new TestListResolver( "MyTest.java" ).shouldRun( sourceFile, null ) );
984 assertFalse( new TestListResolver( "MyTest.java" ).shouldRun( "XMyTest.class", null ) );
985 assertFalse( new TestListResolver( "**/MyTest.java" ).shouldRun( "XMyTest.class", null ) );
986 }
987
988 @Test
989 public void testPatternOnPackageLessClass()
990 {
991 String sourceFile = "pkg" + File.separator + "MyTest.class";
992 assertTrue( new TestListResolver( "**/MyTest.java" ).shouldRun( sourceFile, null ) );
993 assertTrue( new TestListResolver( "MyTest.java" ).shouldRun( sourceFile, null ) );
994 assertTrue( new TestListResolver( "MyTest.java" ).shouldRun( "MyTest.class", null ) );
995 assertTrue( new TestListResolver( "**/MyTest.java" ).shouldRun( "MyTest.class", null ) );
996 }
997
998 @Test
999 public void testIncludesExcludes()
1000 {
1001 Collection<String> inc = Arrays.asList( "**/NotIncludedByDefault.java", "**/*Test.java" );
1002 Collection<String> exc = Collections.singletonList( "**/DontRunTest.*" );
1003 TestListResolver resolver = new TestListResolver( inc, exc );
1004 assertFalse( resolver.shouldRun( "org/test/DontRunTest.class", null ) );
1005 assertTrue( resolver.shouldRun( "org/test/DefaultTest.class", null ) );
1006 assertTrue( resolver.shouldRun( "org/test/NotIncludedByDefault.class", null ) );
1007 }
1008
1009 @Test
1010 public void testSimple()
1011 {
1012 TestListResolver resolver = new TestListResolver( "NotIncludedByDefault" );
1013 assertTrue( resolver.shouldRun( "org/test/NotIncludedByDefault.class", null ) );
1014 }
1015
1016 @Test
1017 public void testFullyQualifiedClass()
1018 {
1019 TestListResolver resolver = new TestListResolver( "my.package.MyTest" );
1020 assertFalse( resolver.shouldRun( "my/package/AnotherTest.class", null ) );
1021 assertTrue( resolver.shouldRun( "my/package/MyTest.class", null ) );
1022 }
1023 }