Remove ClassLoader parameter from canConvert

Author: scordio

junit-platform-commons/src/main/java/org/junit/platform/commons/support/conversion/ConversionSupport.java

@@ -82,7 +82,7 @@ public static <T> T convert(Object source, TypeDescriptor targetType, ClassLoade
 		Converter converter = Stream.concat( //
 			StreamSupport.stream(serviceLoader.spliterator(), false), //
 			Stream.of(DefaultConverter.INSTANCE)) //
-				.filter(candidate -> candidate.canConvert(source, targetType, classLoader)) //
+				.filter(candidate -> candidate.canConvert(source, targetType)) //
 				.findFirst() //
 				.orElseThrow(() -> new ConversionException("No registered or built-in converter for source '" + source
 						+ "' and target type " + targetType.getType().getTypeName()));

junit-platform-commons/src/main/java/org/junit/platform/commons/support/conversion/Converter.java

@@ -43,15 +43,17 @@ public interface Converter {
 	 * if the target type is a reference type
 	 * @param targetType the descriptor of the type the source should be converted into;
 	 * never {@code null}
-	 * @param classLoader the {@code ClassLoader} to use; never {@code null}
 	 * @return {@code true} if the supplied source can be converted
 	 */
-	boolean canConvert(Object source, TypeDescriptor targetType, ClassLoader classLoader);
+	boolean canConvert(Object source, TypeDescriptor targetType);
 
 	/**
 	 * Convert the supplied source object into an instance of the specified
 	 * target type.
 	 *
+	 * <p>This method will only be invoked if {@link #canConvert(Object, TypeDescriptor)}
+	 * returned {@code true} for the same target type.
+	 *
 	 * @param source the source object to convert; may be {@code null} but only
 	 * if the target type is a reference type
 	 * @param targetType the descriptor of the type the source should be converted into;

junit-platform-commons/src/main/java/org/junit/platform/commons/support/conversion/DefaultConverter.java

@@ -73,11 +73,10 @@ private DefaultConverter() {
 	 * if the target type is a reference type
 	 * @param targetType the target type the source should be converted into;
 	 * never {@code null}
-	 * @param classLoader the {@code ClassLoader} to use; never {@code null}
 	 * @return {@code true} if the supplied source can be converted
 	 */
 	@Override
-	public boolean canConvert(Object source, TypeDescriptor targetType, ClassLoader classLoader) {
+	public boolean canConvert(Object source, TypeDescriptor targetType) {
 		if (source == null) {
 			return !targetType.isPrimitive();
 		}

junit-platform-commons/src/main/java/org/junit/platform/commons/support/conversion/TypedConverter.java

@@ -44,7 +44,7 @@ protected TypedConverter(Class<S> sourceType, Class<T> targetType) {
 	}
 
 	@Override
-	public final boolean canConvert(Object source, TypeDescriptor targetType, ClassLoader classLoader) {
+	public final boolean canConvert(Object source, TypeDescriptor targetType) {
 		return this.sourceType.isInstance(source)
 				&& ReflectionUtils.isAssignableTo(this.targetType, targetType.getType());
 	}

platform-tests/src/test/java/org/junit/platform/commons/support/conversion/DefaultConverterTests.java

@@ -252,10 +252,9 @@ void convertsStringToClassWithCustomTypeFromDifferentClassLoader() throws Except
 			assertThat(declaringExecutable.getDeclaringClass().getClassLoader()).isSameAs(testClassLoader);
 
 			var typeDescriptor = TypeDescriptor.forType(Class.class);
-			var classLoader = classLoader(declaringExecutable);
-			assertThat(canConvert(customTypeName, typeDescriptor, classLoader)).isTrue();
+			assertThat(canConvert(customTypeName, typeDescriptor)).isTrue();
 
-			var clazz = (Class<?>) convert(customTypeName, typeDescriptor, classLoader);
+			var clazz = (Class<?>) convert(customTypeName, typeDescriptor, classLoader(declaringExecutable));
 			assertThat(clazz).isNotEqualTo(Enigma.class);
 			assertThat(clazz).isEqualTo(customType);
 			assertThat(clazz.getClassLoader()).isSameAs(testClassLoader);
@@ -345,17 +344,13 @@ private void assertConverts(Object input, Class<?> targetClass, Object expectedO
 	}
 
 	private boolean canConvert(Object input, TypeDescriptor targetClass) {
-		return canConvert(input, targetClass, classLoader());
+		return DefaultConverter.INSTANCE.canConvert(input, targetClass);
 	}
 
 	private Object convert(Object input, TypeDescriptor targetClass) {
 		return convert(input, targetClass, classLoader());
 	}
 
-	private boolean canConvert(Object input, TypeDescriptor targetClass, ClassLoader classLoader) {
-		return DefaultConverter.INSTANCE.canConvert(input, targetClass, classLoader);
-	}
-
 	private Object convert(Object input, TypeDescriptor targetClass, ClassLoader classLoader) {
 		return DefaultConverter.INSTANCE.convert(input, targetClass, classLoader);
 	}