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

@@ -30,10 +30,15 @@
 public final class TypeDescriptor {
 
 /**
- * Internal marker for type descriptors created from a {@code null} value.
+ * Internal marker for descriptors created from a {@code null} value.
  */
 private static final Class<?> NULL_TYPE = Void.class;
 
+/**
+ * {@code TypeDescriptor} returned when no value is available.
+ */
+public static final TypeDescriptor NONE = new TypeDescriptor(NULL_TYPE);
+
 private final Class<?> type;
 
 public static TypeDescriptor forClass(Class<?> clazz) {
@@ -42,25 +47,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 +74,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);
 }