Avoid reporting discovery warnings for abstract methods (#4668)

Resolves #4636.

(cherry picked from commit 16d7fa7)

Author: marcphilipp

documentation/src/docs/asciidoc/release-notes/release-notes-5.13.2.adoc

@@ -39,6 +39,9 @@ repository on GitHub.
   `@Nested`.
 * Stop reporting discovery issues for _abstract_ inner classes that contain test methods
   but are not annotated with `@Nested`.
+* Stop reporting discovery issues for _abstract_ test methods. While they won't be
+  executed, it's a valid pattern to annotate them with `@Test` for documentation purposes
+  and override them in subclasses while re-declaring the `@Test` annotation.
 
 [[release-notes-5.13.2-junit-jupiter-deprecations-and-breaking-changes]]
 ==== Deprecations and Breaking Changes

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/predicates/IsTestableMethod.java

@@ -11,6 +11,7 @@
 package org.junit.jupiter.engine.discovery.predicates;
 
 import static org.junit.platform.commons.support.AnnotationSupport.isAnnotated;
+import static org.junit.platform.commons.support.ModifierSupport.isNotAbstract;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
@@ -39,14 +40,13 @@ abstract class IsTestableMethod implements Predicate<Method> {
 		this.annotationType = annotationType;
 		this.condition = isNotStatic(annotationType, issueReporter) //
 				.and(isNotPrivate(annotationType, issueReporter)) //
-				.and(isNotAbstract(annotationType, issueReporter)) //
 				.and(returnTypeConditionFactory.apply(annotationType, issueReporter));
 	}
 
 	@Override
 	public boolean test(Method candidate) {
 		if (isAnnotated(candidate, this.annotationType)) {
-			return condition.check(candidate);
+			return condition.check(candidate) && isNotAbstract(candidate);
 		}
 		return false;
 	}
@@ -63,12 +63,6 @@ private static Condition<Method> isNotPrivate(Class<? extends Annotation> annota
 			method -> createIssue(annotationType, method, "must not be private"));
 	}
 
-	private static Condition<Method> isNotAbstract(Class<? extends Annotation> annotationType,
-			DiscoveryIssueReporter issueReporter) {
-		return issueReporter.createReportingCondition(ModifierSupport::isNotAbstract,
-			method -> createIssue(annotationType, method, "must not be abstract"));
-	}
-
 	protected static Condition<Method> hasVoidReturnType(Class<? extends Annotation> annotationType,
 			DiscoveryIssueReporter issueReporter) {
 		return issueReporter.createReportingCondition(ReflectionUtils::returnsPrimitiveVoid,

jupiter-tests/src/test/java/org/junit/jupiter/engine/discovery/DiscoveryTests.java

@@ -63,30 +63,30 @@ class DiscoveryTests extends AbstractJupiterTestEngineTests {
 	@Test
 	void discoverTestClass() {
 		LauncherDiscoveryRequest request = defaultRequest().selectors(selectClass(LocalTestCase.class)).build();
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 		assertEquals(7, engineDescriptor.getDescendants().size(), "# resolved test descriptors");
 	}
 
 	@Test
 	void doNotDiscoverAbstractTestClass() {
 		LauncherDiscoveryRequest request = defaultRequest().selectors(selectClass(AbstractTestCase.class)).build();
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 		assertEquals(0, engineDescriptor.getDescendants().size(), "# resolved test descriptors");
 	}
 
 	@Test
 	void discoverMethodByUniqueId() {
 		LauncherDiscoveryRequest request = defaultRequest().selectors(
 			selectUniqueId(JupiterUniqueIdBuilder.uniqueIdForMethod(LocalTestCase.class, "test1()"))).build();
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 		assertEquals(2, engineDescriptor.getDescendants().size(), "# resolved test descriptors");
 	}
 
 	@Test
 	void discoverMethodByUniqueIdForOverloadedMethod() {
 		LauncherDiscoveryRequest request = defaultRequest().selectors(
 			selectUniqueId(JupiterUniqueIdBuilder.uniqueIdForMethod(LocalTestCase.class, "test4()"))).build();
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 		assertEquals(2, engineDescriptor.getDescendants().size(), "# resolved test descriptors");
 	}
 
@@ -95,7 +95,7 @@ void discoverMethodByUniqueIdForOverloadedMethodVariantThatAcceptsArguments() {
 		LauncherDiscoveryRequest request = defaultRequest().selectors(
 			selectUniqueId(JupiterUniqueIdBuilder.uniqueIdForMethod(LocalTestCase.class,
 				"test4(" + TestInfo.class.getName() + ")"))).build();
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 		assertEquals(2, engineDescriptor.getDescendants().size(), "# resolved test descriptors");
 	}
 
@@ -105,7 +105,7 @@ void discoverMethodByMethodReference() throws NoSuchMethodException {
 
 		LauncherDiscoveryRequest request = defaultRequest().selectors(
 			selectMethod(LocalTestCase.class, testMethod)).build();
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 		assertEquals(2, engineDescriptor.getDescendants().size(), "# resolved test descriptors");
 	}
 
@@ -114,7 +114,7 @@ void discoverMultipleMethodsOfSameClass() {
 		LauncherDiscoveryRequest request = defaultRequest().selectors(selectMethod(LocalTestCase.class, "test1"),
 			selectMethod(LocalTestCase.class, "test2")).build();
 
-		TestDescriptor engineDescriptor = discoverTests(request).getEngineDescriptor();
+		TestDescriptor engineDescriptor = discoverTestsWithoutIssues(request);
 
 		assertThat(engineDescriptor.getChildren()).hasSize(1);
 		TestDescriptor classDescriptor = getOnlyElement(engineDescriptor.getChildren());
@@ -361,14 +361,23 @@ void reportsWarningsForBlankDisplayNames() throws Exception {
 				.contains(org.junit.platform.engine.support.descriptor.MethodSource.from(method));
 	}
 
+	private TestDescriptor discoverTestsWithoutIssues(LauncherDiscoveryRequest request) {
+		var results = super.discoverTests(request);
+		assertThat(results.getDiscoveryIssues()).isEmpty();
+		return results.getEngineDescriptor();
+	}
+
 	// -------------------------------------------------------------------
 
 	@SuppressWarnings("unused")
-	private static abstract class AbstractTestCase {
+	static abstract class AbstractTestCase {
 
 		@Test
-		void abstractTest() {
+		void test() {
 		}
+
+		@Test
+		abstract void abstractTest();
 	}
 
 	@SuppressWarnings("JUnitMalformedDeclaration")

jupiter-tests/src/test/java/org/junit/jupiter/engine/discovery/predicates/IsTestMethodTests.java

@@ -72,12 +72,7 @@ void bogusAbstractTestMethod() {
 		var method = abstractMethod("bogusAbstractTestMethod");
 
 		assertThat(isTestMethod).rejects(method);
-
-		var issue = getOnlyElement(discoveryIssues);
-		assertThat(issue.severity()).isEqualTo(Severity.WARNING);
-		assertThat(issue.message()).isEqualTo("@Test method '%s' must not be abstract. It will not be executed.",
-			method.toGenericString());
-		assertThat(issue.source()).contains(MethodSource.from(method));
+		assertThat(discoveryIssues).isEmpty();
 	}
 
 	@Test
@@ -86,12 +81,8 @@ void bogusAbstractNonVoidTestMethod() {
 
 		assertThat(isTestMethod).rejects(method);
 
-		assertThat(discoveryIssues).hasSize(2);
-		discoveryIssues.sort(comparing(DiscoveryIssue::message));
-		assertThat(discoveryIssues.getFirst().message()) //
-				.isEqualTo("@Test method '%s' must not be abstract. It will not be executed.",
-					method.toGenericString());
-		assertThat(discoveryIssues.getLast().message()) //
+		var issue = getOnlyElement(discoveryIssues);
+		assertThat(issue.message()) //
 				.isEqualTo("@Test method '%s' must not return a value. It will not be executed.",
 					method.toGenericString());
 	}