Treat non-inherited composed annos for inherited annos as inherited

Non-@inherited composed annotations which are meta-annotated with an
@inherited annotation are now considered to be implicitly inherited
when searching for the meta-annotation within a class hierarchy.

Issue: #1133

Author: sbrannen

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

@@ -46,6 +46,9 @@ _@API Guardian_ JAR _mandatory_ again.
   `name` attribute of `<testcase/>` elements into XML reports. However, due to a
   limitation of Maven Surefire, instead of `methodName(Type)` they are written as
   `methodName{Type}`.
+* Non-inherited _composed annotations_ which are meta-annotated with a given `@Inherited`
+  annotation are now considered to be implicitly _inherited_ when searching for the given
+  meta-annotation within a class hierarchy.
 
 ===== New Features and Improvements
 
@@ -68,6 +71,13 @@ _@API Guardian_ JAR _mandatory_ again.
 ===== Bug Fixes
 
 * The `@Tag` and `@Tags` annotations are now inherited within test class hierarchies.
+* Due to a change in the JUnit Platform's `AnnotationUtils` class, non-inherited
+  _composed annotations_ which are meta-annotated with a given `@Inherited` annotation
+  are now considered to be implicitly _inherited_ when searching for the given
+  meta-annotation within a class hierarchy.
+** For example, an `@Inherited` annotation such as `@TestInstance` will now be discovered
+   on a custom _composed annotation_ declared on a superclass even if the _composed
+   annotation_ is not declared as `@Inherited`.
 
 
 [[release-notes-5.0.3-junit-vintage]]

junit-platform-commons/src/main/java/org/junit/platform/commons/util/AnnotationUtils.java

@@ -143,19 +143,22 @@ public static <A extends Annotation> Optional<A> findAnnotation(Optional<? exten
 			return Optional.empty();
 		}
 
-		return findAnnotation(element.get(), annotationType, new HashSet<>());
+		boolean inherited = annotationType.isAnnotationPresent(Inherited.class);
+
+		return findAnnotation(element.get(), annotationType, inherited, new HashSet<>());
 	}
 
 	/**
 	 * @see org.junit.platform.commons.support.AnnotationSupport#findAnnotation(AnnotatedElement, Class)
 	 */
 	public static <A extends Annotation> Optional<A> findAnnotation(AnnotatedElement element, Class<A> annotationType) {
-		return findAnnotation(element, annotationType, new HashSet<>());
+		boolean inherited = annotationType.isAnnotationPresent(Inherited.class);
+		return findAnnotation(element, annotationType, inherited, new HashSet<>());
 	}
 
 	@SuppressWarnings("unchecked")
 	private static <A extends Annotation> Optional<A> findAnnotation(AnnotatedElement element, Class<A> annotationType,
-			Set<Annotation> visited) {
+			boolean inherited, Set<Annotation> visited) {
 
 		Preconditions.notNull(annotationType, "annotationType must not be null");
 
@@ -179,22 +182,34 @@ private static <A extends Annotation> Optional<A> findAnnotation(AnnotatedElemen
 
 		// Meta-present on directly present annotations?
 		Optional<A> directMetaAnnotation = findMetaAnnotation(annotationType, element.getDeclaredAnnotations(), key,
-			visited);
+			inherited, visited);
 		if (directMetaAnnotation.isPresent()) {
 			return directMetaAnnotation;
 		}
 
-		// Search on interfaces
 		if (element instanceof Class) {
 			Class<?> clazz = (Class<?>) element;
+
+			// Search on interfaces
 			for (Class<?> ifc : clazz.getInterfaces()) {
 				if (ifc != Annotation.class) {
-					Optional<A> annotationOnInterface = findAnnotation(ifc, annotationType, visited);
+					Optional<A> annotationOnInterface = findAnnotation(ifc, annotationType, inherited, visited);
 					if (annotationOnInterface.isPresent()) {
 						return annotationOnInterface;
 					}
 				}
 			}
+
+			// Search in class hierarchy
+			if (inherited) {
+				Class<?> superclass = clazz.getSuperclass();
+				if (superclass != null && superclass != Object.class) {
+					Optional<A> annotationOnSuperclass = findAnnotation(superclass, annotationType, inherited, visited);
+					if (annotationOnSuperclass.isPresent()) {
+						return annotationOnSuperclass;
+					}
+				}
+			}
 		}
 
 		// Indirectly present?
@@ -205,16 +220,17 @@ private static <A extends Annotation> Optional<A> findAnnotation(AnnotatedElemen
 		}
 
 		// Meta-present on indirectly present annotations?
-		return findMetaAnnotation(annotationType, element.getAnnotations(), key, visited);
+		return findMetaAnnotation(annotationType, element.getAnnotations(), key, inherited, visited);
 	}
 
 	private static <A extends Annotation> Optional<A> findMetaAnnotation(Class<A> annotationType,
-			Annotation[] candidates, AnnotationCacheKey key, Set<Annotation> visited) {
+			Annotation[] candidates, AnnotationCacheKey key, boolean inherited, Set<Annotation> visited) {
 
 		for (Annotation candidateAnnotation : candidates) {
 			Class<? extends Annotation> candidateAnnotationType = candidateAnnotation.annotationType();
 			if (!isInJavaLangAnnotationPackage(candidateAnnotationType) && visited.add(candidateAnnotation)) {
-				Optional<A> metaAnnotation = findAnnotation(candidateAnnotationType, annotationType, visited);
+				Optional<A> metaAnnotation = findAnnotation(candidateAnnotationType, annotationType, inherited,
+					visited);
 				if (metaAnnotation.isPresent()) {
 					annotationCache.put(key, metaAnnotation.get());
 					return metaAnnotation;

platform-tests/src/test/java/org/junit/platform/commons/util/AnnotationUtilsTests.java

@@ -122,6 +122,15 @@ void findAnnotationIndirectlyPresentOnClass() {
 		assertThat(findAnnotation(SubInheritedAnnotationClass.class, InheritedAnnotation.class)).isPresent();
 	}
 
+	/**
+	 * Test for https://github.com/junit-team/junit5/issues/1133
+	 */
+	@Test
+	void findInheritedAnnotationMetaPresentOnNonInheritedComposedAnnotationPresentOnSuperclass() {
+		assertThat(findAnnotation(SubNonInheritedCompositionOfInheritedAnnotationClass.class,
+			InheritedAnnotation.class)).isPresent();
+	}
+
 	@Test
 	void findAnnotationDirectlyPresentOnClass() {
 		assertThat(findAnnotation(Annotation1Class.class, Annotation1.class)).isPresent();
@@ -133,14 +142,15 @@ void findAnnotationMetaPresentOnClass() {
 	}
 
 	/**
-	 * <b>Note:</b> there is no findAnnotationIndirectlyMetaPresentOnMethod counterpart because {@link Inherited}
-	 * annotation has no effect if the annotated type is used to annotate anything other than a class.
+	 * <b>Note:</b> there is no findAnnotationIndirectlyMetaPresentOnMethod
+	 * counterpart because the {@code @Inherited} annotation has no effect if
+	 * the annotation type is used to annotate anything other than a class.
 	 *
 	 * @see Inherited
 	 */
 	@Test
 	void findAnnotationIndirectlyMetaPresentOnClass() {
-		assertThat(findAnnotation(InheritedComposedAnnotationSubClass.class, Annotation1.class)).isPresent();
+		assertThat(findAnnotation(SubInheritedComposedAnnotationClass.class, Annotation1.class)).isPresent();
 	}
 
 	@Test
@@ -475,8 +485,16 @@ private List<String> asNames(List<Field> fields) {
 	@interface InheritedComposedAnnotation {
 	}
 
+	@Target(ElementType.TYPE)
+	@Retention(RetentionPolicy.RUNTIME)
+	@InheritedAnnotation
+	// DO NOT make this @Inherited.
+	@interface NonInheritedCompositionOfInheritedAnnotation {
+	}
+
 	@Target({ ElementType.TYPE, ElementType.METHOD })
 	@Retention(RetentionPolicy.RUNTIME)
+	// DO NOT make this @Inherited.
 	@interface Tags {
 
 		Tag[] value();
@@ -485,6 +503,7 @@ private List<String> asNames(List<Field> fields) {
 	@Target({ ElementType.TYPE, ElementType.METHOD })
 	@Retention(RetentionPolicy.RUNTIME)
 	@Repeatable(Tags.class)
+	// DO NOT make this @Inherited.
 	@interface Tag {
 
 		String value();
@@ -581,7 +600,15 @@ void method() {
 		}
 	}
 
-	static class InheritedComposedAnnotationSubClass extends InheritedComposedAnnotationClass {
+	static class SubInheritedComposedAnnotationClass extends InheritedComposedAnnotationClass {
+	}
+
+	@NonInheritedCompositionOfInheritedAnnotation
+	static class NonInheritedCompositionOfInheritedAnnotationClass {
+	}
+
+	static class SubNonInheritedCompositionOfInheritedAnnotationClass
+			extends NonInheritedCompositionOfInheritedAnnotationClass {
 	}
 
 	@Annotation1