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