Java FrameworkField类代码示例

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
@Test
public void shouldInitializeInjectDelayedField() throws Throwable {
    // given - test class with initialized @Mock fields
    DelayedInjectionRunnerIntegrationTest runnerTest = new DelayedInjectionRunnerIntegrationTest();
    MockitoAnnotations.initMocks(runnerTest);

    TestClass testClass = new TestClass(runnerTest.getClass());
    Statement nextStatement = mock(Statement.class);
    List<FrameworkField> injectDelayedFields = testClass.getAnnotatedFields(InjectDelayed.class);
    assertThat(injectDelayedFields, hasSize(1)); // assumption
    RunDelayedInjects runDelayedInjects =
        new RunDelayedInjects(nextStatement, testClass, runnerTest, injectDelayedFields);

    // when
    runDelayedInjects.evaluate();

    // then
    assertThat(ReflectionUtils.getFieldValue(injectDelayedFields.get(0).getField(), runnerTest), not(nullValue()));
    verify(nextStatement).evaluate();
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
Stream<Assignment> allPossible() throws Throwable {

        final List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(DataProducer.class);


        Stream<Assignment> methodAssignments = Stream.empty();
        for (FrameworkMethod annotatedMethod : annotatedMethods) {
            final Type methodReturnType = getMethodGenericReturnType(annotatedMethod.getMethod());
            methodAssignments = Stream.concat(methodAssignments, methodToStreamOfResults(annotatedMethod)
                    .map(value -> new MethodResultAssignment(value, methodReturnType, annotatedMethod)));
        }

        final List<FrameworkField> annotatedFields = testClass.getAnnotatedFields(DataProducer.class);
        final Stream<Assignment> fieldsAssignments = annotatedFields.stream()
                .map(FieldAssignment::new);
        return Stream.concat(fieldsAssignments, methodAssignments);
    }
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
/**
 * Implements behavior from: org.junit.runners.Parameterized$TestClassRunnerForParameters
 */
private Object createTestUsingFieldInjection() throws Exception {
	List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
	if (annotatedFieldsByParameter.size() != fParameters.length) {
		throw new Exception("Wrong number of parameters and @Parameter fields."
				+ " @Parameter fields counted: " + annotatedFieldsByParameter.size()
				+ ", available parameters: " + fParameters.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, fParameters[index]);
		} catch (IllegalArgumentException iare) {
			throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
					+ " with the value " + fParameters[index] + " that is not the right type ("
					+ fParameters[index].getClass().getSimpleName() + " instead of "
					+ field.getType().getSimpleName() + ").", iare);
		}
	}
	return testClassInstance;
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
private Object injectAnnotatedFields(final Object testInstance) throws Exception {
    final List<FrameworkField> fields = getFieldsAnnotatedByRef();
    final Object[] fieldValues = tableRow.convertValues(fields, defaultValueConverter);
    for (int i = 0; i < fields.size(); i++) {
        final Field field = fields.get(i).getField();
        try {
            field.setAccessible(true);
            field.set(testInstance, fieldValues[i]);
        } catch (final Exception e) {
            throw new Exception(getTestClass().getName()
                    + ": Trying to set " + field.getName()
                    + " with the value " + fieldValues[i], e);
        }
    }
    return testInstance;
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
@Override
public void evaluate() throws Throwable {
    Injector injector = getInjector();
    for (FrameworkField frameworkField : fields) {
        Field field = frameworkField.getField();
        if (ReflectionUtils.getFieldValue(field, target) != null) {
            throw new IllegalStateException("Field with @InjectDelayed must be null on startup. "
                + "Field '" + field.getName() + "' is not null");
        }
        Object object = injector.getSingleton(field.getType());
        ReflectionUtils.setField(field, target, object);
    }

    this.testClass = null;
    this.target = null;
    this.fields = null;
    next.evaluate();
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
@Test
public void shouldThrowForAlreadyInitializedField() throws Throwable {
    // given - test class with initialized @Mock fields
    DelayedInjectionRunnerIntegrationTest runnerTest = new DelayedInjectionRunnerIntegrationTest();
    MockitoAnnotations.initMocks(runnerTest);

    TestClass testClass = new TestClass(runnerTest.getClass());
    Statement nextStatement = mock(Statement.class);
    List<FrameworkField> injectDelayedFields = testClass.getAnnotatedFields(InjectDelayed.class);
    assertThat(injectDelayedFields, hasSize(1)); // assumption
    ReflectionUtils.setField(injectDelayedFields.get(0).getField(), runnerTest, mock(SampleInjectClass.class));
    RunDelayedInjects runDelayedInjects =
            new RunDelayedInjects(nextStatement, testClass, runnerTest, injectDelayedFields);

    // when
    try {
        runDelayedInjects.evaluate();
        fail("Expected exception to be thrown");
    } catch (Exception e) {
        assertThat(e.getMessage(), containsString("Field with @InjectDelayed must be null"));
    }
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
public List<T> getInjectionTestPoints()
  throws IllegalAccessException
{
  List<T> result = new ArrayList<>();

  List<FrameworkField> fields = getTestClass().getAnnotatedFields();

  final MethodHandles.Lookup lookup = MethodHandles.lookup();

  for (FrameworkField field : fields) {
    Field javaField = field.getField();
    javaField.setAccessible(true);

    MethodHandle setter = lookup.unreflectSetter(javaField);

    T ip = createInjectionPoint(javaField.getType(),
                                javaField.getAnnotations(),
                                setter);

    result.add(ip);
  }

  return result;
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
@Override
protected void scanAnnotatedMembers(Map<Class<? extends Annotation>,List<FrameworkMethod>> methodsForAnnotations,
                                    Map<Class<? extends Annotation>,List<FrameworkField>> fieldsForAnnotations)
{
  super.scanAnnotatedMembers(methodsForAnnotations, fieldsForAnnotations);

  for (Map.Entry<Class<? extends Annotation>,List<FrameworkMethod>> entry
    : methodsForAnnotations.entrySet()) {
    if (Test.class.equals(entry.getKey())) {
      List<FrameworkMethod> methods = new ArrayList<>();
      for (FrameworkMethod method : entry.getValue()) {
        Method javaMethod = method.getMethod();
        if (javaMethod.getParameterTypes().length > 0) {
          methods.add(new BaratineFrameworkMethod(javaMethod));
        }
        else {
          methods.add(method);
        }
      }

      entry.setValue(methods);
    }
  }
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
/**
 * @see BlockJUnit4ClassRunnerWithParameters#createTestUsingFieldInjection()
 */
private static Object createTestUsingFieldInjection(TestClass testClass, Object[] parameters) throws Exception {
    List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(testClass);
    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 = testClass.getJavaClass().newInstance();
    for (FrameworkField each : annotatedFieldsByParameter) {
        Field field = each.getField();
        Parameterized.Parameter annotation = field.getAnnotation(Parameterized.Parameter.class);
        int index = annotation.value();
        try {
            field.set(testClassInstance, parameters[index]);
        } catch (IllegalArgumentException iare) {
            throw new Exception(
                    testClass.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;
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
/**
 * Default constructor, called by JUnit.
 * 
 * @param clazz
 *            The root class of the suite.
 * @throws InitializationError
 *             If there
 */
public FuzzyRunner(Class<?> clazz) throws InitializationError {
	super(clazz, Collections.<Runner> emptyList());
	dataProvider = getDataProvider();
	dataProvider.setTestClass(getTestClass());
	dataProvider.init();
	FrameworkField dataField = getDataField();
	FrameworkField utilField = getUtilField();
	FrameworkField optionsField = getOptionsField();
	org.eclipse.emf.emfstore.fuzzy.Util util = dataProvider.getUtil();
	for (int i = 0; i < dataProvider.size(); i++) {
		FuzzyTestClassRunner runner = new FuzzyTestClassRunner(clazz,
			dataProvider, dataField, utilField, optionsField, util,
			i + 1);
		if (runner.getChildren().size() > 0) {
			runners.add(runner);
		}
	}
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
private FrameworkField getSingleStaticFrameworkField(
	Class<? extends Annotation> annotation) {
	List<FrameworkField> fields = getTestClass().getAnnotatedFields(
		annotation);

	// Check if there are more than one Data field in the class
	if (fields.size() > 1) {
		throw new RuntimeException("Only one field annotated with "
			+ annotation.getSimpleName() + " permitted: "
			+ getTestClass().getName() + " contains " + fields.size());
	}

	// get the field and check modifiers
	for (FrameworkField field : fields) {
		int modifiers = field.getField().getModifiers();
		if (!Modifier.isStatic(modifiers)) {
			return field;
		}
	}

	return null;
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
public KurentoTestListener(List<FrameworkField> services) {

    this.serviceFields = services;

    for (FrameworkField service : serviceFields) {
      TestService serviceRunner = null;
      try {
        serviceRunner = (TestService) service.getField().get(null);
        if (!serviceRunners.contains(serviceRunner)) {
          serviceRunners.add(serviceRunner);
          if (serviceRunner.getScope() == TESTSUITE) {
            serviceRunner.start();
          }
        }

      } catch (Throwable e) {
        log.warn("Exception instanting service in class {}", serviceRunner, e);
      }
    }

  }
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
private void doInject(TestClass klass, Object instance) {

        try {

            for (FrameworkField frameworkField : klass.getAnnotatedFields(Inject.class)) {
                Field field = frameworkField.getField();
                if ((instance == null && Modifier.isStatic(field.getModifiers()) ||
                        instance != null)) {//we want to do injection even on static fields before test run, so we make sure that client is correct for current state of server
                    field.setAccessible(true);
                    if (field.getType() == ManagementClient.class && controller.isStarted()) {
                        field.set(instance, controller.getClient());
                    } else if (field.getType() == ModelControllerClient.class && controller.isStarted()) {
                        field.set(instance, controller.getClient().getControllerClient());
                    } else if (field.getType() == ServerController.class) {
                        field.set(instance, controller);
                    }
                }
            }

        } catch (Exception e) {
            throw new RuntimeException("Failed to inject", e);
        }
    }
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
private Object createTestUsingFieldInjection() throws Exception {
    List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
    if (annotatedFieldsByParameter.size() != fParameters.length) {
        throw new Exception("Wrong number of parameters and @Parameter fields." +
                " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + fParameters.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, fParameters[index]);
        } catch (IllegalArgumentException iare) {
            throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
                    " with the value " + fParameters[index] +
                    " that is not the right type (" + fParameters[index].getClass().getSimpleName() + " instead of " +
                    field.getType().getSimpleName() + ").", iare);
        }
    }
    return testClassInstance;
}
 

import org.junit.runners.model.FrameworkField; //导入依赖的package包/类
@Override
protected Object createTest() throws Exception {
    if (fieldAnnotated()) {
        Object testInstance = getTestClass().getOnlyConstructor().newInstance();
        List<FrameworkField> configFields = getFieldsAnnotatedByKiWiConfig();
        for (FrameworkField field : configFields) {
            try {
                field.getField().set(testInstance, config);
            } catch (IllegalArgumentException iae) {
                throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() + " that has a wrong type.");
            }
        }
        return testInstance;
    }
    return getTestClass().getOnlyConstructor().newInstance(config);
}