Java ExtensionContext类代码示例

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
/**
 * Handle the supplied {@code Throwable throwable}. If the {@code extensionContext} is annotated
 * with {@link ExpectedException} and if the {@code throwable} matches the expectations expressed
 * in the {@link ExpectedException} annotation then the supplied {@code throwable} is swallowed
 * otherwise the supplied {@code throwable} is rethrown.
 *
 * @param extensionContext the current extension context
 * @param throwable the {@code Throwable} to handle
 * @throws Throwable
 */
@Override
public void handleTestExecutionException(ExtensionContext extensionContext, Throwable throwable)
    throws Throwable {
  Optional<ExpectedException> optional =
      findAnnotation(extensionContext.getTestMethod(), ExpectedException.class);
  if (optional.isPresent()) {
    ExpectedException annotation = optional.get();
    if (throwable.getClass() == annotation.type()) {
      if (where(function, getPredicate(annotation)).test(throwable)) {
        return;
      }
    }
  }
  throw throwable;
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
public static IInjectorProvider getOrCreateInjectorProvider(ExtensionContext context) {
	InjectWith injectWith = context.getRequiredTestClass().getAnnotation(InjectWith.class);
	if (injectWith != null) {
		Class<? extends IInjectorProvider> klass = injectWith.value();
		IInjectorProvider injectorProvider = injectorProviderClassCache.get(klass);
		if (injectorProvider == null) {
			try {
				injectorProvider = klass.newInstance();
				injectorProviderClassCache.put(klass, injectorProvider);
			} catch (Exception e) {
				throwUncheckedException(e);
			}
		}
		return injectorProvider;
	}
	return null;
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public Object resolveParameter(ParameterContext parameterContext,
    ExtensionContext extensionContext)
    throws ParameterResolutionException {
  List<ParameterFactory> validFactories =
      getSupportedFactories(parameterContext.getParameter()).collect(toList());

  if (validFactories.size() > 1) {
    throw new ParameterResolutionException(
        String.format("Too many factories: %s for parameter: %s",
            validFactories,
            parameterContext.getParameter()));
  }

  return Iterables.getOnlyElement(validFactories)
      .getParameterValue(parameterContext.getParameter());
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void handleTestExecutionException(ExtensionContext context, Throwable throwable)
    throws Throwable {
  Optional<ExpectFailure> annotation = getAnnotation(context);

  if (!annotation.isPresent()) {
    throw throwable;
  }

  ExpectFailure expectedFailure = annotation.get();
  context.getStore(NAMESPACE).put(expectedFailure, throwable);

  ThrowableSubject subject = assertThat(throwable);
  for (Cause cause : expectedFailure.value()) {
    subject.isInstanceOf(cause.type());
    if (!cause.message().isEmpty()) {
      subject.hasMessageThat().contains(cause.message());
    }
    subject = subject.hasCauseThat();
  }
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
/**
 * Returns module types that are present on the given context or any of its enclosing contexts.
 */
private static Set<Class<? extends Module>> getContextModuleTypes(
    Optional<ExtensionContext> context) {
  // TODO: Cache?

  Set<Class<? extends Module>> contextModuleTypes = new LinkedHashSet<>();
  while (context.isPresent() && (hasAnnotatedElement(context) || hasParent(context))) {
    context
        .flatMap(ExtensionContext::getElement)
        .map(GuiceExtension::getModuleTypes)
        .ifPresent(contextModuleTypes::addAll);
    context = context.flatMap(ExtensionContext::getParent);
  }

  return contextModuleTypes;
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void beforeAll(ExtensionContext context) throws Exception {
	Optional<String> baseUri = getProperty(BASE_URI_PROPERTY);
	Optional<String> port = getProperty(DEPLOY_PORT_PROPERTY);

	RestAssured.port = Integer.parseInt(port.orElse("8080"));
	RestAssured.baseURI = baseUri.map(host -> "http://" + host).orElse(RestAssured.DEFAULT_URI);
	RestAssured.rootPath = ROOT_PATH;

	waitForIt(baseUri.orElse("localhost"), RestAssured.port);
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void afterTestExecution(ExtensionContext context) throws Exception {
	IInjectorProvider injectorProvider = getOrCreateInjectorProvider(context);
	if (injectorProvider instanceof IRegistryConfigurator) {
		final IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) injectorProvider;
		registryConfigurator.restoreRegistry();
	}
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public Stream<? extends Arguments> provideArguments(
        ExtensionContext context) {

    System.out.println("Arguments provider [2] to test "
            + context.getTestMethod().get().getName());

    return Stream.of(Arguments.of("more", 3), Arguments.of("arguments", 4));
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
private Object getMock(Parameter parameter,
        ExtensionContext extensionContext) {
    Class<?> mockType = parameter.getType();
    Store mocks = extensionContext
            .getStore(Namespace.create(MockitoExtension.class, mockType));
    String mockName = getMockName(parameter);

    if (mockName != null) {
        return mocks.getOrComputeIfAbsent(mockName,
                key -> mock(mockType, mockName));
    } else {
        return mocks.getOrComputeIfAbsent(mockType.getCanonicalName(),
                key -> mock(mockType));
    }
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void handleTestExecutionException(ExtensionContext context,
        Throwable throwable) throws Throwable {

    if (throwable instanceof IOException) {
        return;
    }
    throw throwable;
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
private Optional<Field> getTestNameField(ExtensionContext extensionContext) {
  for (Field field : extensionContext.getRequiredTestClass().getDeclaredFields()) {
    if (isAnnotated(field, TestName.class)) {
      return Optional.of(field);
    }
  }
  return Optional.empty();
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void afterAll(final ExtensionContext context) throws Exception {
    final TestSetup testSetup = (TestSetup) context.getStore(NS).get(TestSetup.class);
    if (testSetup != null) {
        testSetup.shutdown();
    }

}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void beforeTestExecution(ExtensionContext context) throws Exception {
	IInjectorProvider injectorProvider = getOrCreateInjectorProvider(context);
	if (injectorProvider instanceof IRegistryConfigurator) {
		final IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) injectorProvider;
		registryConfigurator.setupRegistry();
	}
	if (injectorProvider != null) {
		Injector injector = injectorProvider.getInjector();
		if (injector != null)
			injector.injectMembers(context.getRequiredTestInstance());
	}
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
@Override
public void beforeAll(ExtensionContext context) throws Exception {
    if (!STARTED) {
        out.println("Starting JavaFX");
        Platform.startup(() -> {});
        STARTED = true;
    }
}
 

import org.junit.jupiter.api.extension.ExtensionContext; //导入依赖的package包/类
private Object getMock(Parameter parameter, ExtensionContext extensionContext) {
	Class<?> mockType = parameter.getType();
	Store mocks = extensionContext.getStore(Namespace.create(MockitoExtension.class, mockType));
	String mockName = getMockName(parameter);

	if (mockName != null) {
		return mocks.getOrComputeIfAbsent(mockName, key -> mock(mockType, mockName));
	}
	return mocks.getOrComputeIfAbsent(mockType.getCanonicalName(), key -> mock(mockType));
}