1

Rumble

1 May 2008 @22:56

I managed to create my runner based upon the Parameterized runner. The first parameter is used as the description instead of the index of the array.

import static org.junit.Assert.assertEquals;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.junit.internal.runners.CompositeRunner;
import org.junit.internal.runners.MethodValidator;
import org.junit.internal.runners.TestClassMethodsRunner;
import org.junit.internal.runners.TestClassRunner;
import org.junit.runners.Parameterized.Parameters;

/**
 * Class DescParameterized - this class is a direct copy of
 * org.junit.runners.Parameterized, with the getName and getTestName
 * methods altered.
 */
public class DescParameterized extends TestClassRunner {

    public static Collection eachOne(Object... params) {
        List results= new ArrayList();
        for (Object param : params)
            results.add(new Object[] { param });
        return results;
    }

    // TODO: single-class this extension
    private static class TestClassRunnerForParameters
        extends TestClassMethodsRunner {

        private final Object[] fParameters;
        private final int fParameterSetNumber;
        private final Constructor fConstructor;

        private TestClassRunnerForParameters
            (Class klass, Object[] parameters, int i) {
            super(klass);
            fParameters= parameters;
            fParameterSetNumber= i;
            fConstructor= getOnlyConstructor();
        }

        @Override
            protected Object createTest() throws Exception {
            return fConstructor.newInstance(fParameters);
        }

        @Override
            protected String getName() {
            return (String) fParameters[0];
        }

        @Override
            protected String testName(final Method method) {
            return String.format("%s[%s]", method.getName(), fParameters[0]);
        }

        private Constructor getOnlyConstructor() {
            Constructor[] constructors= getTestClass().getConstructors();
            assertEquals(1, constructors.length);
            return constructors[0];
        }
    }

    // TODO: I think this now eagerly reads parameters, which was
    // never the point.
    public static class RunAllParameterMethods extends CompositeRunner {
        private final Class fKlass;

        public RunAllParameterMethods(Class klass) throws Exception {
            super(klass.getName());
            fKlass= klass;
            int i= 0;
            for (final Object each : getParametersList()) {
                if (each instanceof Object[])
                    super.add(new TestClassRunnerForParameters
                              (klass, (Object[])each, i++));
                else
                    throw new Exception
                        (String.format
                         ("%s.%s() must return a Collection of arrays.",
                          fKlass.getName(), getParametersMethod().getName()));
            }
        }

        private Collection getParametersList()
            throws IllegalAccessException, InvocationTargetException,
                   Exception {
            return (Collection) getParametersMethod().invoke(null);
        }

        private Method getParametersMethod() throws Exception {
            for (Method each : fKlass.getMethods()) {
                if (Modifier.isStatic(each.getModifiers())) {
                    Annotation[] annotations= each.getAnnotations();
                    for (Annotation annotation : annotations) {
                        if (annotation.annotationType() == Parameters.class)
                            return each;
                    }
                }
            }
            throw new Exception("No public static parameters method on class "
                                + getName());
        }
    }

    public DescParameterized(final Class klass) throws Exception {
        super(klass, new RunAllParameterMethods(klass));
    }

    @Override
        protected void validate(MethodValidator methodValidator) {
        methodValidator.validateStaticMethods();
        methodValidator.validateInstanceMethods();
    }
}