1 package org.apache.maven.surefire.testset;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 import junit.framework.TestCase;
22
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.Collections;
26 import java.util.HashSet;
27 import java.util.Iterator;
28 import java.util.LinkedHashSet;
29 import java.util.Set;
30
31 import static java.util.Collections.addAll;
32 import static org.apache.maven.surefire.testset.TestListResolver.newTestListResolver;
33 import static org.apache.maven.surefire.testset.ResolvedTest.Type.CLASS;
34 import static java.util.Arrays.asList;
35 import static java.util.Collections.emptySet;
36 import static java.util.Collections.singleton;
37 import static org.hamcrest.MatcherAssert.assertThat;
38 import static org.hamcrest.Matchers.*;
39
40 public class TestListResolverTest
41 extends TestCase
42 {
43 private static final String DEFAULT_SUREFIRE_INCLUDED_TEST_PATTERNS =
44 "**/Test*.java, **/*Test.java, **/*TestCase.java";
45
46 private static final String DEFAULT_SUREFIRE_EXCLUDED_TEST_PATTERNS = "**/*$*";
47
48 public void testRegexSanity1()
49 {
50 try
51 {
52 TestListResolver.isRegexPrefixedPattern( "#%regex[]" );
53 fail( "#%regex[]" );
54 }
55 catch ( IllegalArgumentException e )
56 {
57
58 }
59 }
60
61 public void testRegexSanity2()
62 {
63 try
64 {
65 TestListResolver.isRegexPrefixedPattern( "%regex[]#" );
66 fail( "%regex[]#" );
67 }
68 catch ( IllegalArgumentException e )
69 {
70
71 }
72 }
73
74 public void testRegexSanity3()
75 {
76 try
77 {
78 TestListResolver.isRegexPrefixedPattern( "%regex[]%regex[]" );
79 fail( "%regex[]%regex[]" );
80 }
81 catch ( IllegalArgumentException e )
82 {
83
84 }
85 }
86
87 public void testMinRegexLength()
88 {
89 assertFalse( TestListResolver.isRegexMinLength( "%regex[]" ) );
90 assertFalse( TestListResolver.isRegexMinLength( "%regex[ ]" ) );
91 assertTrue( TestListResolver.isRegexMinLength( "%regex[*Test]" ) );
92 }
93
94 public void testRemoveExclamationMark()
95 {
96 String pattern = TestListResolver.removeExclamationMark( "!%regex[]" );
97 assertEquals( "%regex[]", pattern );
98 pattern = TestListResolver.removeExclamationMark( "%regex[]" );
99 assertEquals( "%regex[]", pattern );
100 }
101
102 public void testUnwrapped()
103 {
104 String[] classAndMethod = TestListResolver.unwrap( " MyTest " );
105 assertEquals( "MyTest", classAndMethod[0] );
106 assertEquals( "", classAndMethod[1] );
107 classAndMethod = TestListResolver.unwrap( " # test " );
108 assertEquals( "", classAndMethod[0] );
109 assertEquals( "test", classAndMethod[1] );
110 classAndMethod = TestListResolver.unwrap( " MyTest # test " );
111 assertEquals( "MyTest", classAndMethod[0] );
112 assertEquals( "test", classAndMethod[1] );
113 }
114
115 public void testUnwrappedRegex()
116 {
117 String[] classAndMethod = TestListResolver.unwrapRegex( "%regex[ .*.MyTest.class ]" );
118 assertEquals( ".*.MyTest.class", classAndMethod[0] );
119 assertEquals( "", classAndMethod[1] );
120 classAndMethod = TestListResolver.unwrapRegex( "%regex[ # myMethod|secondTest ]" );
121 assertEquals( "", classAndMethod[0] );
122 assertEquals( "myMethod|secondTest", classAndMethod[1] );
123 classAndMethod = TestListResolver.unwrapRegex( "%regex[ .*.MyTest.class # myMethod|secondTest ]" );
124 assertEquals( ".*.MyTest.class", classAndMethod[0] );
125 assertEquals( "myMethod|secondTest", classAndMethod[1] );
126 }
127
128 public void testMakeRegex()
129 {
130 String regex = ResolvedTest.wrapRegex( ".*.MyTest.class" );
131 assertEquals( "%regex[.*.MyTest.class]", regex );
132 }
133
134 public void testNonRegexClassAndMethod()
135 {
136 Collection<ResolvedTest> includedFilters = new ArrayList<ResolvedTest>();
137 Collection<ResolvedTest> excludedFilters = new ArrayList<ResolvedTest>();
138 IncludedExcludedPatterns includedExcludedPatterns = new IncludedExcludedPatterns();
139 TestListResolver.nonRegexClassAndMethods( "MyTest", "myTest", false, includedExcludedPatterns, includedFilters,
140 excludedFilters );
141 assertTrue( includedExcludedPatterns.hasIncludedMethodPatterns );
142 assertFalse( includedExcludedPatterns.hasExcludedMethodPatterns );
143 assertFalse( includedFilters.isEmpty() );
144 assertTrue( excludedFilters.isEmpty() );
145 assertEquals( 1, includedFilters.size() );
146 ResolvedTest test = includedFilters.iterator().next();
147 assertFalse( test.isEmpty() );
148 assertFalse( test.isRegexTestClassPattern() );
149 assertFalse( test.isRegexTestMethodPattern() );
150 assertTrue( test.hasTestClassPattern() );
151 assertTrue( test.hasTestMethodPattern() );
152 assertEquals( "**/MyTest", test.getTestClassPattern() );
153 assertEquals( "myTest", test.getTestMethodPattern() );
154 assertTrue( test.matchAsInclusive( "MyTest", "myTest" ) );
155 assertFalse( test.matchAsInclusive( "MyTest", "otherTest" ) );
156 }
157
158 public void testNonRegexClassAndMethods()
159 {
160 Collection<ResolvedTest> includedFilters = new ArrayList<ResolvedTest>();
161 Collection<ResolvedTest> excludedFilters = new ArrayList<ResolvedTest>();
162 IncludedExcludedPatterns includedExcludedPatterns = new IncludedExcludedPatterns();
163 TestListResolver.nonRegexClassAndMethods( "MyTest.class", "first*+second*", false, includedExcludedPatterns,
164 includedFilters, excludedFilters );
165 assertTrue( includedExcludedPatterns.hasIncludedMethodPatterns );
166 assertFalse( includedExcludedPatterns.hasExcludedMethodPatterns );
167 assertFalse( includedFilters.isEmpty() );
168 assertTrue( excludedFilters.isEmpty() );
169 assertEquals( 2, includedFilters.size() );
170 Iterator<ResolvedTest> tests = includedFilters.iterator();
171 ResolvedTest first = tests.next();
172 assertFalse( first.isEmpty() );
173 assertFalse( first.isRegexTestClassPattern() );
174 assertFalse( first.isRegexTestMethodPattern() );
175 assertTrue( first.hasTestClassPattern() );
176 assertTrue( first.hasTestMethodPattern() );
177 assertEquals( "**/MyTest.class", first.getTestClassPattern() );
178 assertEquals( "first*", first.getTestMethodPattern() );
179 assertTrue( first.matchAsInclusive( "your/pkg/MyTest.class", "firstTest" ) );
180 ResolvedTest second = tests.next();
181 assertFalse( second.isEmpty() );
182 assertFalse( second.isRegexTestClassPattern() );
183 assertFalse( second.isRegexTestMethodPattern() );
184 assertTrue( second.hasTestClassPattern() );
185 assertTrue( second.hasTestMethodPattern() );
186 assertEquals( "**/MyTest.class", second.getTestClassPattern() );
187 assertEquals( "second*", second.getTestMethodPattern() );
188 assertTrue( second.matchAsInclusive( "your/pkg/MyTest.class", "secondTest" ) );
189 assertFalse( second.matchAsInclusive( "your/pkg/MyTest.class", "thirdTest" ) );
190 }
191
192 public void testNegativeNonRegexClassAndMethod()
193 {
194 Collection<ResolvedTest> includedFilters = new ArrayList<ResolvedTest>();
195 Collection<ResolvedTest> excludedFilters = new ArrayList<ResolvedTest>();
196 IncludedExcludedPatterns includedExcludedPatterns = new IncludedExcludedPatterns();
197 TestListResolver.nonRegexClassAndMethods( "MyTest", "myTest", true, includedExcludedPatterns, includedFilters,
198 excludedFilters );
199 assertFalse( includedExcludedPatterns.hasIncludedMethodPatterns );
200 assertTrue( includedExcludedPatterns.hasExcludedMethodPatterns );
201 assertTrue( includedFilters.isEmpty() );
202 assertEquals( 1, excludedFilters.size() );
203 ResolvedTest test = excludedFilters.iterator().next();
204 assertFalse( test.isEmpty() );
205 assertFalse( test.isRegexTestClassPattern() );
206 assertFalse( test.isRegexTestMethodPattern() );
207 assertTrue( test.hasTestClassPattern() );
208 assertTrue( test.hasTestMethodPattern() );
209 assertEquals( "**/MyTest", test.getTestClassPattern() );
210 assertEquals( "myTest", test.getTestMethodPattern() );
211
212 assertTrue( test.matchAsInclusive( "MyTest", "myTest" ) );
213 assertFalse( test.matchAsInclusive( "MyTest", "otherTest" ) );
214 assertFalse( test.matchAsInclusive( "pkg/OtherTest.class", "myTest" ) );
215 }
216
217 public void testResolveTestRequest()
218 {
219 Collection<ResolvedTest> includedFilters = new ArrayList<ResolvedTest>();
220 Collection<ResolvedTest> excludedFilters = new ArrayList<ResolvedTest>();
221 IncludedExcludedPatterns includedExcludedPatterns = new IncludedExcludedPatterns();
222 TestListResolver.resolveTestRequest( "!%regex[.*.MyTest.class#myTest]", includedExcludedPatterns,
223 includedFilters, excludedFilters );
224 assertFalse( includedExcludedPatterns.hasIncludedMethodPatterns );
225 assertTrue( includedExcludedPatterns.hasExcludedMethodPatterns );
226 assertTrue( includedFilters.isEmpty() );
227 assertFalse( excludedFilters.isEmpty() );
228 assertEquals( 1, excludedFilters.size() );
229 ResolvedTest test = excludedFilters.iterator().next();
230
231 assertTrue( test.matchAsInclusive( "pkg/MyTest.class", "myTest" ) );
232 assertFalse( test.matchAsInclusive( "pkg/MyTest.class", "otherTest" ) );
233 assertFalse( test.matchAsInclusive( "pkg/OtherTest.class", "myTest" ) );
234 }
235
236 public void testShouldRunTestWithoutMethod()
237 {
238 new TestListResolver("**/*Test.class, !%regex[.*.MyTest.class#myTest]").shouldRun( "pkg/MyTest.class", null );
239 }
240
241 public void testShouldNotRunExcludedMethods()
242 {
243 TestListResolver resolver = new TestListResolver( "!#*Fail*, !%regex[#.*One], !#testSuccessThree" );
244 assertTrue( resolver.shouldRun( "pkg/MyTest.class", null ) );
245 }
246
247 public void testShouldRunSuiteWithIncludedMethods()
248 {
249 TestListResolver resolver = new TestListResolver( "#*Fail*, %regex[#.*One], #testSuccessThree" );
250 assertTrue( resolver.shouldRun( "pkg/MyTest.class", null ) );
251 }
252
253 public void testShouldRunAny()
254 {
255 TestListResolver resolver = TestListResolver.getEmptyTestListResolver();
256 assertTrue( resolver.shouldRun( "pkg/MyTest.class", null ) );
257
258 resolver = new TestListResolver( Collections.<String>emptySet() );
259 assertTrue( resolver.shouldRun( "pkg/MyTest.class", null ) );
260 }
261
262 public void testClassFilter()
263 {
264 TestListResolver resolver = new TestListResolver( "#test" );
265 assertTrue( resolver.shouldRun( "pkg/MyTest.class", null ) );
266
267 resolver = new TestListResolver( "!#test" );
268 assertTrue( resolver.shouldRun( "pkg/MyTest.class", null ) );
269
270 resolver = new TestListResolver( "SomeOtherClass" );
271 assertFalse( resolver.shouldRun( "pkg/MyTest.class", null ) );
272 }
273
274 public void testBrokenPatternThrowsException()
275 {
276 Collection<String> included = emptySet();
277 Collection<String> excluded = asList( "BasicTest, !**/TestTwo, **/TestThree.java" );
278 try
279 {
280 new TestListResolver( included, excluded );
281 fail( "Expected: IllegalArgumentException" );
282 }
283 catch ( IllegalArgumentException e )
284 {
285
286 assertEquals( "Exclamation mark not expected in 'exclusion': BasicTest, !**/TestTwo, **/TestThree.java",
287 e.getLocalizedMessage() );
288 }
289 }
290
291 public void testMultipleExcludedClassesOnly()
292 {
293 Collection<String> included = emptySet();
294 Collection<String> excluded = asList( "BasicTest, **/TestTwo, **/TestThree.java" );
295 TestListResolver resolver = new TestListResolver( included, excluded );
296 assertFalse( resolver.shouldRun( "jiras/surefire745/BasicTest.class", null ) );
297 assertFalse( resolver.shouldRun( "jiras/surefire745/TestTwo.class", null ) );
298 assertFalse( resolver.shouldRun( "jiras/surefire745/TestThree.class", null ) );
299 assertTrue( resolver.shouldRun( "jiras/surefire745/TestFour.class", null ) );
300 }
301
302 public void testMultipleExcludedClasses()
303 {
304 Collection<String> included = singleton( DEFAULT_SUREFIRE_INCLUDED_TEST_PATTERNS );
305 Collection<String> excluded = asList( "BasicTest, **/TestTwo, **/TestThree.java" );
306 TestListResolver resolver = new TestListResolver( included, excluded );
307 assertFalse( resolver.shouldRun( "jiras/surefire745/BasicTest.class", null ) );
308 assertFalse( resolver.shouldRun( "jiras/surefire745/TestTwo.class", null ) );
309 assertFalse( resolver.shouldRun( "jiras/surefire745/TestThree.class", null ) );
310 assertTrue( resolver.shouldRun( "jiras/surefire745/TestFour.class", null ) );
311 }
312
313 public void testAndFilters()
314 {
315 TestListResolver firstFilter = new TestListResolver( "BasicTest, **/TestTwo, **/TestThree.java" );
316 TestListResolver secondFilter = new TestListResolver( "*icTest, Test???*" );
317 TestFilter<String, String> filter = firstFilter.and( secondFilter );
318
319 assertTrue( filter.shouldRun( "jiras/surefire745/BasicTest.class", null ) );
320 assertTrue( filter.shouldRun( "jiras/surefire745/TestTwo.class", null ) );
321 assertTrue( filter.shouldRun( "jiras/surefire745/TestThree.class", null ) );
322 assertFalse( filter.shouldRun( "jiras/surefire745/TestFour.class", null ) );
323 }
324
325 public void testTestListResolverWithoutMethods()
326 {
327 ResolvedTest inc1 = new ResolvedTest( "A?Test.java", null, false );
328 ResolvedTest inc2 = new ResolvedTest( "**/?Test", null, false );
329 ResolvedTest exc1 = new ResolvedTest( "AATest", null, false );
330 ResolvedTest exc2 = new ResolvedTest( "**/BTest.java", null, false );
331 TestListResolver resolver = newTestListResolver( $( inc1, inc2 ), $( exc1, exc2 ) );
332 assertThat( resolver.getPluginParameterTest(), is( "A?Test.java, **/?Test, !AATest, !**/BTest.java" ) );
333 assertFalse( resolver.isEmpty() );
334 assertFalse( resolver.hasIncludedMethodPatterns() );
335 assertFalse( resolver.hasExcludedMethodPatterns() );
336 assertFalse( resolver.hasMethodPatterns() );
337 assertTrue( resolver.shouldRun( "ATest.class", null ) );
338 assertFalse( resolver.shouldRun( "AATest.class", null ) );
339 assertTrue( resolver.shouldRun( "ABTest.class", null ) );
340 assertFalse( resolver.shouldRun( "BTest.class", null ) );
341 assertTrue( resolver.shouldRun( "CTest.class", null ) );
342 assertFalse( resolver.hasMethodPatterns() );
343 }
344
345 public void testTestListResolverWithMethods()
346 {
347 ResolvedTest inc1 = new ResolvedTest( "A?Test.java", null, false );
348 ResolvedTest inc2 = new ResolvedTest( "*?Test", null, false );
349 ResolvedTest exc1 = new ResolvedTest( "AATest", null, false );
350 ResolvedTest exc2 = new ResolvedTest( "*BTest.java", "failedTest", false );
351 TestListResolver resolver = newTestListResolver( $( inc1, inc2 ), $( exc1, exc2 ) );
352 assertThat( resolver.getPluginParameterTest(), is( "A?Test.java, *?Test, !AATest, !*BTest.java#failedTest" ) );
353 assertFalse( resolver.isEmpty() );
354 assertFalse( resolver.hasIncludedMethodPatterns() );
355 assertTrue( resolver.hasExcludedMethodPatterns() );
356 assertTrue( resolver.hasMethodPatterns() );
357 assertTrue( resolver.shouldRun( "ATest.class", null ) );
358 assertFalse( resolver.shouldRun( "AATest.class", null ) );
359 assertTrue( resolver.shouldRun( "ABTest.class", null ) );
360 assertTrue( resolver.shouldRun( "BTest.class", null ) );
361 assertFalse( resolver.shouldRun( "BTest.class", "failedTest" ) );
362 assertTrue( resolver.shouldRun( "CTest.class", null ) );
363 assertFalse( TestListResolver.optionallyWildcardFilter( resolver ).isEmpty() );
364 }
365
366 private static Set<ResolvedTest> $( ResolvedTest... patterns )
367 {
368 Set<ResolvedTest> set = new LinkedHashSet<ResolvedTest>();
369 addAll( set, patterns );
370 return set;
371 }
372
373 public void testDefaultPatternsMatching()
374 {
375 Set<ResolvedTest> inclusions = resolveClass( DEFAULT_SUREFIRE_INCLUDED_TEST_PATTERNS );
376 Set<ResolvedTest> exclusions = resolveClass( DEFAULT_SUREFIRE_EXCLUDED_TEST_PATTERNS );
377 TestListResolver tlr = newTestListResolver( inclusions, exclusions );
378 boolean shouldRun = tlr.shouldRun( "org/apache/maven/surefire/SomeTest.class", null );
379 assertTrue( shouldRun );
380 }
381
382 public void testDefaultPatternsNotMatching()
383 {
384 Set<ResolvedTest> inclusions = resolveClass( DEFAULT_SUREFIRE_INCLUDED_TEST_PATTERNS );
385 Set<ResolvedTest> exclusions = resolveClass( DEFAULT_SUREFIRE_EXCLUDED_TEST_PATTERNS );
386 TestListResolver tlr = newTestListResolver( inclusions, exclusions );
387 boolean shouldRun = tlr.shouldRun( "org/apache/maven/surefire/SomeTestNotRunning.class", null );
388 assertFalse( shouldRun );
389 }
390
391 public void testInclusiveWithDefaultExclusivePattern()
392 {
393 Set<ResolvedTest> defaultExclusions = resolveClass( DEFAULT_SUREFIRE_EXCLUDED_TEST_PATTERNS );
394 boolean runnable = newTestListResolver( resolveClass( "A*Test" ), defaultExclusions )
395 .shouldRun( "org/apache/maven/surefire/ARunnableTest.class", null );
396 assertTrue( runnable );
397 }
398
399 public void testWildcard()
400 {
401 TestListResolver tlr = TestListResolver.optionallyWildcardFilter( new TestListResolver( (String) null ) );
402 assertThat( tlr, is( new TestListResolver( "**/*.class" ) ) );
403 assertThat( tlr.isWildcard(), is( true ) );
404 assertThat( tlr.isEmpty(), is( false ) );
405
406 tlr = TestListResolver.optionallyWildcardFilter( new TestListResolver( "**/**/MethodLessPattern.class" ) );
407 assertThat( tlr, is( new TestListResolver( "**/*.class" ) ) );
408 assertThat( tlr.isWildcard(), is( true ) );
409 assertThat( tlr.isEmpty(), is( false ) );
410 }
411
412 public void testRegexRuleViolationQuotedHashMark()
413 {
414 try
415 {
416 new TestListResolver( "%regex[.\\Q#\\E.]" );
417 fail( "IllegalArgumentException is expected" );
418 }
419 catch ( IllegalArgumentException iea )
420 {
421
422 }
423 }
424
425 public void testRegexRuleViolationEnclosedMethodSeparator()
426 {
427 try
428 {
429 new TestListResolver( "%regex[(.|.#.)]" );
430 fail( "IllegalArgumentException is expected" );
431 }
432 catch ( IllegalArgumentException iea )
433 {
434
435 }
436 }
437
438 public void testRegexRuleViolationMultipleHashmarkWithClassConstraint()
439 {
440 try
441 {
442 new TestListResolver( "%regex[.*#.|#.]" );
443 fail( "IllegalArgumentException is expected" );
444 }
445 catch ( IllegalArgumentException iea )
446 {
447
448 }
449 }
450
451 public void testRegexRuleViolationMultipleHashmarkForMethods()
452 {
453 try
454 {
455 new TestListResolver( "%regex[#.|#.]" );
456 fail( "IllegalArgumentException is expected" );
457 }
458 catch ( IllegalArgumentException iea )
459 {
460
461 }
462 }
463
464 public void testRegexRuleViolationInvalidClassPattern()
465 {
466 try
467 {
468 new TestListResolver( "%regex[.(.]" )
469 .shouldRun( "x", "x" );
470 fail( "IllegalArgumentException is expected" );
471 }
472 catch ( IllegalArgumentException iea )
473 {
474
475 }
476 }
477
478 public void testRegexRuleViolationInvalidMethodPattern()
479 {
480 try
481 {
482 new TestListResolver( "%regex[#.(.]" );
483 fail( "IllegalArgumentException is expected" );
484 }
485 catch ( IllegalArgumentException iea )
486 {
487
488 }
489 }
490
491 private static Set<ResolvedTest> resolveClass( String patterns )
492 {
493 Set<ResolvedTest> resolved = new HashSet<ResolvedTest>();
494 for ( String pattern : patterns.split( "," ) )
495 {
496 resolved.add( new ResolvedTest( CLASS, pattern, false ) );
497 }
498 return resolved;
499 }
500 }