Create a Custom Annotation for your JUnit5 ParameterizedTest ArgumentProvider

In my opinion, the best new feature of Junit5 is the addition of parameterized tests. They greatly reduce copy/pasted code and makes it easy to increase your test coverage without unnecessarily increasing the amount of testing code you need to write and maintain.

Here is an example of a simple Parameterized Test that tests a variety of ints to see if they are divisible by 16

@ParameterizedTest
@ValueSource(ints = {24, 32, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200})
void divisibleBy16(int i) {
    assertEquals(0, i % 16);
}

Now if we wanted to create a custom source for our test we could create our own ArgumentProvider…

 
public class OurCustomProvider implements ArgumentsProvider {
 
    public Stream provideArguments(ExtensionContext context) {
        return Stream.of(24, 32, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200).map(Arguments::of);
    }
}

… and use it.

 
@ParameterizedTest
@ArgumentsSource(OurCustomProvider.class)
void divisibleBy16(int i) {
    assertEquals(0, i % 16);
}

Now we could settle for this but we don’t have to. We can upgrade our provider by making a custom annotation and use that instead of using the @ArgumentsSource and sending in our ArgumentProvider class. While we’re at it we’ll make it more generic so that its reusable for more of our tests.

First, let’s create our new annotation with some attributes, and annotate it as with an @ArgumentsSource of our ArgumentProvider (which we’ll write next).

import org.junit.jupiter.params.provider.ArgumentsSource;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@ArgumentsSource(RangeArgumentsProvider.class)
public @interface RangeSource {
    int min() default 1;
 
    int max() default 100;
 
    int step() default 1;
}

Next, we have to create our argument provider. Implementing ArgumentsProvider as before and AnnotationConsumer to wire up our new Annotation.

import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.support.AnnotationConsumer;
 
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
public class RangeArgumentsProvider implements ArgumentsProvider, AnnotationConsumer {
    private int start;
    private int stop;
    private int step;
 
 
    RangeArgumentsProvider() {
    }
 
    public void accept(RangeSource source) {
        start = source.min();
        stop = source.max();
        step = source.step();
    }
 
    public Stream provideArguments(ExtensionContext context) {
        return IntStream.range(start, stop).filter(i -> (i - start) % step == 0).mapToObj(i -> Arguments.of(i));
    }
}

Now we can use our new custom annotation just like any of JUnit5’s built in argument providers like @ValueSource, @CsvSource, @MethodSource, etc.

@ParameterizedTest
@RangeSource(min = 24, max = 200, step = 8)
public void divisibleBy16(int i) {
    assertEquals(0, i % 16);
}
Leave a Reply

Your email address will not be published. Required fields are marked *

*

*