@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); } }
@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."); } }
@Override protected void validateConstructor(List<Throwable> errors) { validateOnlyOneConstructor(errors); if (getInjectionType() != InjectionType.CONSTRUCTOR) { validateZeroArgConstructor(errors); } }
@Override public Object createTest() throws Exception { if (fieldsAreAnnotated()) { return createTestUsingFieldInjection(); } else { return createTestUsingConstructorInjection(); } }
@Override protected void validateConstructor(List<Throwable> errors) { validateOnlyOneConstructor(errors); if (fieldsAreAnnotated()) { validateZeroArgConstructor(errors); } }
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 Object createTestUsingConstructorInjection() throws Exception { return getTestClass().getOnlyConstructor().newInstance(parameters); }
@Override protected void validateFields(List<Throwable> errors) { super.validateFields(errors); if (fieldsAreAnnotated()) { List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(); int[] usedIndices = new int[annotatedFieldsByParameter.size()]; for (FrameworkField each : annotatedFieldsByParameter) {
@Override protected Statement classBlock(RunNotifier notifier) { return childrenInvoker(notifier); }
@Override protected String testName(FrameworkMethod method) { return method.getName() + getName(); }
private boolean fieldsAreAnnotated() { return !getAnnotatedFieldsByParameter().isEmpty(); } }
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 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 InjectionType getInjectionType() { if (fieldsAreAnnotated()) { return InjectionType.FIELD; } else { return InjectionType.CONSTRUCTOR; } }
@Override public Object createTest() throws Exception { if (fieldsAreAnnotated()) { return createTestUsingFieldInjection(); } else { return createTestUsingConstructorInjection(); } }
@Override protected void validateConstructor(List<Throwable> errors) { validateOnlyOneConstructor(errors); if (fieldsAreAnnotated()) { validateZeroArgConstructor(errors); } }
private Object createTestUsingFieldInjection() throws Exception { List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(); if (annotatedFieldsByParameter.size() != parameters.length) { throw new Exception( "Wrong number of parameters and @Parameter fields." + " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + parameters.length + "."); } Object testClassInstance = getTestClass().getJavaClass().newInstance(); for (FrameworkField each : annotatedFieldsByParameter) { Field field = each.getField(); Parameter annotation = field.getAnnotation(Parameter.class); int index = annotation.value(); try { field.set(testClassInstance, parameters[index]); } catch (IllegalArgumentException iare) { throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() + " with the value " + parameters[index] + " that is not the right type (" + parameters[index].getClass().getSimpleName() + " instead of " + field.getType().getSimpleName() + ").", iare); } } return testClassInstance; }
private List<FrameworkField> getAnnotatedFieldsByParameter() { return getTestClass().getAnnotatedFields(Parameter.class); }
@Override protected void validateFields(List<Throwable> errors) { super.validateFields(errors); if (fieldsAreAnnotated()) { List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(); int[] usedIndices = new int[annotatedFieldsByParameter.size()]; for (FrameworkField each : annotatedFieldsByParameter) {