View Javadoc
1   package org.apache.maven.surefire.common.junit48;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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              //System.out.println( "FirstClass#testMethod" );
58          }
59  
60          @Test
61          public void secondTestMethod()
62          {
63              //System.out.println( "FirstClass#secondTestMethod" );
64          }
65  
66          @Test
67          public void otherMethod()
68          {
69              //System.out.println( "FirstClass#otherMethod" );
70          }
71      }
72  
73      static public class SecondClass
74      {
75          @Test
76          public void testMethod()
77          {
78              //System.out.println( "SecondClass#testMethod" );
79          }
80  
81          @Test
82          public void secondTestMethod()
83          {
84              //System.out.println( "SecondClass#secondTestMethod" );
85          }
86      }
87  
88      static public class ThirdClass
89      {
90          @Test
91          public void testMethod()
92          {
93              //System.out.println( "ThirdClass#testMethod" );
94          }
95  
96          @Test
97          public void secondTestMethod()
98          {
99              //System.out.println( "ThirdClass#secondTestMethod" );
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             // expected in junit 3.x
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             // expected in junit 3.x
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() );//running the Suite
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         // Running parameterized tests: w12T34, x12T34 and x12T35.
918         // Two parameters "x" and "y" in the test case PT.java change the method descriptions to the following ones:
919         // w12T34[0], w12T34[1]
920         // x12T34[0], x12T34[1]
921         // x12T35[0], x12T35[1]
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 }