AnnotatedBuilder.java

package org.junit.internal.builders;

import org.junit.runner.RunWith;
import org.junit.runner.Runner;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerBuilder;

import java.lang.reflect.Modifier;


/**
 * The {@code AnnotatedBuilder} is a strategy for constructing runners for test class that have been annotated with the
 * {@code @RunWith} annotation. All tests within this class will be executed using the runner that was specified within
 * the annotation.
 * <p>
 * If a runner supports inner member classes, the member classes will inherit the runner from the enclosing class, e.g.:
 * <pre>
 * @RunWith(MyRunner.class)
 * public class MyTest {
 *     // some tests might go here
 *
 *     public class MyMemberClass {
 *         @Test
 *         public void thisTestRunsWith_MyRunner() {
 *             // some test logic
 *         }
 *
 *         // some more tests might go here
 *     }
 *
 *     @RunWith(AnotherRunner.class)
 *     public class AnotherMemberClass {
 *         // some tests might go here
 *
 *         public class DeepInnerClass {
 *             @Test
 *             public void thisTestRunsWith_AnotherRunner() {
 *                 // some test logic
 *             }
 *         }
 *
 *         public class DeepInheritedClass extends SuperTest {
 *             @Test
 *             public void thisTestRunsWith_SuperRunner() {
 *                 // some test logic
 *             }
 *         }
 *     }
 * }
 *
 * @RunWith(SuperRunner.class)
 * public class SuperTest {
 *     // some tests might go here
 * }
 * </pre>
 * The key points to note here are:
 * <ul>
 *     <li>If there is no RunWith annotation, no runner will be created.</li>
 *     <li>The resolve step is inside-out, e.g. the closest RunWith annotation wins</li>
 *     <li>RunWith annotations are inherited and work as if the class was annotated itself.</li>
 *     <li>The default JUnit runner does not support inner member classes,
 *         so this is only valid for custom runners that support inner member classes.</li>
 *     <li>Custom runners with support for inner classes may or may not support RunWith annotations for member
 *         classes. Please refer to the custom runner documentation.</li>
 * </ul>
 *
 * @see org.junit.runners.model.RunnerBuilder
 * @see org.junit.runner.RunWith
 * @since 4.0
 */
public class AnnotatedBuilder extends RunnerBuilder {
    private static final String CONSTRUCTOR_ERROR_FORMAT = "Custom runner class %s should have a public constructor with signature %s(Class testClass)";

    private final RunnerBuilder suiteBuilder;

    public AnnotatedBuilder(RunnerBuilder suiteBuilder) {
        this.suiteBuilder = suiteBuilder;
    }

    @Override
    public Runner runnerForClass(Class<?> testClass) throws Exception {
        for (Class<?> currentTestClass = testClass; currentTestClass != null;
             currentTestClass = getEnclosingClassForNonStaticMemberClass(currentTestClass)) {
            RunWith annotation = currentTestClass.getAnnotation(RunWith.class);
            if (annotation != null) {
                return buildRunner(annotation.value(), testClass);
            }
        }

        return null;
    }

    private Class<?> getEnclosingClassForNonStaticMemberClass(Class<?> currentTestClass) {
        if (currentTestClass.isMemberClass() && !Modifier.isStatic(currentTestClass.getModifiers())) {
            return currentTestClass.getEnclosingClass();
        } else {
            return null;
        }
    }

    public Runner buildRunner(Class<? extends Runner> runnerClass,
            Class<?> testClass) throws Exception {
        try {
            return runnerClass.getConstructor(Class.class).newInstance(testClass);
        } catch (NoSuchMethodException e) {
            try {
                return runnerClass.getConstructor(Class.class,
                        RunnerBuilder.class).newInstance(testClass, suiteBuilder);
            } catch (NoSuchMethodException e2) {
                String simpleName = runnerClass.getSimpleName();
                throw new InitializationError(String.format(
                        CONSTRUCTOR_ERROR_FORMAT, simpleName, simpleName));
            }
        }
    }
}