Add sourceType to canConvert and convert

Author: scordio

junit-jupiter-params/src/main/java/org/junit/jupiter/params/aggregator/DefaultArgumentsAccessor.java

@@ -47,7 +47,7 @@ public static DefaultArgumentsAccessor create(ExtensionContext context, int invo
 		Preconditions.notNull(classLoader, "ClassLoader must not be null");
 
 		BiFunction<Object, Class<?>, Object> converter = (source, targetType) -> new DefaultArgumentConverter(context) //
-				.convert(source, TypeDescriptor.forType(targetType), classLoader);
+				.convert(source, TypeDescriptor.forClass(targetType), classLoader);
 		return new DefaultArgumentsAccessor(converter, invocationIndex, arguments);
 	}
 

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

@@ -54,7 +54,7 @@ private ConversionSupport() {
 	@Deprecated
 	@API(status = DEPRECATED, since = "5.13")
 	public static <T> T convert(String source, Class<T> targetType, ClassLoader classLoader) {
-		return convert(source, TypeDescriptor.forType(targetType), getClassLoader(classLoader));
+		return convert(source, TypeDescriptor.forClass(targetType), getClassLoader(classLoader));
 	}
 
 	/**
@@ -76,18 +76,19 @@ public static <T> T convert(String source, Class<T> targetType, ClassLoader clas
 	@API(status = EXPERIMENTAL, since = "1.13")
 	@SuppressWarnings("unchecked")
 	public static <T> T convert(Object source, TypeDescriptor targetType, ClassLoader classLoader) {
+		TypeDescriptor sourceType = TypeDescriptor.forInstance(source);
 		ClassLoader classLoaderToUse = getClassLoader(classLoader);
 		ServiceLoader<Converter> serviceLoader = ServiceLoader.load(Converter.class, classLoaderToUse);
 
 		Converter converter = Stream.concat( //
 			StreamSupport.stream(serviceLoader.spliterator(), false), //
 			Stream.of(DefaultConverter.INSTANCE)) //
-				.filter(candidate -> candidate.canConvert(source, targetType)) //
+				.filter(candidate -> candidate.canConvert(source, sourceType, targetType)) //
 				.findFirst() //
 				.orElseThrow(() -> new ConversionException("No registered or built-in converter for source '" + source
 						+ "' and target type " + targetType.getType().getTypeName()));
 
-		return (T) converter.convert(source, targetType, classLoaderToUse);
+		return (T) converter.convert(source, sourceType, targetType, classLoaderToUse);
 	}
 
 	private static ClassLoader getClassLoader(ClassLoader classLoader) {

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

@@ -41,28 +41,30 @@ public interface Converter {
 	 *
 	 * @param source the source object to convert; may be {@code null} but only
 	 * if the target type is a reference type
+	 * @param sourceType the descriptor of the source type; never {@code null}
 	 * @param targetType the descriptor of the type the source should be converted into;
 	 * never {@code null}
 	 * @return {@code true} if the supplied source can be converted
 	 */
-	boolean canConvert(Object source, TypeDescriptor targetType);
+	boolean canConvert(Object source, TypeDescriptor sourceType, 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)}
+	 * <p>This method will only be invoked if {@link #canConvert(Object, TypeDescriptor, 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 sourceType the descriptor of the source type; never {@code null}
 	 * @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 the converted object; may be {@code null} but only if the target
 	 * type is a reference type
 	 * @throws ConversionException if an error occurs during the conversion
 	 */
-	Object convert(Object source, TypeDescriptor targetType, ClassLoader classLoader) throws ConversionException;
+	Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType, ClassLoader classLoader)
+			throws ConversionException;
 
 }

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

@@ -70,12 +70,13 @@ private DefaultConverter() {
 	 *
 	 * @param source the source object to convert; may be {@code null} but only
 	 * if the target type is a reference type
+	 * @param sourceType the descriptor of the source type; never {@code null}
 	 * @param targetType the target type the source should be converted into;
 	 * never {@code null}
 	 * @return {@code true} if the supplied source can be converted
 	 */
 	@Override
-	public boolean canConvert(Object source, TypeDescriptor targetType) {
+	public boolean canConvert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
 		if (source == null) {
 			return !targetType.isPrimitive();
 		}
@@ -95,14 +96,11 @@ public boolean canConvert(Object source, TypeDescriptor targetType) {
 	/**
 	 * Convert the supplied source object into an instance of the specified
 	 * target type.
-	 *
 	 * <p>If the target type is {@code String}, the source {@code String} will not
 	 * be modified.
-	 *
 	 * <p>Some forms of conversion require a {@link ClassLoader}. If none is
 	 * provided, the {@linkplain ClassLoaderUtils#getDefaultClassLoader() default
 	 * ClassLoader} will be used.
-	 *
 	 * <p>This method is able to convert strings into primitive types and their
 	 * corresponding wrapper types ({@link Boolean}, {@link Character}, {@link Byte},
 	 * {@link Short}, {@link Integer}, {@link Long}, {@link Float}, and
@@ -112,29 +110,26 @@ public boolean canConvert(Object source, TypeDescriptor targetType) {
 	 * {@link java.math.BigDecimal}, {@link java.math.BigInteger},
 	 * {@link java.util.Currency}, {@link java.util.Locale}, {@link java.util.UUID},
 	 * {@link java.net.URI}, and {@link java.net.URL}.
-	 *
 	 * <p>If the target type is not covered by any of the above, a convention-based
 	 * conversion strategy will be used to convert the source {@code String} into the
 	 * given target type by invoking a static factory method or factory constructor
 	 * defined in the target type. The search algorithm used in this strategy is
 	 * outlined below.
-	 *
 	 * <h4>Search Algorithm</h4>
-	 *
 	 * <ol>
 	 * <li>Search for a single, non-private static factory method in the target
 	 * type that converts from a String to the target type. Use the factory method
 	 * if present.</li>
 	 * <li>Search for a single, non-private constructor in the target type that
 	 * accepts a String. Use the constructor if present.</li>
 	 * </ol>
-	 *
 	 * <p>If multiple suitable factory methods are discovered, they will be ignored.
 	 * If neither a single factory method nor a single constructor is found, the
 	 * convention-based conversion strategy will not apply.
 	 *
 	 * @param source the source object to convert; may be {@code null} but only
 	 * if the target type is a reference type
+	 * @param sourceType the descriptor of the source type; never {@code null}
 	 * @param targetType the target type the source should be converted into;
 	 * never {@code null}
 	 * @param classLoader the {@code ClassLoader} to use; never {@code null}
@@ -143,7 +138,8 @@ public boolean canConvert(Object source, TypeDescriptor targetType) {
 	 * @throws ConversionException if an error occurs during the conversion
 	 */
 	@Override
-	public Object convert(Object source, TypeDescriptor targetType, ClassLoader classLoader) {
+	public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType,
+			ClassLoader classLoader) {
 		if (source == null) {
 			if (targetType.isPrimitive()) {
 				throw new ConversionException(

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

@@ -17,7 +17,7 @@
 abstract class StringToObjectConverter implements Converter {
 
 	@Override
-	public final boolean canConvert(Object source, TypeDescriptor targetType) {
+	public final boolean canConvert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
 		return canConvert(targetType.getType());
 	}
 
@@ -29,7 +29,8 @@ public final boolean canConvert(Object source, TypeDescriptor targetType) {
 	abstract boolean canConvert(Class<?> targetType);
 
 	@Override
-	public final Object convert(Object source, TypeDescriptor targetType, ClassLoader classLoader) {
+	public final Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType,
+			ClassLoader classLoader) {
 		return convert((String) source, targetType.getType(), classLoader);
 	}
 

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

@@ -16,6 +16,7 @@
 import java.lang.reflect.Parameter;
 
 import org.apiguardian.api.API;
+import org.junit.platform.commons.util.Preconditions;
 import org.junit.platform.commons.util.ReflectionUtils;
 
 /**
@@ -28,15 +29,21 @@ public final class TypeDescriptor {
 
 	private final Class<?> type;
 
-	public static TypeDescriptor forType(Class<?> type) {
-		return new TypeDescriptor(type);
+	public static TypeDescriptor forClass(Class<?> clazz) {
+		return new TypeDescriptor(clazz);
+	}
+
+	public static TypeDescriptor forInstance(Object instance) {
+		return new TypeDescriptor(instance != null ? instance.getClass() : null);
 	}
 
 	public static TypeDescriptor forField(Field field) {
+		Preconditions.notNull(field, "field must not be null");
 		return new TypeDescriptor(field.getType());
 	}
 
 	public static TypeDescriptor forParameter(Parameter parameter) {
+		Preconditions.notNull(parameter, "parameter must not be null");
 		return new TypeDescriptor(parameter.getType());
 	}
 

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

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

jupiter-tests/src/test/java/org/junit/jupiter/params/converter/DefaultArgumentConverterTests.java

@@ -99,7 +99,7 @@ void delegatesStringsConversion() {
 
 		convert("value", int.class);
 
-		verify(underTest).delegateConversion("value", TypeDescriptor.forType(int.class),
+		verify(underTest).delegateConversion("value", TypeDescriptor.forClass(int.class),
 			getClassLoader(DefaultArgumentConverterTests.class));
 	}
 
@@ -130,7 +130,7 @@ void delegatesLocaleConversionWithExplicitIso639Format() {
 
 		convert("en", Locale.class);
 
-		verify(underTest).convert("en", TypeDescriptor.forType(Locale.class),
+		verify(underTest).convert("en", TypeDescriptor.forClass(Locale.class),
 			getClassLoader(DefaultArgumentConverterTests.class));
 	}
 
@@ -144,7 +144,7 @@ void throwsExceptionForDelegatedConversionFailure() {
 				.withCause(exception) //
 				.withMessage(exception.getMessage());
 
-		verify(underTest).delegateConversion("value", TypeDescriptor.forType(int.class),
+		verify(underTest).delegateConversion("value", TypeDescriptor.forClass(int.class),
 			getClassLoader(DefaultArgumentConverterTests.class));
 	}
 
@@ -165,7 +165,7 @@ void delegatesStringToClassWithCustomTypeFromDifferentClassLoaderConversion() th
 			assertThat(clazz).isEqualTo(customType);
 			assertThat(clazz.getClassLoader()).isSameAs(testClassLoader);
 
-			verify(underTest).delegateConversion(customTypeName, TypeDescriptor.forType(Class.class), testClassLoader);
+			verify(underTest).delegateConversion(customTypeName, TypeDescriptor.forClass(Class.class), testClassLoader);
 		}
 	}
 
@@ -186,7 +186,7 @@ private Object convert(Object input, Class<?> targetClass) {
 	}
 
 	private Object convert(Object input, Class<?> targetClass, ClassLoader classLoader) {
-		return underTest.convert(input, TypeDescriptor.forType(targetClass), classLoader);
+		return underTest.convert(input, TypeDescriptor.forClass(targetClass), classLoader);
 	}
 
 	@SuppressWarnings("unused")

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

@@ -105,7 +105,7 @@ void convertsStringsToPrimitiveWrapperTypes() {
 	@ValueSource(classes = { char.class, boolean.class, short.class, byte.class, int.class, long.class, float.class,
 			double.class, void.class })
 	void throwsExceptionForNullToPrimitiveTypeConversion(Class<?> type) {
-		TypeDescriptor typeDescriptor = TypeDescriptor.forType(type);
+		TypeDescriptor typeDescriptor = TypeDescriptor.forClass(type);
 
 		assertThat(canConvert(null, typeDescriptor)).isFalse();
 		assertThatExceptionOfType(ConversionException.class) //
@@ -117,7 +117,7 @@ void throwsExceptionForNullToPrimitiveTypeConversion(Class<?> type) {
 	@ValueSource(classes = { Boolean.class, Character.class, Short.class, Byte.class, Integer.class, Long.class,
 			Float.class, Double.class })
 	void throwsExceptionWhenConvertingTheWordNullToPrimitiveWrapperType(Class<?> type) {
-		TypeDescriptor typeDescriptor = TypeDescriptor.forType(type);
+		TypeDescriptor typeDescriptor = TypeDescriptor.forClass(type);
 
 		assertThat(canConvert("null", typeDescriptor)).isTrue();
 		assertThatExceptionOfType(ConversionException.class) //
@@ -132,7 +132,7 @@ void throwsExceptionWhenConvertingTheWordNullToPrimitiveWrapperType(Class<?> typ
 
 	@Test
 	void throwsExceptionOnInvalidStringForPrimitiveTypes() {
-		TypeDescriptor charDescriptor = TypeDescriptor.forType(char.class);
+		TypeDescriptor charDescriptor = TypeDescriptor.forClass(char.class);
 
 		assertThat(canConvert("ab", charDescriptor)).isTrue();
 		assertThatExceptionOfType(ConversionException.class) //
@@ -141,7 +141,7 @@ void throwsExceptionOnInvalidStringForPrimitiveTypes() {
 				.havingCause() //
 				.withMessage("String must have length of 1: ab");
 
-		TypeDescriptor booleanDescriptor = TypeDescriptor.forType(boolean.class);
+		TypeDescriptor booleanDescriptor = TypeDescriptor.forClass(boolean.class);
 
 		assertThat(canConvert("tru", booleanDescriptor)).isTrue();
 		assertThatExceptionOfType(ConversionException.class) //
@@ -167,7 +167,7 @@ void throwsExceptionOnInvalidStringForPrimitiveTypes() {
 
 	@Test
 	void throwsExceptionWhenImplicitConversionIsUnsupported() {
-		TypeDescriptor typeDescriptor = TypeDescriptor.forType(Enigma.class);
+		TypeDescriptor typeDescriptor = TypeDescriptor.forClass(Enigma.class);
 
 		assertThat(canConvert("foo", typeDescriptor)).isFalse();
 		assertThatExceptionOfType(ConversionException.class) //
@@ -251,7 +251,7 @@ void convertsStringToClassWithCustomTypeFromDifferentClassLoader() throws Except
 			var declaringExecutable = ReflectionSupport.findMethod(customType, "foo").get();
 			assertThat(declaringExecutable.getDeclaringClass().getClassLoader()).isSameAs(testClassLoader);
 
-			var typeDescriptor = TypeDescriptor.forType(Class.class);
+			var typeDescriptor = TypeDescriptor.forClass(Class.class);
 			assertThat(canConvert(customTypeName, typeDescriptor)).isTrue();
 
 			var clazz = (Class<?>) convert(customTypeName, typeDescriptor, classLoader(declaringExecutable));
@@ -332,7 +332,7 @@ void convertsStringToUUID() {
 	// -------------------------------------------------------------------------
 
 	private void assertConverts(Object input, Class<?> targetClass, Object expectedOutput) {
-		TypeDescriptor typeDescriptor = TypeDescriptor.forType(targetClass);
+		TypeDescriptor typeDescriptor = TypeDescriptor.forClass(targetClass);
 
 		assertThat(canConvert(input, typeDescriptor)).isTrue();
 
@@ -344,15 +344,15 @@ private void assertConverts(Object input, Class<?> targetClass, Object expectedO
 	}
 
 	private boolean canConvert(Object input, TypeDescriptor targetClass) {
-		return DefaultConverter.INSTANCE.canConvert(input, targetClass);
+		return DefaultConverter.INSTANCE.canConvert(input, TypeDescriptor.forInstance(input), targetClass);
 	}
 
 	private Object convert(Object input, TypeDescriptor targetClass) {
 		return convert(input, targetClass, classLoader());
 	}
 
 	private Object convert(Object input, TypeDescriptor targetClass, ClassLoader classLoader) {
-		return DefaultConverter.INSTANCE.convert(input, targetClass, classLoader);
+		return DefaultConverter.INSTANCE.convert(input, TypeDescriptor.forInstance(input), targetClass, classLoader);
 	}
 
 	private static ClassLoader classLoader() {