Load canonical resources through classloader

junit-platform-commons/src/main/java/org/junit/platform/commons/support/ReflectionSupport.java

@@ -113,6 +113,27 @@ public static Try<Class<?>> tryToLoadClass(String name, ClassLoader classLoader)
 		return ReflectionUtils.tryToLoadClass(name, classLoader);
 	}
 
+	/**
+	 * Tries to load the {@link Resource} for the supplied classpath resource name.
+	 *
+	 * <p>The name of a <em>classpath resource</em> must follow the semantics
+	 * for resource paths as defined in {@link ClassLoader#getResource(String)}.
+	 *
+	 * <p>If the supplied classpath resource name is prefixed with a slash
+	 * ({@code /}), the slash will be removed.
+	 *
+	 * @param classpathResourceName the name of the resource to load; never {@code null} or blank
+	 * @param classLoader the {@code ClassLoader} to use; never {@code null}
+	 * @return a successful {@code Try} containing the loaded class or a failed
+	 * {@code Try} containing the exception if no such resource could be loaded;
+	 * never {@code null}
+	 * @since 1.11
+	 */
+	@API(status = EXPERIMENTAL, since = "1.11")
+	public static Try<Resource> tryToLoadResource(String classpathResourceName, ClassLoader classLoader) {
+		return ReflectionUtils.tryToLoadResource(classpathResourceName, classLoader);
+	}
+
 	/**
 	 * Find all {@linkplain Class classes} in the supplied classpath {@code root}
 	 * that match the specified {@code classFilter} and {@code classNameFilter}

junit-platform-commons/src/main/java/org/junit/platform/commons/util/ClasspathScanner.java

@@ -68,12 +68,15 @@ class ClasspathScanner {
 	private final Supplier<ClassLoader> classLoaderSupplier;
 
 	private final BiFunction<String, ClassLoader, Try<Class<?>>> loadClass;
+	private final BiFunction<String, ClassLoader, Try<Resource>> loadResource;
 
 	ClasspathScanner(Supplier<ClassLoader> classLoaderSupplier,
-			BiFunction<String, ClassLoader, Try<Class<?>>> loadClass) {
+			BiFunction<String, ClassLoader, Try<Class<?>>> loadClass,
+			BiFunction<String, ClassLoader, Try<Resource>> loadResource) {
 
 		this.classLoaderSupplier = classLoaderSupplier;
 		this.loadClass = loadClass;
+		this.loadResource = loadResource;
 	}
 
 	List<Class<?>> scanForClassesInPackage(String basePackageName, ClassFilter classFilter) {
@@ -208,10 +211,17 @@ private void processResourceFileSafely(Path baseDir, String basePackageName, Res
 			String fullyQualifiedResourceName = determineFullyQualifiedResourceName(baseDir, basePackageName,
 				resourceFile);
 			if (resourceFilter.match(fullyQualifiedResourceName)) {
-				Resource resource = new ClasspathResource(fullyQualifiedResourceName, resourceFile.toUri());
-				// Always use "resourceFilter.test" to include future predicates.
-				if (resourceFilter.test(resource)) {
-					resourceConsumer.accept(resource);
+				try {
+					// @formatter:off
+					loadResource.apply(fullyQualifiedResourceName, getClassLoader())
+							.toOptional()
+							// Always use ".filter(classFilter)" to include future predicates.
+							.filter(resourceFilter)
+							.ifPresent(resourceConsumer);
+					// @formatter:on
+				}
+				catch (InternalError internalError) {
+					handleInternalError(resourceFile, fullyQualifiedResourceName, internalError);
 				}
 			}
 		}

junit-platform-commons/src/main/java/org/junit/platform/commons/util/ReflectionUtils.java

@@ -35,6 +35,7 @@
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.net.URI;
+import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -56,6 +57,7 @@
 
 import org.apiguardian.api.API;
 import org.junit.platform.commons.JUnitException;
+import org.junit.platform.commons.PreconditionViolationException;
 import org.junit.platform.commons.function.Try;
 import org.junit.platform.commons.logging.Logger;
 import org.junit.platform.commons.logging.LoggerFactory;
@@ -146,7 +148,7 @@ public enum HierarchyTraversalMode {
 	private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];
 
 	private static final ClasspathScanner classpathScanner = new ClasspathScanner(
-		ClassLoaderUtils::getDefaultClassLoader, ReflectionUtils::tryToLoadClass);
+		ClassLoaderUtils::getDefaultClassLoader, ReflectionUtils::tryToLoadClass, ReflectionUtils::tryToLoadResource);
 
 	/**
 	 * Cache for equivalent methods on an interface implemented by the declaring class.
@@ -890,6 +892,27 @@ public static Try<Class<?>> tryToLoadClass(String name, ClassLoader classLoader)
 		});
 	}
 
+	/**
+	 * Tries to load the {@link Resource} for the supplied classpath resource name.
+	 *
+	 * <p>See {@link org.junit.platform.commons.support.ReflectionSupport#tryToLoadResource(String, ClassLoader)}
+	 * for details.
+	 *
+	 * @param classpathResourceName the name of the resource to load; never {@code null} or blank
+	 * @param classLoader the {@code ClassLoader} to use; never {@code null}
+	 * @since 1.11
+	 */
+	@API(status = INTERNAL, since = "1.11")
+	public static Try<Resource> tryToLoadResource(String classpathResourceName, ClassLoader classLoader) {
+		Preconditions.notBlank(classpathResourceName, "Resource name must not be null or blank");
+		boolean startsWithSlash = classpathResourceName.startsWith("/");
+		URL resource = classLoader.getResource(startsWithSlash ? "/" + classpathResourceName : classpathResourceName);
+		if (resource == null) {
+			return Try.failure(new PreconditionViolationException("classLoader.getResource returned null"));
+		}
+		return Try.call(() -> new ClasspathResource(classpathResourceName, resource.toURI()));
+	}
+
 	private static Class<?> loadArrayType(ClassLoader classLoader, String componentTypeName, int dimensions)
 			throws ClassNotFoundException {
 

platform-tests/src/test/java/org/junit/platform/commons/util/ClasspathScannerTests.java

@@ -63,12 +63,16 @@ class ClasspathScannerTests {
 	private static final ResourceFilter allResources = ResourceFilter.of(type -> true);
 
 	private final List<Class<?>> loadedClasses = new ArrayList<>();
+	private final List<Resource> loadedResources = new ArrayList<>();
 
 	private final BiFunction<String, ClassLoader, Try<Class<?>>> trackingClassLoader = (name,
 			classLoader) -> ReflectionUtils.tryToLoadClass(name, classLoader).ifSuccess(loadedClasses::add);
 
+	private final BiFunction<String, ClassLoader, Try<Resource>> trackingResourceLoader = (name,
+			classLoader) -> ReflectionUtils.tryToLoadResource(name, classLoader).ifSuccess(loadedResources::add);
+
 	private final ClasspathScanner classpathScanner = new ClasspathScanner(ClassLoaderUtils::getDefaultClassLoader,
-		trackingClassLoader);
+		trackingClassLoader, trackingResourceLoader);
 
 	@Test
 	void scanForClassesInClasspathRootWhenMalformedClassnameInternalErrorOccursWithNullDetailedMessage(
@@ -189,7 +193,8 @@ private void scanForClassesInClasspathRootWithinJarFile(String resourceName) thr
 		var jarfile = getClass().getResource(resourceName);
 
 		try (var classLoader = new URLClassLoader(new URL[] { jarfile })) {
-			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass);
+			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass,
+				ReflectionUtils::tryToLoadResource);
 
 			var classes = classpathScanner.scanForClassesInClasspathRoot(jarfile.toURI(), allClasses);
 			assertThat(classes).extracting(Class::getName) //
@@ -213,7 +218,8 @@ private void scanForResourcesInClasspathRootWithinJarFile(String resourceName) t
 		var jarfile = getClass().getResource(resourceName);
 
 		try (var classLoader = new URLClassLoader(new URL[] { jarfile })) {
-			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass);
+			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass,
+				ReflectionUtils::tryToLoadResource);
 
 			var resources = classpathScanner.scanForResourcesInClasspathRoot(jarfile.toURI(), allResources);
 			assertThat(resources).extracting(Resource::getName) //
@@ -270,7 +276,8 @@ private void checkModules2500(ModuleFinder finder) {
 		var parent = ClassLoader.getPlatformClassLoader();
 		var layer = ModuleLayer.defineModulesWithOneLoader(configuration, List.of(boot), parent).layer();
 
-		var classpathScanner = new ClasspathScanner(() -> layer.findLoader(root), ReflectionUtils::tryToLoadClass);
+		var classpathScanner = new ClasspathScanner(() -> layer.findLoader(root), ReflectionUtils::tryToLoadClass,
+			ReflectionUtils::tryToLoadResource);
 		{
 			var classes = classpathScanner.scanForClassesInPackage("foo", allClasses);
 			var classNames = classes.stream().map(Class::getName).collect(Collectors.toList());
@@ -289,7 +296,8 @@ void findAllClassesInPackageWithinJarFileConcurrently() throws Exception {
 		var jarUri = URI.create("jar:" + jarFile);
 
 		try (var classLoader = new URLClassLoader(new URL[] { jarFile })) {
-			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass);
+			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass,
+				ReflectionUtils::tryToLoadResource);
 
 			var results = executeConcurrently(10,
 				() -> classpathScanner.scanForClassesInPackage("org.junit.platform.jartest.included", allClasses));
@@ -314,7 +322,8 @@ void findAllResourcesInPackageWithinJarFileConcurrently() throws Exception {
 		var jarUri = URI.create("jar:" + jarFile);
 
 		try (var classLoader = new URLClassLoader(new URL[] { jarFile })) {
-			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass);
+			var classpathScanner = new ClasspathScanner(() -> classLoader, ReflectionUtils::tryToLoadClass,
+				ReflectionUtils::tryToLoadResource);
 
 			var results = executeConcurrently(10,
 				() -> classpathScanner.scanForResourcesInPackage("org.junit.platform.jartest.included", allResources));
@@ -416,14 +425,16 @@ void scanForClassesInPackageForNullClassFilter() {
 
 	@Test
 	void scanForClassesInPackageWhenIOExceptionOccurs() {
-		var scanner = new ClasspathScanner(ThrowingClassLoader::new, ReflectionUtils::tryToLoadClass);
+		var scanner = new ClasspathScanner(ThrowingClassLoader::new, ReflectionUtils::tryToLoadClass,
+			ReflectionUtils::tryToLoadResource);
 		var classes = scanner.scanForClassesInPackage("org.junit.platform.commons", allClasses);
 		assertThat(classes).isEmpty();
 	}
 
 	@Test
 	void scanForResourcesInPackageWhenIOExceptionOccurs() {
-		var scanner = new ClasspathScanner(ThrowingClassLoader::new, ReflectionUtils::tryToLoadClass);
+		var scanner = new ClasspathScanner(ThrowingClassLoader::new, ReflectionUtils::tryToLoadClass,
+			ReflectionUtils::tryToLoadResource);
 		var classes = scanner.scanForResourcesInPackage("org.junit.platform.commons", allResources);
 		assertThat(classes).isEmpty();
 	}
@@ -438,6 +449,17 @@ void scanForClassesInPackageOnlyLoadsClassesThatAreIncludedByTheClassNameFilter(
 		assertThat(loadedClasses).containsExactly(ClasspathScannerTests.class);
 	}
 
+	@Test
+	void scanForResourcesInPackageOnlyLoadsResourcesThatAreIncludedByTheResourceNameFilter() {
+		Predicate<String> resourceNameFilter = name -> name.endsWith("/example.resource");
+		var resourceFilter = ResourceFilter.of(resourceNameFilter, type -> true);
+
+		classpathScanner.scanForResourcesInPackage("org.junit.platform.commons", resourceFilter);
+
+		assertThat(loadedResources).extracting(Resource::getName).containsExactly(
+			"org/junit/platform/commons/example.resource");
+	}
+
 	@Test
 	void findAllClassesInClasspathRoot() throws Exception {
 		var thisClassOnly = ClassFilter.of(clazz -> clazz == ClasspathScannerTests.class);
@@ -519,6 +541,18 @@ void onlyLoadsClassesInClasspathRootThatAreIncludedByTheClassNameFilter() throws
 		assertThat(loadedClasses).containsExactly(ClasspathScannerTests.class);
 	}
 
+	@Test
+	void onlyLoadsResourcesInClasspathRootThatAreIncludedByTheResourceNameFilter() {
+		Predicate<String> resourceNameFilter = name -> name.endsWith("/example.resource");
+		var resourceFilter = ResourceFilter.of(resourceNameFilter, type -> true);
+		var root = getTestClasspathResourceRoot();
+
+		classpathScanner.scanForResourcesInClasspathRoot(root, resourceFilter);
+
+		assertThat(loadedResources).extracting(Resource::getName).containsExactly(
+			"org/junit/platform/commons/example.resource");
+	}
+
 	private static URI uriOf(String name) {
 		var resource = ClasspathScannerTests.class.getResource(name);
 		try {