Parameterized tests enabled by defining a annotation (see {@link TestParameter} as an example) * for the type of the parameter, defining a member variable annotated with this annotation, and * specifying the parameter with the same annotation for each test, or for the whole class, for * example: * *
{@code
* @RunWith(TestParameterInjector.class)
* public class ColorTest {
* @Retention(RUNTIME)
* @Target({TYPE, METHOD, FIELD})
* @TestParameterAnnotation
* public @interface ColorParameter {
* Color[] value() default {};
* }
*
* @ColorParameter({BLUE, WHITE, RED}) private Color color;
*
* @Test
* public void test() {
* assertThat(paint(color)).isSuccessful();
* }
* }
* }
*
* An alternative is to use a method parameter for injection: * *
{@code
* @RunWith(TestParameterInjector.class)
* public class ColorTest {
* @Retention(RUNTIME)
* @Target({TYPE, METHOD, FIELD})
* @TestParameterAnnotation
* public @interface ColorParameter {
* Color[] value() default {};
* }
*
* @Test
* @ColorParameter({BLUE, WHITE, RED})
* public void test(Color color) {
* assertThat(paint(color)).isSuccessful();
* }
* }
* }
*
* Yet another alternative is to use a method parameter for injection, but with the annotation * specified on the parameter itself, which helps when multiple arguments share the * same @TestParameterAnnotation annotation. * *
{@code
* @RunWith(TestParameterInjector.class)
* public class ColorTest {
* @Retention(RUNTIME)
* @Target({TYPE, METHOD, FIELD})
* @TestParameterAnnotation
* public @interface ColorParameter {
* Color[] value() default {};
* }
*
* @Test
* public void test(@ColorParameter({BLUE, WHITE}) Color color1,
* @ColorParameter({WHITE, RED}) Color color2) {
* assertThat(paint(color1. color2)).isSuccessful();
* }
* }
* }
*
* Class constructors can also be annotated with @TestParameterAnnotation annotations, as shown * below: * *
{@code
* @RunWith(TestParameterInjector.class)
* public class ColorTest {
* @Retention(RUNTIME)
* @Target({TYPE, METHOD, FIELD})
* public @TestParameterAnnotation
* public @interface ColorParameter {
* Color[] value() default {};
* }
*
* public ColorTest(@ColorParameter({BLUE, WHITE}) Color color) {
* ...
* }
*
* @Test
* public void test() {...}
* }
* }
*
* Each field that needs to be injected from a parameter requires its dedicated distinct * annotation. * *
If the same annotation is defined both on the class and method, the method parameter values * take precedence. * *
If the same annotation is defined both on the class and constructor, the constructor parameter * values take precedence. * *
Annotations cannot be duplicated between the constructor or constructor parameters and a * method or method parameter. * *
Since the parameter values must be specified in an annotation return value, they are * restricted to the annotation method return type set (primitive, Class, Enum, String, etc...). If * parameters have to be dynamically generated, the conventional Parameterized mechanism with {@code * Parameters} has to be used instead. */ @Retention(RUNTIME) @Target({ANNOTATION_TYPE}) @interface TestParameterAnnotation { /** * Pattern of the {@link MessageFormat} format to derive the test's name from the parameters. * * @see {@code Parameters#name()} */ String name() default "{0}"; /** Specifies a validator for the parameter to determine whether test should be skipped. */ Class validator() default DefaultValidator.class; /** * Specifies a processor for the parameter to invoke arbitrary code before and after the test * statement's execution. */ Class processor() default DefaultProcessor.class; /** Specifies a value provider for the parameter to provide the values to test. */ Class valueProvider() default DefaultValueProvider.class; /** Default {@link TestParameterValidator} implementation which skips no test. */ class DefaultValidator implements TestParameterValidator { @Override public boolean shouldSkip(Context context) { return false; } } /** Default {@link TestParameterProcessor} implementation which does nothing. */ class DefaultProcessor implements TestParameterProcessor { @Override public void before(Object testParameterValue) {} @Override public void after(Object testParameterValue) {} } /** * Default {@link TestParameterValueProvider} implementation that gets its values from the * annotation's `value` method. */ class DefaultValueProvider implements TestParameterValueProvider { @Override public List