Added LifecycleContext.findRepeatableAnnotations()

Author: jlink

api/src/main/java/net/jqwik/api/lifecycle/LifecycleContext.java

@@ -79,6 +79,16 @@ public interface LifecycleContext {
 	 */
 	<T extends Annotation> List<T> findAnnotationsInContainer(Class<T> annotationClass);
 
+	/**
+	 * Retrieve a list of repeatable annotations if present at the current test element.
+	 *
+	 * @param annotationClass The annotation type
+	 * @param <T>             The annotation type
+	 * @return list of annotation objects
+	 */
+	@API(status = MAINTAINED, since = "1.7.4")
+	<T extends Annotation> List<T> findRepeatableAnnotations(Class<T> annotationClass);
+
 	/**
 	 * Create a new instance of a {@code clazz} in the context of the property in which it
 	 * is running. Use this method, for example, when trying to instantiate a class

engine/src/main/java/net/jqwik/engine/execution/AbstractLifecycleContext.java

@@ -56,6 +56,11 @@ public <A extends Annotation> List<A> findAnnotationsInContainer(Class<A> annota
 			.orElse(Collections.emptyList());
 	}
 
+	@Override
+	public <T extends Annotation> List<T> findRepeatableAnnotations(Class<T> annotationClass) {
+		return AnnotationSupport.findRepeatableAnnotations(optionalElement(), annotationClass);
+	}
+
 	private Optional<ContainerClassDescriptor> parentContainer() {
 		return parentContainer(descriptor);
 	}

engine/src/main/java/net/jqwik/engine/execution/DefaultTryLifecycleContext.java

@@ -77,6 +77,11 @@ public <T extends Annotation> List<T> findAnnotationsInContainer(Class<T> annota
 		return propertyContext.findAnnotationsInContainer(annotationClass);
 	}
 
+	@Override
+	public <T extends Annotation> List<T> findRepeatableAnnotations(Class<T> annotationClass) {
+		return propertyContext.findRepeatableAnnotations(annotationClass);
+	}
+
 	@Override
 	public String toString() {
 		return String.format("TryLifecycleContext:%s", propertyContext);

engine/src/test/java/net/jqwik/engine/TestHelper.java

@@ -218,6 +218,11 @@ public <T extends Annotation> List<T> findAnnotationsInContainer(Class<T> annota
 				return Collections.emptyList();
 			}
 
+			@Override
+			public <T extends Annotation> List<T> findRepeatableAnnotations(Class<T> annotationClass) {
+				return Collections.emptyList();
+			}
+
 			@Override
 			public <T> T newInstance(Class<T> clazz) {
 				return null;

engine/src/test/java/net/jqwik/engine/execution/lifecycle/LifecycleContextAnnotationsTests.java

@@ -1,7 +1,9 @@
 package net.jqwik.engine.execution.lifecycle;
 
 import java.lang.annotation.*;
+import java.util.*;
 
+import org.junit.platform.engine.*;
 import org.mockito.*;
 
 import net.jqwik.api.*;
@@ -13,11 +15,27 @@
 import static org.assertj.core.api.Assertions.*;
 
 @MyAnnotation
+@MyRepeatableAnnotation("one")
+@MyRepeatableAnnotation("two")
 class LifecycleContextAnnotationsTests {
 
 	private final Reporter reporter = Mockito.mock(Reporter.class);
 	private final ResolveParameterHook resolveParameter = Mockito.mock(ResolveParameterHook.class);
 
+	@Example
+	void engineLifecycleContext() {
+
+		TestDescriptor engineDescriptor = TestDescriptorBuilder.forEngine(new JqwikTestEngine()).build();
+		EngineLifecycleContext lifecycleContext = new EngineLifecycleContext(
+			engineDescriptor,
+			reporter,
+			resolveParameter
+		);
+		assertThat(lifecycleContext.findAnnotation(MyAnnotation.class)).isEmpty();
+		assertThat(lifecycleContext.findAnnotationsInContainer(MyAnnotation.class)).isEmpty();
+		assertThat(lifecycleContext.findRepeatableAnnotations(MyRepeatableAnnotation.class)).isEmpty();
+	}
+
 	@Example
 	void containerLifecycleDescriptor() {
 
@@ -31,7 +49,11 @@ void containerLifecycleDescriptor() {
 
 		assertThat(lifecycleContext.findAnnotation(MyAnnotation.class)).isPresent();
 		assertThat(lifecycleContext.findAnnotationsInContainer(MyAnnotation.class)).isEmpty();
-		assertThat(lifecycleContext.findAnnotation(Property.class)).isNotPresent();
+
+		List<MyRepeatableAnnotation> repeatableAnnotations = lifecycleContext.findRepeatableAnnotations(MyRepeatableAnnotation.class);
+		assertThat(repeatableAnnotations).isNotEmpty();
+		assertThat(repeatableAnnotations.stream().map(MyRepeatableAnnotation::value))
+			.contains("one", "two");
 	}
 
 	@Example
@@ -52,6 +74,8 @@ void nestedContainerLifecycleDescriptor() {
 			.hasSize(1);
 	}
 
+	@MyRepeatableAnnotation("three")
+	@MyRepeatableAnnotation("four")
 	@Example
 	void propertyLifecycleDescriptor() {
 
@@ -69,6 +93,39 @@ void propertyLifecycleDescriptor() {
 		assertThat(lifecycleContext.findAnnotationsInContainer(MyAnnotation.class))
 			.hasSize(1);
 
+		List<MyRepeatableAnnotation> repeatableAnnotations = lifecycleContext.findRepeatableAnnotations(MyRepeatableAnnotation.class);
+		assertThat(repeatableAnnotations).isNotEmpty();
+		assertThat(repeatableAnnotations.stream().map(MyRepeatableAnnotation::value))
+			.contains("three", "four");
+
+	}
+
+	@MyRepeatableAnnotation("five")
+	@MyRepeatableAnnotation("six")
+	@Example
+	void tryLifecycleDescriptor() {
+
+		PropertyMethodDescriptor methodDescriptor = (PropertyMethodDescriptor) TestDescriptorBuilder.forMethod(
+			LifecycleContextAnnotationsTests.class, "tryLifecycleDescriptor"
+		).build();
+		DefaultPropertyLifecycleContext propertyLifecycleContext = new DefaultPropertyLifecycleContext(
+			methodDescriptor,
+			new LifecycleContextAnnotationsTests(),
+			reporter,
+			resolveParameter
+		);
+
+		TryLifecycleContext lifecycleContext = new DefaultTryLifecycleContext(propertyLifecycleContext);
+
+		assertThat(lifecycleContext.findAnnotation(Example.class)).isPresent();
+		assertThat(lifecycleContext.findAnnotationsInContainer(MyAnnotation.class))
+			.hasSize(1);
+
+		List<MyRepeatableAnnotation> repeatableAnnotations = lifecycleContext.findRepeatableAnnotations(MyRepeatableAnnotation.class);
+		assertThat(repeatableAnnotations).isNotEmpty();
+		assertThat(repeatableAnnotations.stream().map(MyRepeatableAnnotation::value))
+			.contains("five", "six");
+
 	}
 
 	@Group
@@ -83,3 +140,16 @@ void aProperty(@ForAll String aString) {}
 @Retention(RetentionPolicy.RUNTIME)
 @interface MyAnnotation {
 }
+
+@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(MyRepeatableAnnotations.class)
+@interface MyRepeatableAnnotation {
+	String value();
+}
+
+@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@interface MyRepeatableAnnotations {
+	MyRepeatableAnnotation[] value();
+}