@BeforeParam/@AfterParam for Parameterized runner

src/main/java/org/junit/runners/Parameterized.java

@@ -1,5 +1,6 @@
 package org.junit.runners;
 
+import java.lang.annotation.Annotation;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Inherited;
 import java.lang.annotation.Retention;
@@ -13,6 +14,7 @@
 
 import org.junit.runner.Runner;
 import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InvalidTestClassError;
 import org.junit.runners.model.TestClass;
 import org.junit.runners.parameterized.BlockJUnit4ClassRunnerWithParametersFactory;
 import org.junit.runners.parameterized.ParametersRunnerFactory;
@@ -234,23 +236,75 @@ public class Parameterized extends Suite {
         Class<? extends ParametersRunnerFactory> value() default BlockJUnit4ClassRunnerWithParametersFactory.class;
     }
 
+    /**
+     * Annotation for {@code public static void} methods which should be executed before
+     * evaluating tests with a particular parameter.
+     *
+     * @see org.junit.BeforeClass
+     * @see org.junit.Before
+     * @since 4.13
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface BeforeParam {
+    }
+
+    /**
+     * Annotation for {@code public static void} methods which should be executed after
+     * evaluating tests with a particular parameter.
+     *
+     * @see org.junit.AfterClass
+     * @see org.junit.After
+     * @since 4.13
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface AfterParam {
+    }
+
     /**
      * Only called reflectively. Do not use programmatically.
      */
     public Parameterized(Class<?> klass) throws Throwable {
-        super(klass, RunnersFactory.createRunnersForClass(klass));
+        this(klass, new RunnersFactory(klass));
+    }
+
+    private Parameterized(Class<?> klass, RunnersFactory runnersFactory) throws Throwable {
+        super(klass, runnersFactory.createRunners());
+        validateBeforeParamAndAfterParamMethods(runnersFactory.parameterCount);
+    }
+
+    private void validateBeforeParamAndAfterParamMethods(Integer parameterCount)
+            throws InvalidTestClassError {
+        List<Throwable> errors = new ArrayList<Throwable>();
+        validatePublicStaticVoidMethods(Parameterized.BeforeParam.class, parameterCount, errors);
+        validatePublicStaticVoidMethods(Parameterized.AfterParam.class, parameterCount, errors);
+        if (!errors.isEmpty()) {
+            throw new InvalidTestClassError(getTestClass().getJavaClass(), errors);
+        }
+    }
+
+    private void validatePublicStaticVoidMethods(
+            Class<? extends Annotation> annotation, Integer parameterCount,
+            List<Throwable> errors) {
+        List<FrameworkMethod> methods = getTestClass().getAnnotatedMethods(annotation);
+        for (FrameworkMethod fm : methods) {
+            fm.validatePublicVoid(true, errors);
+            if (parameterCount != null) {
+                final int methodParameterCount = fm.getMethod().getParameterTypes().length;
+                if (methodParameterCount != 0 && methodParameterCount != parameterCount) {
+                    errors.add(new Exception("Method " + fm.getName()
+                            + "() should have 0 or " + parameterCount + " parameter(s)"));
+                }
+            }
+        }
     }
 
     private static class RunnersFactory {
         private static final ParametersRunnerFactory DEFAULT_FACTORY = new BlockJUnit4ClassRunnerWithParametersFactory();
 
         private final TestClass testClass;
 
-        static List<Runner> createRunnersForClass(Class<?> klass)
-                throws Throwable {
-            return new RunnersFactory(klass).createRunners();
-        }
-
         private RunnersFactory(Class<?> klass) {
             testClass = new TestClass(klass);
         }
@@ -276,10 +330,15 @@ private ParametersRunnerFactory getParametersRunnerFactory()
             }
         }
 
+        private Integer parameterCount;
+
         private TestWithParameters createTestWithNotNormalizedParameters(
                 String pattern, int index, Object parametersOrSingleParameter) {
             Object[] parameters = (parametersOrSingleParameter instanceof Object[]) ? (Object[]) parametersOrSingleParameter
                     : new Object[] { parametersOrSingleParameter };
+            if (parameterCount == null) {
+                parameterCount = parameters.length;
+            }
             return createTestWithParameters(testClass, pattern, index,
                     parameters);
         }

src/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.java

@@ -2,15 +2,18 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
+import java.util.ArrayList;
 import java.util.List;
 
 import org.junit.runner.RunWith;
 import org.junit.runner.notification.RunNotifier;
 import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.model.FrameworkField;
 import org.junit.runners.model.FrameworkMethod;
 import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.MultipleFailureException;
 import org.junit.runners.model.Statement;
 
 /**
@@ -135,7 +138,73 @@ protected void validateFields(List<Throwable> errors) {
 
     @Override
     protected Statement classBlock(RunNotifier notifier) {
-        return childrenInvoker(notifier);
+        Statement statement = childrenInvoker(notifier);
+        statement = withBeforeParams(statement);
+        statement = withAfterParams(statement);
+        return statement;
+    }
+
+    private Statement withBeforeParams(Statement statement) {
+        List<FrameworkMethod> befores = getTestClass()
+                .getAnnotatedMethods(Parameterized.BeforeParam.class);
+        return befores.isEmpty() ? statement : new RunBeforeParams(statement, befores);
+    }
+
+    private class RunBeforeParams extends Statement {
+        private final Statement next;
+        private final List<FrameworkMethod> befores;
+
+        RunBeforeParams(Statement next, List<FrameworkMethod> befores) {
+            this.next = next;
+            this.befores = befores;
+        }
+
+        @Override
+        public void evaluate() throws Throwable {
+            for (FrameworkMethod before : befores) {
+                int paramCount = before.getMethod().getParameterTypes().length;
+                before.invokeExplosively(
+                        null, paramCount == 0 ? (Object[]) null : parameters);
+            }
+            next.evaluate();
+        }
+    }
+
+    private Statement withAfterParams(Statement statement) {
+        List<FrameworkMethod> afters = getTestClass()
+                .getAnnotatedMethods(Parameterized.AfterParam.class);
+        return afters.isEmpty() ? statement : new RunAfterParams(statement, afters);
+    }
+
+    private class RunAfterParams extends Statement {
+        private final Statement next;
+        private final List<FrameworkMethod> afters;
+
+        RunAfterParams(Statement next, List<FrameworkMethod> afters) {
+            this.next = next;
+            this.afters = afters;
+        }
+
+        @Override
+        public void evaluate() throws Throwable {
+            List<Throwable> errors = new ArrayList<Throwable>();
+            try {
+                next.evaluate();
+            } catch (Throwable e) {
+                errors.add(e);
+            } finally {
+                for (FrameworkMethod each : afters) {
+                    try {
+                        int paramCount = each.getMethod().getParameterTypes().length;
+                        each.invokeExplosively(
+                                null, paramCount == 0 ? (Object[]) null : parameters);
+                    } catch (Throwable e) {
+                        errors.add(e);
+                    }
+                }
+            }
+            MultipleFailureException.assertEmpty(errors);
+        }
     }
 
     @Override