Limit access to junit platform engines

Currently the testruntime is exposed to multiple engines and the check
for compatibility does not work well in the case of JUnit 5/6 on the
classpath.

This now
- limit the dynamic import to a range of the currently only supported
junit 5
- remove the falsely check for compatible engines
- enhance the multi-bundle classloader to not expose META-INF/services/*
from bundles not strictly classloader compatible for the given service
interface

Author: laeubi

ui/org.eclipse.pde.junit.runtime/META-INF/MANIFEST.MF

@@ -12,5 +12,5 @@ Export-Package: org.eclipse.pde.internal.junit.runtime;x-internal:=true
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
 Import-Package: org.eclipse.ui.testing;resolution:=optional
-DynamicImport-Package: org.junit.platform.engine
+DynamicImport-Package: org.junit.platform.engine;version="[1.14.0,2.0.0)"
 Automatic-Module-Name: org.eclipse.pde.junit.runtime

ui/org.eclipse.pde.junit.runtime/src/org/eclipse/pde/internal/junit/runtime/MultiBundleClassLoader.java

@@ -22,13 +22,22 @@
 
 import org.eclipse.core.runtime.FileLocator;
 import org.osgi.framework.Bundle;
+import org.osgi.framework.FrameworkUtil;
 
 class MultiBundleClassLoader extends ClassLoader {
+
+	private static final String META_INF_SERVICES = "META-INF/services/"; //$NON-NLS-1$
 	private final List<Bundle> bundleList;
+	private Bundle runtimeBundle;
 
-	public MultiBundleClassLoader(List<Bundle> platformEngineBundles) {
+	public MultiBundleClassLoader(List<Bundle> platformEngineBundles, Bundle runtimeBundle) {
 		super(null); // never delegate to system classloader, only load classes via given Bundles
 		this.bundleList = platformEngineBundles;
+		if (runtimeBundle == null) {
+			this.runtimeBundle = FrameworkUtil.getBundle(RemotePluginTestRunner.class);
+		} else {
+			this.runtimeBundle = runtimeBundle;
+		}
 	}
 
 	@Override
@@ -63,12 +72,29 @@ protected URL findResource(String name) {
 	@Override
 	protected Enumeration<URL> findResources(String name) throws IOException {
 		List<URL> merged = new ArrayList<>();
+
 		for (Bundle bundle : bundleList) {
-			Enumeration<URL> resources = bundle.getResources(name);
-			while (resources != null && resources.hasMoreElements()) {
-				merged.add(FileLocator.resolve(resources.nextElement()));
+			if (name.startsWith(META_INF_SERVICES)) {
+				String serviceName = name.substring(META_INF_SERVICES.length());
+				if (!isCompatible(bundle, serviceName, runtimeBundle)) {
+					//do not expose SPI services to incompatible bundles!
+					continue;
+
+				}
+				Enumeration<URL> resources = bundle.getResources(name);
+				while (resources != null && resources.hasMoreElements()) {
+					merged.add(FileLocator.resolve(resources.nextElement()));
+				}
 			}
 		}
 		return Collections.enumeration(merged);
 	}
+
+	private static boolean isCompatible(Bundle bundle, String serviceName, Bundle callingBundle) {
+		try {
+			return bundle.loadClass(serviceName) == callingBundle.loadClass(serviceName);
+		} catch (ClassNotFoundException e) {
+			return false;
+		}
+	}
 }

ui/org.eclipse.pde.junit.runtime/src/org/eclipse/pde/internal/junit/runtime/RemotePluginTestRunner.java

@@ -143,35 +143,23 @@ private static ClassLoader createJUnit5PluginClassLoader(String testPluginName)
 		if (junit5RuntimeBundle != null) {
 			platformEngineBundles.add(junit5RuntimeBundle);
 		}
-		return new MultiBundleClassLoader(platformEngineBundles);
+		return new MultiBundleClassLoader(platformEngineBundles, junit5RuntimeBundle);
 	}
 
 	private static List<Bundle> findTestEngineBundles() {
 		BundleContext bundleContext = FrameworkUtil.getBundle(RemotePluginTestRunner.class).getBundleContext();
-		return Arrays.stream(bundleContext.getBundles()).filter(RemotePluginTestRunner::providesCompatibleTestEngine).collect(toCollection(ArrayList::new));
+		return Arrays.stream(bundleContext.getBundles()).filter(RemotePluginTestRunner::providesTestEngine).collect(toCollection(ArrayList::new));
 	}
 
 	/**
 	 * Checks whether the bundle provides test engines.
-	 * Ensures that test engines that can be loaded from the bundle
-	 * are compatible with the TestEngine version in current scope.
-	 * Otherwise, the JUnit platform's call to the ServiceLoader for
-	 * retrieving available engines will fail.
-	 * Incompatibilities can happen, e.g., in Tycho builds, where
-	 * the org.eclipse.tycho.surefire.osgibooter bundle is found
-	 * that may provide a different JUnit platform version than the
-	 * one available via the Eclipse target platform.
 	 */
-	private static boolean providesCompatibleTestEngine(Bundle bundle) {
+	private static boolean providesTestEngine(Bundle bundle) {
 		try {
 			BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
 			String testEngineClass = "org.junit.platform.engine.TestEngine"; //$NON-NLS-1$
 			Collection<String> engineProviders = bundleWiring.listResources("META-INF/services", testEngineClass, BundleWiring.LISTRESOURCES_LOCAL); //$NON-NLS-1$
-			if (!engineProviders.isEmpty()) {
-				Class<?> thisTestEngine = Class.forName(testEngineClass);
-				Class<?> bundleTestEngine = bundle.loadClass(testEngineClass);
-				return thisTestEngine == bundleTestEngine;
-			}
+			return !engineProviders.isEmpty();
 		} catch (Exception e) {
 			// skip this bundle
 		}
@@ -204,7 +192,8 @@ public void init(String[] args) {
 			// during initialization - see bug 520811
 			ClassLoader currentTCCL = Thread.currentThread().getContextClassLoader();
 			try {
-				Thread.currentThread().setContextClassLoader(new MultiBundleClassLoader(findTestEngineBundles()));
+				Bundle junit5RuntimeBundle = Platform.getBundle("org.eclipse.jdt.junit5.runtime"); //$NON-NLS-1$
+				Thread.currentThread().setContextClassLoader(new MultiBundleClassLoader(findTestEngineBundles(), junit5RuntimeBundle));
 				defaultInit(args);
 			} finally {
 				Thread.currentThread().setContextClassLoader(currentTCCL);