org.eclipse.xtext.testing.IInjectorProvider Java Examples

/**
 * Implements behavior from: org.junit.runners.Parameterized$TestClassRunnerForParameters
 * org.eclipse.xtext.testing.XtextRunner
 */
@Override
public Object createTest() throws Exception {
	Object object;
	// Functionality of
	// org.junit.runners.Parameterized$TestClassRunnerForParameters
	if (fieldsAreAnnotated()) {
		object = createTestUsingFieldInjection();
	} else {
		object = createTestUsingConstructorInjection();
	}

	// Functionality of org.eclipse.xtext.testing.XtextRunner
	IInjectorProvider injectorProvider = getOrCreateInjectorProvider();
	if (injectorProvider != null) {
		Injector injector = injectorProvider.getInjector();
		if (injector != null)
			injector.injectMembers(object);
	}
	return object;
}
 

protected void process(String data) throws Exception {
	IInjectorProvider delegate = getOrCreateInjectorProvider().getDelegate();
	if (delegate instanceof IRegistryConfigurator) {
		IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) delegate;
		registryConfigurator.setupRegistry();
		try {
			ScenarioProcessor processor = delegate.getInjector().getInstance(processorClass);
			String preProcessed = processor.preProcess(data);
			if (preProcessed == null) {
				throw new AssumptionViolatedException("Input is filtered by the pre processing step: " + data);
			}
			doProcess(preProcessed, processor);
		} finally {
			registryConfigurator.restoreRegistry();
		}
	}
}
 

private static IInjectorProvider getOrCreateInjectorProvider(ExtensionContext context) {
	InjectWith injectWith = getInjectWith(context.getRequiredTestClass());
	if (injectWith != null) {
		Class<? extends IInjectorProvider> klass = injectWith.value();
		IInjectorProvider injectorProvider = injectorProviderClassCache.get(klass);
		if (injectorProvider == null) {
			try {
				injectorProvider = klass.getDeclaredConstructor().newInstance();
				injectorProviderClassCache.put(klass, injectorProvider);
			} catch (Exception e) {
				throwUncheckedException(e);
			}
		}
		return injectorProvider;
	}
	return null;
}
 

public static IInjectorProvider getOrCreateInjectorProvider(TestClass testClass) {
	InjectWith injectWith = testClass.getJavaClass().getAnnotation(InjectWith.class);
	if (injectWith != null) {
		Class<? extends IInjectorProvider> klass = injectWith.value();
		IInjectorProvider injectorProvider = injectorProviderClassCache.get(klass);
		if (injectorProvider == null) {
			try {
				injectorProvider = klass.getDeclaredConstructor().newInstance();
				injectorProviderClassCache.put(klass, injectorProvider);
			} catch (Exception e) {
				throwUncheckedException(e);
			}
		}
		return injectorProvider;
	}
	return null;
}
 

private static IInjectorProvider createInjectorProvider(ExtensionContext context) {
	InjectWith injectWith = context.getRequiredTestClass().getAnnotation(InjectWith.class);
	if (injectWith != null) {
		Class<? extends IInjectorProvider> klass = injectWith.value();
		try {
			// TODO this mode of creation is not efficient, but it ensures that the injector providers are really reset.
			final IInjectorProvider injectorProvider = klass.getDeclaredConstructor().newInstance();
			if (injectorProvider instanceof IRegistryConfigurator) {
				final IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) injectorProvider;
				registryConfigurator.setupRegistry();
			}
			return injectorProvider;
		} catch (Exception e) {
			throwUncheckedException(e);
		}
	}
	throw new IllegalStateException("Expected valid @InjectWith annotation");
}
 

@Override
protected Object createTest() throws Exception {
	Object object = getTestClass().getOnlyConstructor().newInstance(parameters.toArray());
	IInjectorProvider injectorProvider = getOrCreateInjectorProvider();
	if (injectorProvider != null) {
		Injector injector = injectorProvider.getInjector();
		if (injector != null)
			injector.injectMembers(object);
	}
	return object;
}
 

@Override
protected Statement childrenInvoker(final RunNotifier notifier) {
	return new Statement() {
		@Override
		public void evaluate() throws Throwable {
			WrappingInjectorProvider wrapped = getOrCreateInjectorProvider();
			wrapped.setupRegistry();
			try {
				prepareChildren(notifier);
			} finally {
				wrapped.restoreRegistry();
			}
			IInjectorProvider delegate = wrapped.getDelegate();
			if (delegate instanceof IRegistryConfigurator) {
				IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) delegate;
				registryConfigurator.setupRegistry();
				try {
					runChildren(notifier);
				} finally {
					registryConfigurator.restoreRegistry();
				}
			} else {
				runChildren(notifier);
			}
		}
	};
}
 

@Override
protected void process(String data) throws Exception {
	IInjectorProvider delegate = getOrCreateInjectorProvider().getDelegate();
	ScenarioProcessor processor = delegate.getInjector().getInstance(getProcessorClass());
	String preProcessed = processor.preProcess(data);
	if (preProcessed == null) {
		throw new AssumptionViolatedException("Input is filtered by the pre processing step: " + data);
	}
	doProcess(preProcessed, processor);
}
 

public WrappingInjectorProvider(IInjectorProvider delegate) {
	this.delegate = delegate;
	stateBeforeInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
	this.injector = createInjector();
	if (delegate instanceof IRegistryConfigurator) {
		((IRegistryConfigurator) delegate).setupRegistry();
	}
	registerFactory(injector);
	stateAfterInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
	if (delegate instanceof IRegistryConfigurator) {
		((IRegistryConfigurator) delegate).restoreRegistry();
	}
	stateBeforeInjectorCreation.restoreGlobalState();
}
 

public static WrappingInjectorProvider wrap(IInjectorProvider delegate) {
	WrappingInjectorProvider result = cachedInjectors.get(delegate);
	if (result == null) {
		result = new WrappingInjectorProvider(delegate);
		cachedInjectors.put(delegate, result);
	}
	return result;
}
 

@Override
public void beforeEach(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) {
			Object testInstance = context.getRequiredTestInstance();
			injector.injectMembers(testInstance);
			try {
				TestInstances requiredTestInstances = context.getRequiredTestInstances();
				for (Object o : requiredTestInstances.getEnclosingInstances()) {
					injector.injectMembers(o);
				}
			} catch (NoSuchMethodError e) {
				if (!Modifier.isStatic(testInstance.getClass().getModifiers())) {
					if (testInstance.getClass().getDeclaringClass() != null) {
						throw new ExtensionConfigurationException("Injection of nested classes needs Junit5 >= 5.4", e);
					}
				}
				// OK, getRequiredTestInstances is not there in Junit5 < 5.4
			}
		}
	}
}
 

@Override
public void afterEach(ExtensionContext context) throws Exception {
	IInjectorProvider injectorProvider = getOrCreateInjectorProvider(context);
	if (injectorProvider instanceof IRegistryConfigurator) {
		final IRegistryConfigurator registryConfigurator = (IRegistryConfigurator) injectorProvider;
		registryConfigurator.restoreRegistry();
	}
}
 

public static IInjectorProvider getInjectorProvider(TestClass testClass) {
	InjectWith injectWith = testClass.getJavaClass().getAnnotation(InjectWith.class);
	if (injectWith != null) {
		return injectorProviderClassCache.get(injectWith.value());
	}
	return null;
}
 

public static IInjectorProvider createInjectorProvider(TestClass testClass) {
	InjectWith injectWith = testClass.getJavaClass().getAnnotation(InjectWith.class);
	if (injectWith != null) {
		try {
			return injectWith.value().getDeclaredConstructor().newInstance();
		} catch (Exception e) {
			throwUncheckedException(e);
		}
	}
	return null;
}
 

/** Create the injector and inject the given instance.
 *
 * @param instance the instance to inject
 */
public void injectMembers(Object instance, ExtensionContext context) throws Exception {
	IInjectorProvider injectorProvider = createInjectorProvider(context);
	if (injectorProvider != null) {
		Injector injector = injectorProvider.getInjector();
		if (injector != null)
			injector.injectMembers(instance);
	}
}
 

public IInjectorProvider getDelegate() {
	return delegate;
}