Add type parameters to Converter

Author: scordio

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

@@ -56,7 +56,7 @@ private ConversionSupport() {
 	@API(status = DEPRECATED, since = "6.0")
 	public static <T> @Nullable T convert(@Nullable String source, Class<T> targetType,
 			@Nullable ClassLoader classLoader) {
-		return convert(source, TypeDescriptor.forClass(targetType), getClassLoader(classLoader));
+		return convert(source, TypeDescriptor.forClass(targetType), classLoader);
 	}
 
 	/**
@@ -76,17 +76,17 @@ private ConversionSupport() {
 	 * @since 6.0
 	 */
 	@API(status = EXPERIMENTAL, since = "6.0")
-	@SuppressWarnings("unchecked")
+	@SuppressWarnings({ "unchecked", "rawtypes" })
 	public static <T> @Nullable T convert(@Nullable Object source, TypeDescriptor targetType,
 			@Nullable ClassLoader classLoader) {
 		TypeDescriptor sourceType = TypeDescriptor.forInstance(source);
-		ClassLoader classLoaderToUse = getClassLoader(classLoader);
+		ClassLoader classLoaderToUse = classLoader != null ? classLoader : ClassLoaderUtils.getDefaultClassLoader();
 		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, sourceType, targetType)) //
+				.filter(candidate -> candidate.canConvert(sourceType, targetType)) //
 				.findFirst() //
 				.orElseThrow(() -> new ConversionException(
 					"No registered or built-in converter for source '%s' and target type %s".formatted( //
@@ -95,8 +95,4 @@ private ConversionSupport() {
 		return (T) converter.convert(source, sourceType, targetType, classLoaderToUse);
 	}
 
-	private static ClassLoader getClassLoader(@Nullable ClassLoader classLoader) {
-		return classLoader != null ? classLoader : ClassLoaderUtils.getDefaultClassLoader();
-	}
-
 }

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

@@ -34,26 +34,24 @@
  * @see TypedConverter
  */
 @API(status = EXPERIMENTAL, since = "6.0")
-public interface Converter {
+public interface Converter<S, T> {
 
 	/**
-	 * Determine if the supplied source object can be converted into an instance
+	 * Determine if the supplied source type can be converted into an instance
 	 * of the specified 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}
-	 * @return {@code true} if the supplied source can be converted
+	 * @return {@code true} if the supplied source type can be converted
 	 */
-	boolean canConvert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
+	boolean canConvert(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, TypeDescriptor)}
-	 * returned {@code true} for the same target type.
+	 * <p>This method will only be invoked if {@link #canConvert(TypeDescriptor, TypeDescriptor)}
+	 * returned {@code true} for the same type descriptors.
 	 *
 	 * @param source the source object to convert; may be {@code null} but only
 	 * if the target type is a reference type
@@ -66,7 +64,7 @@ public interface Converter {
 	 * @throws ConversionException if an error occurs during the conversion
 	 */
 	@Nullable
-	Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType,
-			ClassLoader classLoader) throws ConversionException;
+	T convert(@Nullable S source, TypeDescriptor sourceType, TypeDescriptor targetType, ClassLoader classLoader)
+			throws ConversionException;
 
 }

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

@@ -44,7 +44,7 @@
  * @since 6.0
  */
 @API(status = INTERNAL, since = "6.0")
-public class DefaultConverter implements Converter {
+public class DefaultConverter implements Converter<String, Object> {
 
 	static final DefaultConverter INSTANCE = new DefaultConverter();
 
@@ -64,23 +64,21 @@ private DefaultConverter() {
 	}
 
 	/**
-	 * Determine if the supplied source object can be converted into an instance
+	 * Determine if the supplied source type can be converted into an instance
 	 * of the specified 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 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(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
-		if (source == null) {
+	public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {
+		if (sourceType == TypeDescriptor.NONE) {
 			return !targetType.isPrimitive();
 		}
 
-		if (!(source instanceof String)) {
+		if (!(String.class.equals(sourceType.getType()))) {
 			return false;
 		}
 
@@ -93,7 +91,7 @@ public boolean canConvert(@Nullable Object source, TypeDescriptor sourceType, Ty
 	}
 
 	/**
-	 * Convert the supplied source object into an instance of the specified
+	 * Convert the supplied source {@link String} into an instance of the specified
 	 * target type.
 	 * <p>If the target type is {@code String}, the source {@code String} will not
 	 * be modified.
@@ -126,19 +124,19 @@ public boolean canConvert(@Nullable Object source, TypeDescriptor sourceType, Ty
 	 * 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
+	 * @param source the source {@link String} 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;
+	 * @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
 	 */
 	@Override
-	public @Nullable Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType,
-			ClassLoader classLoader) {
+	public @Nullable Object convert(@Nullable String source, TypeDescriptor sourceType, TypeDescriptor targetType,
+			ClassLoader classLoader) throws ConversionException {
 		if (source == null) {
 			if (targetType.isPrimitive()) {
 				throw new ConversionException(
@@ -156,7 +154,7 @@ public boolean canConvert(@Nullable Object source, TypeDescriptor sourceType, Ty
 			candidate -> candidate.canConvert(targetTypeToUse)).findFirst();
 		if (converter.isPresent()) {
 			try {
-				return converter.get().convert((String) source, targetTypeToUse, classLoader);
+				return converter.get().convert(source, targetTypeToUse, classLoader);
 			}
 			catch (Exception ex) {
 				if (ex instanceof ConversionException) {

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

@@ -16,10 +16,10 @@
  * Internal API for converting arguments of type {@link String} to a specified
  * target type.
  */
-abstract class StringToObjectConverter implements Converter {
+abstract class StringToObjectConverter implements Converter<String, Object> {
 
 	@Override
-	public final boolean canConvert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
+	public final boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {
 		return canConvert(targetType.getType());
 	}
 
@@ -31,9 +31,9 @@ public final boolean canConvert(@Nullable Object source, TypeDescriptor sourceTy
 	abstract boolean canConvert(@Nullable Class<?> targetType);
 
 	@Override
-	public final Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType,
+	public final Object convert(@Nullable String source, TypeDescriptor sourceType, TypeDescriptor targetType,
 			ClassLoader classLoader) {
-		return convert((String) source, targetType.getType(), classLoader);
+		return convert(source, targetType.getType(), classLoader);
 	}
 
 	/**

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

@@ -29,10 +29,12 @@
 @API(status = EXPERIMENTAL, since = "6.0")
 public final class TypeDescriptor {
 
+	private static final Class<?> NULL_TYPE = Void.class;
+
 	/**
-	 * Internal marker for type descriptors created from a {@code null} value.
+	 * {@code TypeDescriptor} returned when no value is available.
 	 */
-	private static final Class<?> NULL_TYPE = Void.class;
+	public static final TypeDescriptor NONE = new TypeDescriptor(NULL_TYPE);
 
 	private final Class<?> type;
 
@@ -42,25 +44,25 @@ public static TypeDescriptor forClass(Class<?> clazz) {
 	}
 
 	public static TypeDescriptor forInstance(@Nullable Object instance) {
-		return new TypeDescriptor(instance != null ? instance.getClass() : NULL_TYPE);
+		return instance != null ? forClass(instance.getClass()) : NONE;
 	}
 
 	public static TypeDescriptor forField(Field field) {
 		Preconditions.notNull(field, "field must not be null");
-		return new TypeDescriptor(field.getType());
+		return forClass(field.getType());
 	}
 
 	public static TypeDescriptor forParameter(Parameter parameter) {
 		Preconditions.notNull(parameter, "parameter must not be null");
-		return new TypeDescriptor(parameter.getType());
+		return forClass(parameter.getType());
 	}
 
 	private TypeDescriptor(Class<?> type) {
 		this.type = type;
 	}
 
 	public @Nullable Class<?> getType() {
-		return type != NULL_TYPE ? type : null;
+		return this != NONE ? type : null;
 	}
 
 	public @Nullable Class<?> getWrapperType() {
@@ -69,11 +71,11 @@ private TypeDescriptor(Class<?> type) {
 	}
 
 	public boolean isPrimitive() {
-		return type != NULL_TYPE && type.isPrimitive();
+		return type.isPrimitive();
 	}
 
 	public String getTypeName() {
-		return type != NULL_TYPE ? type.getName() : "null";
+		return type.getName();
 	}
 
 	@Override

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

@@ -13,8 +13,8 @@
 import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 
 import org.apiguardian.api.API;
+import org.jspecify.annotations.Nullable;
 import org.junit.platform.commons.util.Preconditions;
-import org.junit.platform.commons.util.ReflectionUtils;
 
 /**
  * {@code TypedConversionService} is an abstract base class for
@@ -26,7 +26,7 @@
  * @since 6.0
  */
 @API(status = EXPERIMENTAL, since = "6.0")
-public abstract class TypedConverter<S, T> implements Converter {
+public abstract class TypedConverter<S, T> implements Converter<S, T> {
 
 	private final Class<S> sourceType;
 	private final Class<T> targetType;
@@ -44,15 +44,15 @@ protected TypedConverter(Class<S> sourceType, Class<T> targetType) {
 	}
 
 	@Override
-	public final boolean canConvert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
-		return this.sourceType.isInstance(source)
-				&& ReflectionUtils.isAssignableTo(this.targetType, targetType.getType());
+	public final boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {
+		// FIXME add test cases with subtypes
+		return this.sourceType == sourceType.getType() && this.targetType == targetType.getType();
 	}
 
 	@Override
-	public final Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType,
+	public final @Nullable T convert(@Nullable S source, TypeDescriptor sourceType, TypeDescriptor targetType,
 			ClassLoader classLoader) {
-		return source == null ? convert(null) : convert(this.sourceType.cast(source));
+		return convert(source);
 	}
 
 	/**
@@ -64,6 +64,6 @@ public final Object convert(Object source, TypeDescriptor sourceType, TypeDescri
 	 * type is a reference type
 	 * @throws ConversionException if an error occurs during the conversion
 	 */
-	protected abstract T convert(S source) throws ConversionException;
+	protected abstract @Nullable T convert(@Nullable S source) throws ConversionException;
 
 }

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

@@ -12,18 +12,19 @@
 
 import java.util.Locale;
 
+import org.jspecify.annotations.Nullable;
 import org.junit.platform.commons.support.conversion.TypedConverter;
 
-// FIXME delete
+// FIXME move to ConversionSupportIntegrationTests
 public class LocaleConverter extends TypedConverter<String, Locale> {
 
 	public LocaleConverter() {
 		super(String.class, Locale.class);
 	}
 
 	@Override
-	protected Locale convert(String source) {
-		return Locale.forLanguageTag(source);
+	protected @Nullable Locale convert(@Nullable String source) {
+		return source != null ? Locale.forLanguageTag(source) : null;
 	}
 
 }

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

@@ -330,7 +330,7 @@ void convertsStringToUUID() {
 
 	// -------------------------------------------------------------------------
 
-	private void assertConverts(@Nullable Object input, Class<?> targetClass, @Nullable Object expectedOutput) {
+	private void assertConverts(@Nullable String input, Class<?> targetClass, @Nullable Object expectedOutput) {
 		TypeDescriptor typeDescriptor = TypeDescriptor.forClass(targetClass);
 
 		assertThat(canConvert(input, typeDescriptor)).isTrue();
@@ -342,15 +342,15 @@ private void assertConverts(@Nullable Object input, Class<?> targetClass, @Nulla
 				.isEqualTo(expectedOutput);
 	}
 
-	private boolean canConvert(@Nullable Object input, TypeDescriptor targetClass) {
-		return DefaultConverter.INSTANCE.canConvert(input, TypeDescriptor.forInstance(input), targetClass);
+	private boolean canConvert(@Nullable String input, TypeDescriptor targetClass) {
+		return DefaultConverter.INSTANCE.canConvert(TypeDescriptor.forInstance(input), targetClass);
 	}
 
-	private @Nullable Object convert(@Nullable Object input, TypeDescriptor targetClass) {
+	private @Nullable Object convert(@Nullable String input, TypeDescriptor targetClass) {
 		return convert(input, targetClass, classLoader());
 	}
 
-	private @Nullable Object convert(@Nullable Object input, TypeDescriptor targetClass, ClassLoader classLoader) {
+	private @Nullable Object convert(@Nullable String input, TypeDescriptor targetClass, ClassLoader classLoader) {
 		return DefaultConverter.INSTANCE.convert(input, TypeDescriptor.forInstance(input), targetClass, classLoader);
 	}