testing JUnit 5 equivalent of XpectRunner

org.eclipse.xpect/src/org/eclipse/xpect/dynamic/IXpectDynamicTestFactory.java

@@ -0,0 +1,18 @@
+package org.eclipse.xpect.dynamic;
+
+import java.util.stream.Stream;
+
+import org.eclipse.xpect.XpectImport;
+import org.eclipse.xpect.runner.TestTitleProvider;
+import org.junit.jupiter.api.DynamicContainer;
+import org.junit.jupiter.api.TestFactory;
+
+@XpectImport(TestTitleProvider.class)
+public interface IXpectDynamicTestFactory {
+
+	@TestFactory
+	default Stream<DynamicContainer> generateTests() {
+		return XpectDynamicTestFactory.xpectTests(getClass());
+	}
+}
+

org.eclipse.xpect/src/org/eclipse/xpect/dynamic/XpectDynamicTest.java

@@ -0,0 +1,81 @@
+package org.eclipse.xpect.dynamic;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.eclipse.xpect.XjmTestMethod;
+import org.eclipse.xpect.runner.ValidatingSetup;
+import org.eclipse.xpect.runner.XpectTestGlobalState;
+import org.eclipse.xpect.setup.ThisTestObject;
+import org.eclipse.xpect.state.Creates;
+import org.eclipse.xpect.state.StateContainer;
+import org.junit.jupiter.api.DynamicTest;
+
+import com.google.common.base.Preconditions;
+
+public class XpectDynamicTest {
+
+	private final String className;
+	private XjmTestMethod method;
+	private final StateContainer state;
+
+	public XpectDynamicTest(StateContainer state, XjmTestMethod method) {
+		Preconditions.checkNotNull(method);
+		this.className = XpectTestGlobalState.INSTANCE.testClass().getName();
+		this.method = method;
+		this.state = state;
+	}
+
+	@Creates
+	public XpectDynamicTest create() {
+		return this;
+	}
+
+	public XjmTestMethod getMethod() {
+		return method;
+	}
+
+	public StateContainer getState() {
+		return state;
+	}
+
+	public DynamicTest test() {
+		String testName = getName();
+		return DynamicTest.dynamicTest(testName, () -> {
+			state.get(ValidatingSetup.class).get().validate();
+			try {
+				runInternal();
+			} finally {
+				state.invalidate();
+			}
+		});
+	}
+
+	public String getName() {
+		String testName = formatDisplayName(method.getName(), className);
+		return testName;
+	}
+
+	protected void runInternal() throws Throwable {
+		Object test = state.get(Object.class, ThisTestObject.class).get();
+		// Object test = method.getTest().getJavaClass().newInstance();
+		// ctx.setMethod(method);
+		// ctx.setTestInstance(test);
+		try {
+			// if (setup != null)
+			// ctx.setUserTestCtx(setup.beforeTest(ctx, ctx.getUserFileCtx()));
+			method.getJavaMethod().invoke(test);
+		} catch (InvocationTargetException e) {
+			throw e.getCause();
+		}
+		// finally {
+		// if (setup != null)
+		// setup.afterTest(ctx, ctx.getUserTestCtx());
+		// }
+	}
+
+	private static String formatDisplayName(String name, String className) {
+		return String.format("%s(%s)", name, className);
+	}
+
+}
+

org.eclipse.xpect/src/org/eclipse/xpect/dynamic/XpectDynamicTestCase.java

@@ -0,0 +1,120 @@
+package org.eclipse.xpect.dynamic;
+
+import static org.eclipse.xpect.runner.DescriptionFactory.*;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xpect.XjmMethod;
+import org.eclipse.xpect.XjmTestMethod;
+import org.eclipse.xpect.XpectFile;
+import org.eclipse.xpect.XpectInvocation;
+import org.eclipse.xpect.XpectJavaModel;
+import org.eclipse.xpect.runner.IXpectURIProvider;
+import org.eclipse.xpect.runner.TestExecutor;
+import org.eclipse.xpect.runner.TestRunner;
+import org.eclipse.xpect.runner.ValidatingSetup;
+import org.eclipse.xpect.runner.XpectTestRunner;
+import org.eclipse.xpect.setup.ThisRootTestClass;
+import org.eclipse.xpect.state.Creates;
+import org.eclipse.xpect.state.StateContainer;
+import org.junit.jupiter.api.DynamicContainer;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+
+import com.google.common.collect.Lists;
+
+public class XpectDynamicTestCase {
+	private List<DynamicContainer> children;
+	private Description description;
+	private final StateContainer state;
+	private final XpectFile xpectFile;
+
+	public XpectDynamicTestCase(StateContainer state, XpectFile file) {
+		this.xpectFile = file;
+		this.state = state;
+	}
+
+	@Creates
+	public XpectDynamicTestCase create() {
+		return this;
+	}
+
+	public DynamicContainer dynamicContainer() {
+		return DynamicContainer.dynamicContainer(getName(), getChildren().stream());
+	}
+
+	protected List<DynamicContainer> createChildren() {
+		List<DynamicContainer> children = Lists.newArrayList();
+		if (xpectFile != null) {
+			XpectJavaModel xjm = xpectFile.getJavaModel();
+			for (XjmMethod method : xjm.getMethods().values())
+				if (method instanceof XjmTestMethod) {
+					XpectDynamicTest test = createDynamicTest((XjmTestMethod) method);
+					if (test != null)
+						children.add(DynamicContainer.dynamicContainer(test.getName(), Arrays.asList(test.test())));
+				}
+			for (XpectInvocation inv : xpectFile.getInvocations()) {
+				DynamicContainer test = createDynamicTest(inv);
+				if (test != null)
+					children.add(test);
+			}
+		}
+		return children;
+	}
+
+	protected XpectDynamicTest createDynamicTest(XjmTestMethod method) {
+		StateContainer childState = TestExecutor.createState(state, TestExecutor.createTestConfiguration(method));
+		return childState.get(XpectDynamicTest.class).get();
+	}
+
+	protected DynamicContainer createDynamicTest(XpectInvocation invocation) {
+		StateContainer childState = TestExecutor.createState(state, TestExecutor.createXpectConfiguration(invocation));
+		List<DynamicTest> tests = Arrays.asList(childState.get(XpectInvocationDynamicTest.class).get().test());
+		String testClassName = getJavaTestClass().getName();
+		IXpectURIProvider uriProvider = getURIProvider();
+		String testName = XpectInvocationDynamicTest.getTestNameForInvocation(uriProvider, testClassName, invocation);
+		return DynamicContainer.dynamicContainer(testName, tests);
+	}
+
+	protected List<DynamicContainer> getChildren() {
+		if (children == null)
+			children = createChildren();
+		return children;
+	}
+
+	public Class<?> getJavaTestClass() {
+		return state.get(Class.class, ThisRootTestClass.class).get();
+	}
+
+	public IXpectURIProvider getURIProvider() {
+		return state.get(IXpectURIProvider.class).get();
+	}
+
+	public StateContainer getState() {
+		return state;
+	}
+
+	public URI getUri() {
+		return xpectFile.eResource().getURI();
+	}
+
+	public XpectFile getXpectFile() {
+		return xpectFile;
+	}
+
+	public String getName() {
+		IXpectURIProvider uriProvider = getURIProvider();
+		URI uri = getUri();
+		URI deresolved = uriProvider.deresolveToProject(uri);
+		String pathInProject = deresolved.trimSegments(1).toString();
+		String fileName = deresolved.lastSegment();
+		return fileName + ": " + pathInProject;
+	}
+}
+