Fixes after rebase

Author: scordio

junit-jupiter-params/src/main/java/org/junit/jupiter/params/converter/DefaultArgumentConverter.java

@@ -27,7 +27,6 @@
 import org.junit.jupiter.params.support.FieldContext;
 import org.junit.platform.commons.support.conversion.ConversionException;
 import org.junit.platform.commons.support.conversion.ConversionSupport;
-import org.junit.platform.commons.util.ClassLoaderUtils;
 import org.junit.platform.commons.util.ReflectionUtils;
 
 /**
@@ -84,17 +83,15 @@ public final Object convert(Object source, Class<?> targetType, ClassLoader clas
 			return source;
 		}
 
-		Class<?> declaringClass = context.getDeclaringExecutable().getDeclaringClass();
-		ClassLoader classLoader = ClassLoaderUtils.getClassLoader(declaringClass);
 		try {
-			return convert(source, targetType, classLoader);
+			return delegateConversion(source, targetType, classLoader);
 		}
 		catch (ConversionException ex) {
 			throw new ArgumentConversionException(ex.getMessage(), ex);
 		}
 	}
 
-	Object convert(Object source, Class<?> targetType, ClassLoader classLoader) {
+	Object delegateConversion(Object source, Class<?> targetType, ClassLoader classLoader) {
 		return ConversionSupport.convert(source, targetType, classLoader);
 	}
 

junit-jupiter-params/src/main/java/org/junit/jupiter/params/converter/TypedArgumentConverter.java

@@ -47,9 +47,6 @@ protected TypedArgumentConverter(Class<S> sourceType, Class<T> targetType) {
 		this.targetType = Preconditions.notNull(targetType, "targetType must not be null");
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public final Object convert(Object source, ParameterContext context) throws ArgumentConversionException {
 		return convert(source, context.getParameter().getType());

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

@@ -28,11 +28,11 @@
  * from a given source type into a given target type and does not need access to
  * the {@link ClassLoader} to perform the conversion.
  *
- * @since 1.12
+ * @since 1.13
  * @see ConversionSupport
  * @see TypedConversionService
  */
-@API(status = EXPERIMENTAL, since = "1.12")
+@API(status = EXPERIMENTAL, since = "1.13")
 public interface ConversionService {
 
 	/**

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

@@ -53,7 +53,7 @@ private ConversionSupport() {
 	 */
 	@SuppressWarnings("unchecked")
 	@Deprecated
-	@API(status = DEPRECATED, since = "5.12")
+	@API(status = DEPRECATED, since = "5.13")
 	public static <T> T convert(String source, Class<T> targetType, ClassLoader classLoader) {
 		return (T) DefaultConversionService.INSTANCE.convert(source, targetType, getClassLoader(classLoader));
 	}
@@ -72,22 +72,23 @@ public static <T> T convert(String source, Class<T> targetType, ClassLoader clas
 	 * @return the converted object; may be {@code null} but only if the target
 	 * type is a reference type
 	 *
-	 * @since 1.12
+	 * @since 1.13
 	 */
-	@API(status = EXPERIMENTAL, since = "1.12")
+	@API(status = EXPERIMENTAL, since = "1.13")
 	@SuppressWarnings("unchecked")
 	public static <T> T convert(Object source, Class<T> targetType, ClassLoader classLoader) {
 		ClassLoader classLoaderToUse = getClassLoader(classLoader);
 		ServiceLoader<ConversionService> serviceLoader = ServiceLoader.load(ConversionService.class, classLoaderToUse);
 
-		return (T) Stream.concat( //
+		ConversionService conversionService = Stream.concat( //
 			StreamSupport.stream(serviceLoader.spliterator(), false), //
 			Stream.of(DefaultConversionService.INSTANCE)) //
 				.filter(candidate -> candidate.canConvert(source, targetType, classLoader)) //
 				.findFirst() //
-				.map(candidate -> candidate.convert(source, targetType, classLoaderToUse)) //
-				.orElseThrow(() -> new ConversionException("No registered or built-in converter for source type "
-						+ source.getClass().getTypeName() + " and target type " + targetType.getTypeName()));
+				.orElseThrow(() -> new ConversionException("No registered or built-in converter for source '" + source
+						+ "' and target type " + targetType.getTypeName()));
+
+		return (T) conversionService.convert(source, targetType, classLoaderToUse);
 	}
 
 	private static ClassLoader getClassLoader(ClassLoader classLoader) {

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

@@ -43,9 +43,9 @@
  * <p>If the source and target types are identical, the source object will not
  * be modified.
  *
- * @since 1.12
+ * @since 1.13
  */
-@API(status = INTERNAL, since = "5.12")
+@API(status = INTERNAL, since = "1.13")
 public class DefaultConversionService implements ConversionService {
 
 	static final DefaultConversionService INSTANCE = new DefaultConversionService();
@@ -78,8 +78,8 @@ private DefaultConversionService() {
 	 */
 	@Override
 	public boolean canConvert(Object source, Class<?> targetType, ClassLoader classLoader) {
-		if (source == null && targetType.isPrimitive()) {
-			return false;
+		if (source == null) {
+			return !targetType.isPrimitive();
 		}
 
 		if (!(source instanceof String)) {

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

@@ -23,9 +23,9 @@
  *
  * @param <S> the type of the source argument to convert
  * @param <T> the type of the target object to create from the source
- * @since 1.12
+ * @since 1.13
  */
-@API(status = EXPERIMENTAL, since = "1.12")
+@API(status = EXPERIMENTAL, since = "1.13")
 public abstract class TypedConversionService<S, T> implements ConversionService {
 
 	private final Class<S> sourceType;
@@ -43,17 +43,11 @@ protected TypedConversionService(Class<S> sourceType, Class<T> targetType) {
 		this.targetType = Preconditions.notNull(targetType, "targetType must not be null");
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public final boolean canConvert(Object source, Class<?> targetType, ClassLoader classLoader) {
 		return sourceType.isInstance(source) && ReflectionUtils.isAssignableTo(this.targetType, targetType);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public final Object convert(Object source, Class<?> 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

@@ -78,39 +78,29 @@ void throwsExceptionForNullToPrimitiveTypeConversion(Class<?> type) {
 				.isThrownBy(() -> convert(null, type)) //
 				.withMessage("Cannot convert null to primitive value of type " + type.getCanonicalName());
 
-		verify(underTest, never()).convert(any(), any(), any(ClassLoader.class));
-	}
-
-	@Test
-	void throwsExceptionForNonStringsConversion() {
-		assertThatExceptionOfType(ArgumentConversionException.class) //
-				.isThrownBy(() -> convert(new Enigma(), String.class)) //
-				.withMessage("No built-in converter for source type %s and target type java.lang.String",
-					Enigma.class.getName());
-
-		verify(underTest, never()).convert(any(), any(), any(ClassLoader.class));
+		verify(underTest, never()).delegateConversion(any(), any(), any(ClassLoader.class));
 	}
 
 	@Test
 	void delegatesStringsConversion() {
-		doReturn(null).when(underTest).convert(any(), any(), any(ClassLoader.class));
+		doReturn(null).when(underTest).delegateConversion(any(), any(), any(ClassLoader.class));
 
 		convert("value", int.class);
 
-		verify(underTest).convert("value", int.class, getClassLoader(DefaultArgumentConverterTests.class));
+		verify(underTest).delegateConversion("value", int.class, getClassLoader(DefaultArgumentConverterTests.class));
 	}
 
 	@Test
 	void throwsExceptionForDelegatedConversionFailure() {
 		ConversionException exception = new ConversionException("fail");
-		doThrow(exception).when(underTest).convert(any(), any(), any(ClassLoader.class));
+		doThrow(exception).when(underTest).delegateConversion(any(), any(), any(ClassLoader.class));
 
 		assertThatExceptionOfType(ArgumentConversionException.class) //
 				.isThrownBy(() -> convert("value", int.class)) //
 				.withCause(exception) //
 				.withMessage(exception.getMessage());
 
-		verify(underTest).convert("value", int.class, getClassLoader(DefaultArgumentConverterTests.class));
+		verify(underTest).delegateConversion("value", int.class, getClassLoader(DefaultArgumentConverterTests.class));
 	}
 
 	@Test
@@ -123,14 +113,14 @@ void delegatesStringToClassWithCustomTypeFromDifferentClassLoaderConversion() th
 			var declaringExecutable = ReflectionSupport.findMethod(customType, "foo").orElseThrow();
 			assertThat(declaringExecutable.getDeclaringClass().getClassLoader()).isSameAs(testClassLoader);
 
-			doReturn(customType).when(underTest).convert(any(), any(), any(ClassLoader.class));
+			doReturn(customType).when(underTest).delegateConversion(any(), any(), any(ClassLoader.class));
 
 			var clazz = (Class<?>) convert(customTypeName, Class.class, testClassLoader);
 			assertThat(clazz).isNotEqualTo(Enigma.class);
 			assertThat(clazz).isEqualTo(customType);
 			assertThat(clazz.getClassLoader()).isSameAs(testClassLoader);
 
-			verify(underTest).convert(customTypeName, Class.class, testClassLoader);
+			verify(underTest).delegateConversion(customTypeName, Class.class, testClassLoader);
 		}
 	}
 
@@ -143,7 +133,7 @@ private void assertConverts(Object input, Class<?> targetClass, Object expectedO
 				.describedAs(input + " --(" + targetClass.getName() + ")--> " + expectedOutput) //
 				.isEqualTo(expectedOutput);
 
-		verify(underTest, never()).convert(any(), any(), any(ClassLoader.class));
+		verify(underTest, never()).delegateConversion(any(), any(), any(ClassLoader.class));
 	}
 
 	private Object convert(Object input, Class<?> targetClass) {

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

@@ -107,7 +107,8 @@ void convertsStringsToPrimitiveWrapperTypes() {
 	void throwsExceptionForNullToPrimitiveTypeConversion(Class<?> type) {
 		assertThatExceptionOfType(ConversionException.class) //
 				.isThrownBy(() -> convert(null, type)) //
-				.withMessage("Cannot convert null to primitive value of type " + type.getCanonicalName());
+				.withMessage("No registered or built-in converter for source 'null' and target type %s",
+					type.getCanonicalName());
 	}
 
 	@ParameterizedTest(name = "[{index}] {0}")
@@ -153,7 +154,7 @@ void throwsExceptionOnInvalidStringForPrimitiveTypes() {
 	void throwsExceptionWhenImplicitConversionIsUnsupported() {
 		assertThatExceptionOfType(ConversionException.class) //
 				.isThrownBy(() -> convert("foo", Enigma.class)) //
-				.withMessage("No built-in converter for source type java.lang.String and target type %s",
+				.withMessage("No registered or built-in converter for source 'foo' and target type %s",
 					Enigma.class.getName());
 	}
 
@@ -309,19 +310,19 @@ void convertsStringToUUID() {
 
 	// -------------------------------------------------------------------------
 
-	private void assertConverts(String input, Class<?> targetClass, Object expectedOutput) {
+	private void assertConverts(Object input, Class<?> targetClass, Object expectedOutput) {
 		var result = convert(input, targetClass);
 
 		assertThat(result) //
 				.describedAs(input + " --(" + targetClass.getName() + ")--> " + expectedOutput) //
 				.isEqualTo(expectedOutput);
 	}
 
-	private Object convert(String input, Class<?> targetClass) {
+	private Object convert(Object input, Class<?> targetClass) {
 		return convert(input, targetClass, classLoader());
 	}
 
-	private Object convert(String input, Class<?> targetClass, ClassLoader classLoader) {
+	private Object convert(Object input, Class<?> targetClass, ClassLoader classLoader) {
 		return ConversionSupport.convert(input, targetClass, classLoader);
 	}