root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Polish tests

This commit is contained in:
Sam Brannen 2024-05-02 13:28:48 +03:00
parent f90bdbef42
commit 5a24e94d2e
1 changed files with 82 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
spring-core/src/test/java/org/springframework/core/annotation/MergedAnnotationsRepeatableAnnotationTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2020 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -35,6 +35,8 @@ import org.springframework.core.annotation.MergedAnnotations.SearchStrategy;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.springframework.core.annotation.MergedAnnotations.SearchStrategy.INHERITED_ANNOTATIONS;
import static org.springframework.core.annotation.MergedAnnotations.SearchStrategy.TYPE_HIERARCHY;
/** /**
* Tests for {@link MergedAnnotations} and {@link RepeatableContainers} that * Tests for {@link MergedAnnotations} and {@link RepeatableContainers} that
@ -49,184 +51,168 @@ class MergedAnnotationsRepeatableAnnotationTests {
@Test @Test
void inheritedAnnotationsWhenNonRepeatableThrowsException() { void inheritedAnnotationsWhenNonRepeatableThrowsException() {
assertThatIllegalArgumentException().isThrownBy(() -> assertThatIllegalArgumentException()
getAnnotations(null, NonRepeatable.class, SearchStrategy.INHERITED_ANNOTATIONS, getClass())) .isThrownBy(() -> getAnnotations(null, NonRepeatable.class, INHERITED_ANNOTATIONS, getClass()))
.satisfies(this::nonRepeatableRequirements); .satisfies(this::nonRepeatableRequirements);
} }
@Test @Test
void inheritedAnnotationsWhenContainerMissingValueAttributeThrowsException() { void inheritedAnnotationsWhenContainerMissingValueAttributeThrowsException() {
assertThatAnnotationConfigurationException().isThrownBy(() -> assertThatAnnotationConfigurationException()
getAnnotations(ContainerMissingValueAttribute.class, InvalidRepeatable.class, .isThrownBy(() -> getAnnotations(ContainerMissingValueAttribute.class, InvalidRepeatable.class,
SearchStrategy.INHERITED_ANNOTATIONS, getClass())) INHERITED_ANNOTATIONS, getClass()))
.satisfies(this::missingValueAttributeRequirements); .satisfies(this::missingValueAttributeRequirements);
} }
@Test @Test
void inheritedAnnotationsWhenWhenNonArrayValueAttributeThrowsException() { void inheritedAnnotationsWhenWhenNonArrayValueAttributeThrowsException() {
assertThatAnnotationConfigurationException().isThrownBy(() -> assertThatAnnotationConfigurationException()
getAnnotations(ContainerWithNonArrayValueAttribute.class, InvalidRepeatable.class, .isThrownBy(() -> getAnnotations(ContainerWithNonArrayValueAttribute.class, InvalidRepeatable.class,
SearchStrategy.INHERITED_ANNOTATIONS, getClass())) INHERITED_ANNOTATIONS, getClass()))
.satisfies(this::nonArrayValueAttributeRequirements); .satisfies(this::nonArrayValueAttributeRequirements);
} }
@Test @Test
void inheritedAnnotationsWhenWrongComponentTypeThrowsException() { void inheritedAnnotationsWhenWrongComponentTypeThrowsException() {
assertThatAnnotationConfigurationException().isThrownBy(() -> assertThatAnnotationConfigurationException()
getAnnotations(ContainerWithArrayValueAttributeButWrongComponentType.class, .isThrownBy(() -> getAnnotations(ContainerWithArrayValueAttributeButWrongComponentType.class,
InvalidRepeatable.class, SearchStrategy.INHERITED_ANNOTATIONS, getClass())) InvalidRepeatable.class, INHERITED_ANNOTATIONS, getClass()))
.satisfies(this::wrongComponentTypeRequirements); .satisfies(this::wrongComponentTypeRequirements);
} }
@Test @Test
void inheritedAnnotationsWhenOnClassReturnsAnnotations() { void inheritedAnnotationsWhenOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.INHERITED_ANNOTATIONS, RepeatableClass.class); INHERITED_ANNOTATIONS, RepeatableClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void inheritedAnnotationsWhenWhenOnSuperclassReturnsAnnotations() { void inheritedAnnotationsWhenWhenOnSuperclassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.INHERITED_ANNOTATIONS, SubRepeatableClass.class); INHERITED_ANNOTATIONS, SubRepeatableClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void inheritedAnnotationsWhenComposedOnClassReturnsAnnotations() { void inheritedAnnotationsWhenComposedOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.INHERITED_ANNOTATIONS, ComposedRepeatableClass.class); INHERITED_ANNOTATIONS, ComposedRepeatableClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void inheritedAnnotationsWhenComposedMixedWithContainerOnClassReturnsAnnotations() { void inheritedAnnotationsWhenComposedMixedWithContainerOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.INHERITED_ANNOTATIONS, INHERITED_ANNOTATIONS, ComposedRepeatableMixedWithContainerClass.class);
ComposedRepeatableMixedWithContainerClass.class); assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B",
"C");
} }
@Test @Test
void inheritedAnnotationsWhenComposedContainerForRepeatableOnClassReturnsAnnotations() { void inheritedAnnotationsWhenComposedContainerForRepeatableOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.INHERITED_ANNOTATIONS, ComposedContainerClass.class); INHERITED_ANNOTATIONS, ComposedContainerClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void inheritedAnnotationsWhenNoninheritedComposedRepeatableOnClassReturnsAnnotations() { void inheritedAnnotationsWhenNoninheritedComposedRepeatableOnClassReturnsAnnotations() {
Set<Noninherited> annotations = getAnnotations(null, Noninherited.class, Set<Noninherited> annotations = getAnnotations(null, Noninherited.class,
SearchStrategy.INHERITED_ANNOTATIONS, NoninheritedRepeatableClass.class); INHERITED_ANNOTATIONS, NoninheritedRepeatableClass.class);
assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A", assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A", "B", "C");
"B", "C");
} }
@Test @Test
void inheritedAnnotationsWhenNoninheritedComposedRepeatableOnSuperclassReturnsAnnotations() { void inheritedAnnotationsWhenNoninheritedComposedRepeatableOnSuperclassReturnsAnnotations() {
Set<Noninherited> annotations = getAnnotations(null, Noninherited.class, Set<Noninherited> annotations = getAnnotations(null, Noninherited.class,
SearchStrategy.INHERITED_ANNOTATIONS, INHERITED_ANNOTATIONS, SubNoninheritedRepeatableClass.class);
SubNoninheritedRepeatableClass.class);
assertThat(annotations).isEmpty(); assertThat(annotations).isEmpty();
} }
@Test @Test
void typeHierarchyWhenNonRepeatableThrowsException() { void typeHierarchyWhenNonRepeatableThrowsException() {
assertThatIllegalArgumentException().isThrownBy(() -> assertThatIllegalArgumentException()
getAnnotations(null, NonRepeatable.class, SearchStrategy.TYPE_HIERARCHY, getClass())) .isThrownBy(() -> getAnnotations(null, NonRepeatable.class, TYPE_HIERARCHY, getClass()))
.satisfies(this::nonRepeatableRequirements); .satisfies(this::nonRepeatableRequirements);
} }
@Test @Test
void typeHierarchyWhenContainerMissingValueAttributeThrowsException() { void typeHierarchyWhenContainerMissingValueAttributeThrowsException() {
assertThatAnnotationConfigurationException().isThrownBy(() -> assertThatAnnotationConfigurationException()
getAnnotations(ContainerMissingValueAttribute.class, InvalidRepeatable.class, .isThrownBy(() -> getAnnotations(ContainerMissingValueAttribute.class, InvalidRepeatable.class,
SearchStrategy.TYPE_HIERARCHY, getClass())) TYPE_HIERARCHY, getClass()))
.satisfies(this::missingValueAttributeRequirements); .satisfies(this::missingValueAttributeRequirements);
} }
@Test @Test
void typeHierarchyWhenWhenNonArrayValueAttributeThrowsException() { void typeHierarchyWhenWhenNonArrayValueAttributeThrowsException() {
assertThatAnnotationConfigurationException().isThrownBy(() -> assertThatAnnotationConfigurationException()
getAnnotations(ContainerWithNonArrayValueAttribute.class, InvalidRepeatable.class, .isThrownBy(() -> getAnnotations(ContainerWithNonArrayValueAttribute.class, InvalidRepeatable.class,
SearchStrategy.TYPE_HIERARCHY, getClass())) TYPE_HIERARCHY, getClass()))
.satisfies(this::nonArrayValueAttributeRequirements); .satisfies(this::nonArrayValueAttributeRequirements);
} }
@Test @Test
void typeHierarchyWhenWrongComponentTypeThrowsException() { void typeHierarchyWhenWrongComponentTypeThrowsException() {
assertThatAnnotationConfigurationException().isThrownBy(() -> assertThatAnnotationConfigurationException()
getAnnotations(ContainerWithArrayValueAttributeButWrongComponentType.class, .isThrownBy(() -> getAnnotations(ContainerWithArrayValueAttributeButWrongComponentType.class,
InvalidRepeatable.class, SearchStrategy.TYPE_HIERARCHY, getClass())) InvalidRepeatable.class, TYPE_HIERARCHY, getClass()))
.satisfies(this::wrongComponentTypeRequirements); .satisfies(this::wrongComponentTypeRequirements);
} }
@Test @Test
void typeHierarchyWhenOnClassReturnsAnnotations() { void typeHierarchyWhenOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.TYPE_HIERARCHY, RepeatableClass.class); TYPE_HIERARCHY, RepeatableClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void typeHierarchyWhenWhenOnSuperclassReturnsAnnotations() { void typeHierarchyWhenWhenOnSuperclassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.TYPE_HIERARCHY, SubRepeatableClass.class); TYPE_HIERARCHY, SubRepeatableClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void typeHierarchyWhenComposedOnClassReturnsAnnotations() { void typeHierarchyWhenComposedOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.TYPE_HIERARCHY, ComposedRepeatableClass.class); TYPE_HIERARCHY, ComposedRepeatableClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void typeHierarchyWhenComposedMixedWithContainerOnClassReturnsAnnotations() { void typeHierarchyWhenComposedMixedWithContainerOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.TYPE_HIERARCHY, TYPE_HIERARCHY, ComposedRepeatableMixedWithContainerClass.class);
ComposedRepeatableMixedWithContainerClass.class); assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B",
"C");
} }
@Test @Test
void typeHierarchyWhenComposedContainerForRepeatableOnClassReturnsAnnotations() { void typeHierarchyWhenComposedContainerForRepeatableOnClassReturnsAnnotations() {
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
SearchStrategy.TYPE_HIERARCHY, ComposedContainerClass.class); TYPE_HIERARCHY, ComposedContainerClass.class);
assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B", "C");
"C");
} }
@Test @Test
void typeHierarchyAnnotationsWhenNoninheritedComposedRepeatableOnClassReturnsAnnotations() { void typeHierarchyAnnotationsWhenNoninheritedComposedRepeatableOnClassReturnsAnnotations() {
Set<Noninherited> annotations = getAnnotations(null, Noninherited.class, Set<Noninherited> annotations = getAnnotations(null, Noninherited.class,
SearchStrategy.TYPE_HIERARCHY, NoninheritedRepeatableClass.class); TYPE_HIERARCHY, NoninheritedRepeatableClass.class);
assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A", assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A", "B", "C");
"B", "C");
} }
@Test @Test
void typeHierarchyAnnotationsWhenNoninheritedComposedRepeatableOnSuperclassReturnsAnnotations() { void typeHierarchyAnnotationsWhenNoninheritedComposedRepeatableOnSuperclassReturnsAnnotations() {
Set<Noninherited> annotations = getAnnotations(null, Noninherited.class, Set<Noninherited> annotations = getAnnotations(null, Noninherited.class,
SearchStrategy.TYPE_HIERARCHY, SubNoninheritedRepeatableClass.class); TYPE_HIERARCHY, SubNoninheritedRepeatableClass.class);
assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A", assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A", "B", "C");
"B", "C");
} }
@Test @Test
void typeHierarchyAnnotationsWithLocalComposedAnnotationWhoseRepeatableMetaAnnotationsAreFiltered() { void typeHierarchyAnnotationsWithLocalComposedAnnotationWhoseRepeatableMetaAnnotationsAreFiltered() {
Class<WithRepeatedMetaAnnotationsClass> element = WithRepeatedMetaAnnotationsClass.class; Class<WithRepeatedMetaAnnotationsClass> element = WithRepeatedMetaAnnotationsClass.class;
SearchStrategy searchStrategy = SearchStrategy.TYPE_HIERARCHY; SearchStrategy searchStrategy = TYPE_HIERARCHY;
AnnotationFilter annotationFilter = PeteRepeat.class.getName()::equals; AnnotationFilter annotationFilter = PeteRepeat.class.getName()::equals;
Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, searchStrategy, element, annotationFilter); Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class, searchStrategy, element, annotationFilter);
@ -255,32 +241,37 @@ class MergedAnnotationsRepeatableAnnotationTests {
} }
private void nonRepeatableRequirements(Exception ex) { private void nonRepeatableRequirements(Exception ex) {
assertThat(ex.getMessage()).startsWith( assertThat(ex)
"Annotation type must be a repeatable annotation").contains( .hasMessageStartingWith("Annotation type must be a repeatable annotation")
"failed to resolve container type for", .hasMessageContaining("failed to resolve container type for", NonRepeatable.class.getName());
NonRepeatable.class.getName());
} }
private void missingValueAttributeRequirements(Exception ex) { private void missingValueAttributeRequirements(Exception ex) {
assertThat(ex.getMessage()).startsWith( assertThat(ex)
"Invalid declaration of container type").contains( .hasMessageStartingWith("Invalid declaration of container type")
.hasMessageContaining(
ContainerMissingValueAttribute.class.getName(), ContainerMissingValueAttribute.class.getName(),
"for repeatable annotation", InvalidRepeatable.class.getName()); "for repeatable annotation",
assertThat(ex).hasCauseInstanceOf(NoSuchMethodException.class); InvalidRepeatable.class.getName())
.hasCauseInstanceOf(NoSuchMethodException.class);
} }
private void nonArrayValueAttributeRequirements(Exception ex) { private void nonArrayValueAttributeRequirements(Exception ex) {
assertThat(ex.getMessage()).startsWith("Container type").contains( assertThat(ex)
ContainerWithNonArrayValueAttribute.class.getName(), .hasMessageStartingWith("Container type")
"must declare a 'value' attribute for an array of type", .hasMessageContaining(
InvalidRepeatable.class.getName()); ContainerWithNonArrayValueAttribute.class.getName(),
"must declare a 'value' attribute for an array of type",
InvalidRepeatable.class.getName());
} }
private void wrongComponentTypeRequirements(Exception ex) { private void wrongComponentTypeRequirements(Exception ex) {
assertThat(ex.getMessage()).startsWith("Container type").contains( assertThat(ex)
ContainerWithArrayValueAttributeButWrongComponentType.class.getName(), .hasMessageStartingWith("Container type")
"must declare a 'value' attribute for an array of type", .hasMessageContaining(
InvalidRepeatable.class.getName()); ContainerWithArrayValueAttributeButWrongComponentType.class.getName(),
"must declare a 'value' attribute for an array of type",
InvalidRepeatable.class.getName());
} }
private static ThrowableTypeAssert<AnnotationConfigurationException> assertThatAnnotationConfigurationException() { private static ThrowableTypeAssert<AnnotationConfigurationException> assertThatAnnotationConfigurationException() {
@ -289,33 +280,28 @@ class MergedAnnotationsRepeatableAnnotationTests {
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@interface NonRepeatable { @interface NonRepeatable {
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@interface ContainerMissingValueAttribute { @interface ContainerMissingValueAttribute {
// InvalidRepeatable[] value(); // InvalidRepeatable[] value();
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@interface ContainerWithNonArrayValueAttribute { @interface ContainerWithNonArrayValueAttribute {
InvalidRepeatable value(); InvalidRepeatable value();
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@interface ContainerWithArrayValueAttributeButWrongComponentType { @interface ContainerWithArrayValueAttributeButWrongComponentType {
String[] value(); String[] value();
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@interface InvalidRepeatable { @interface InvalidRepeatable {
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@ -323,7 +309,6 @@ class MergedAnnotationsRepeatableAnnotationTests {
@interface PeteRepeats { @interface PeteRepeats {
PeteRepeat[] value(); PeteRepeat[] value();
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@ -332,7 +317,6 @@ class MergedAnnotationsRepeatableAnnotationTests {
@interface PeteRepeat { @interface PeteRepeat {
String value(); String value();
} }
@PeteRepeat("shadowed") @PeteRepeat("shadowed")
@ -343,7 +327,6 @@ class MergedAnnotationsRepeatableAnnotationTests {
@AliasFor(annotation = PeteRepeat.class) @AliasFor(annotation = PeteRepeat.class)
String value(); String value();
} }
@PeteRepeat("shadowed") @PeteRepeat("shadowed")
@ -354,7 +337,6 @@ class MergedAnnotationsRepeatableAnnotationTests {
@AliasFor(annotation = PeteRepeat.class) @AliasFor(annotation = PeteRepeat.class)
String value(); String value();
} }
@PeteRepeats({ @PeteRepeat("B"), @PeteRepeat("C") }) @PeteRepeats({ @PeteRepeat("B"), @PeteRepeat("C") })
@ -362,37 +344,31 @@ class MergedAnnotationsRepeatableAnnotationTests {
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@Inherited @Inherited
@interface ComposedContainer { @interface ComposedContainer {
} }
@PeteRepeat("A") @PeteRepeat("A")
@PeteRepeats({ @PeteRepeat("B"), @PeteRepeat("C") }) @PeteRepeats({ @PeteRepeat("B"), @PeteRepeat("C") })
static class RepeatableClass { static class RepeatableClass {
} }
static class SubRepeatableClass extends RepeatableClass { static class SubRepeatableClass extends RepeatableClass {
} }
@ForPetesSake("B") @ForPetesSake("B")
@ForTheLoveOfFoo("C") @ForTheLoveOfFoo("C")
@PeteRepeat("A") @PeteRepeat("A")
static class ComposedRepeatableClass { static class ComposedRepeatableClass {
} }
@ForPetesSake("C") @ForPetesSake("C")
@PeteRepeats(@PeteRepeat("A")) @PeteRepeats(@PeteRepeat("A"))
@PeteRepeat("B") @PeteRepeat("B")
static class ComposedRepeatableMixedWithContainerClass { static class ComposedRepeatableMixedWithContainerClass {
} }
@PeteRepeat("A") @PeteRepeat("A")
@ComposedContainer @ComposedContainer
static class ComposedContainerClass { static class ComposedContainerClass {
} }
@Target(ElementType.TYPE) @Target(ElementType.TYPE)
@ -400,7 +376,6 @@ class MergedAnnotationsRepeatableAnnotationTests {
@interface Noninheriteds { @interface Noninheriteds {
Noninherited[] value(); Noninherited[] value();
} }
@Target(ElementType.TYPE) @Target(ElementType.TYPE)
@ -413,7 +388,6 @@ class MergedAnnotationsRepeatableAnnotationTests {
@AliasFor("value") @AliasFor("value")
String name() default ""; String name() default "";
} }
@Noninherited(name = "shadowed") @Noninherited(name = "shadowed")
@ -423,17 +397,14 @@ class MergedAnnotationsRepeatableAnnotationTests {
@AliasFor(annotation = Noninherited.class) @AliasFor(annotation = Noninherited.class)
String name() default ""; String name() default "";
} }
@ComposedNoninherited(name = "C") @ComposedNoninherited(name = "C")
@Noninheriteds({ @Noninherited(value = "A"), @Noninherited(name = "B") }) @Noninheriteds({ @Noninherited(value = "A"), @Noninherited(name = "B") })
static class NoninheritedRepeatableClass { static class NoninheritedRepeatableClass {
} }
static class SubNoninheritedRepeatableClass extends NoninheritedRepeatableClass { static class SubNoninheritedRepeatableClass extends NoninheritedRepeatableClass {
} }
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)