private InjectionType getInjectionType() { if (fieldsAreAnnotated()) { return InjectionType.FIELD; } else { return InjectionType.CONSTRUCTOR; } }
@Override protected Statement classBlock(RunNotifier notifier) { Statement statement = childrenInvoker(notifier); statement = withBeforeParams(statement); statement = withAfterParams(statement); return statement; }
public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError { return new BlockJUnit4ClassRunnerWithParameters(test); } }
public BlockJUnit4ClassRunnerWithParameters(TestWithParameters test) throws InitializationError { super(test.getTestClass()); parameters = test.getParameters().toArray( new Object[test.getParameters().size()]); name = test.getName(); }
ParameterizedBehaviorTestRunner(TestWithParameters test) throws InitializationError { super(test); FeatureSet features = FluentIterable .from(test.getParameters()) .filter(FeatureSet.class) .first() .orNull(); checkState(features != null, "No FeatureSet parameter found"); // JDK-8 bug: Cannot use `super::` if the superclass method is protected; see // https://bugs.openjdk.java.net/browse/JDK-8139836 testing = new SharedBehaviorTesting( notifier -> super.childrenInvoker(notifier), (method, notifier) -> super.runChild(method, notifier), super::createTest, super::getDescription, super::getTestClass, (cls, name) -> Description.createTestDescription(cls, name + test.getParameters()), features); }
@Override protected void validateConstructor(List<Throwable> errors) { validateOnlyOneConstructor(errors); if (getInjectionType() != InjectionType.CONSTRUCTOR) { validateZeroArgConstructor(errors); } }
@Override public Object createTest() throws Exception { InjectionType injectionType = getInjectionType(); switch (injectionType) { case CONSTRUCTOR: return createTestUsingConstructorInjection(); case FIELD: return createTestUsingFieldInjection(); default: throw new IllegalStateException("The injection type " + injectionType + " is not supported."); } }
private Object createTestUsingFieldInjection() throws Exception { List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(); if (annotatedFieldsByParameter.size() != parameters.length) { throw new Exception( + "."); Object testClassInstance = getTestClass().getJavaClass().newInstance(); for (FrameworkField each : annotatedFieldsByParameter) { Field field = each.getField(); throw wrappedException; } catch (IllegalArgumentException iare) { throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() + " with the value " + parameters[index]
private TestWithParameters createTestWithParameters( TestClass testClass, String pattern, int index, Object[] parameters) { String finalPattern = pattern.replaceAll("\\{index\\}", Integer.toString(index)); String name = MessageFormat.format(finalPattern, parameters); return new TestWithParameters("[" + name + "]", testClass, Arrays.asList(parameters)); } }
private Statement withBeforeParams(Statement statement) { List<FrameworkMethod> befores = getTestClass() .getAnnotatedMethods(Parameterized.BeforeParam.class); return befores.isEmpty() ? statement : new RunBeforeParams(statement, befores); }
private Statement withAfterParams(Statement statement) { List<FrameworkMethod> afters = getTestClass() .getAnnotatedMethods(Parameterized.AfterParam.class); return afters.isEmpty() ? statement : new RunAfterParams(statement, afters); }
private List<Runner> createRunnersForParameters( Iterable<Object> allParameters, String namePattern, ParametersRunnerFactory runnerFactory) throws Exception { try { List<TestWithParameters> tests = createTestsForParameters( allParameters, namePattern); List<Runner> runners = new ArrayList<Runner>(); for (TestWithParameters test : tests) { runners.add(runnerFactory .createRunnerForTestWithParameters(test)); } return runners; } catch (ClassCastException e) { throw parametersMethodReturnedWrongType(testClass, parametersMethod); } }
@Override protected void validateFields(List<Throwable> errors) { super.validateFields(errors); if (getInjectionType() == InjectionType.FIELD) { List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(); int[] usedIndices = new int[annotatedFieldsByParameter.size()]; for (FrameworkField each : annotatedFieldsByParameter) {
private List<FrameworkField> getAnnotatedFieldsByParameter() { return getTestClass().getAnnotatedFields(Parameter.class); }
private boolean fieldsAreAnnotated() { return !getAnnotatedFieldsByParameter().isEmpty(); } }
@Override protected String testName(FrameworkMethod method) { return method.getName() + getName(); }
@Override protected List<FrameworkMethod> computeTestMethods() { return JUnit4ZKTestRunner.computeTestMethodsForClass(getTestClass().getJavaClass(), super.computeTestMethods()); }
@Override public Annotation[] getRunnerAnnotations() { return super.getRunnerAnnotations(); } }
private Object createTestUsingConstructorInjection() throws Exception { return getTestClass().getOnlyConstructor().newInstance(parameters); }
@Override protected List<FrameworkMethod> computeTestMethods() { List<FrameworkMethod> methods = super.computeTestMethods(); List<FrameworkMethod> result; Class<?> testClass = getTestClass().getJavaClass(); if (isFlakyClass(testClass)) { result = computeTestMehods(methods, testClass); } else { result = computeTestMethods(methods); } return result; }