Merge pull request #256 from scijava/modify-cancast

Modify cancast

Author: ctrueden

src/main/java/org/scijava/util/ConversionUtils.java

@@ -97,26 +97,46 @@ public static <T> T cast(final Object src, final Class<T> dest) {
 	}
 
 	/**
-	 * Checks whether objects of the given class can be cast to the specified
-	 * type.
-	 *
+	 * Checks whether objects of the given class can be assigned to the specified
+	 * type. Unlike {@link Class#isAssignableFrom(Class)}, this method considers
+	 * auto-unboxing.
+	 * 
 	 * @return true If the destination class is assignable from the source one, or
 	 *         if the source class is null and destination class is non-null.
-	 * @see #cast(Object, Class)
 	 */
-	public static boolean canCast(final Class<?> src, final Class<?> dest) {
-		if (dest == null) return false;
-		return src == null || dest.isAssignableFrom(src);
+	public static boolean canAssign(final Class<?> src, final Class<?> dest) {
+		return canCast(src, dest);
 	}
 
 	/**
-	 * Checks whether the given object can be cast to the specified type.
-	 *
+	 * Checks whether the given object can be assigned to the specified type.
+	 * Unlike {@link Class#isAssignableFrom(Class)}, this method considers
+	 * auto-unboxing.
+	 * 
 	 * @return true If the destination class is assignable from the source
 	 *         object's class, or if the source object is null and destionation
 	 *         class is non-null.
-	 * @see #cast(Object, Class)
 	 */
+	public static boolean canAssign(final Object src, final Class<?> dest) {
+		return canCast(src, dest);
+	}
+
+	/**
+	 * @deprecated use {@link #canAssign(Class, Class)} instead
+	 */
+	@Deprecated
+	public static boolean canCast(final Class<?> src, final Class<?> dest) {
+		if (dest == null) return false;
+		if (src == null) return true;
+		final Class<?> saneSrc = getNonprimitiveType(src);
+		final Class<?> saneDest = getNonprimitiveType(dest);
+		return saneDest.isAssignableFrom(saneSrc);
+	}
+
+	/**
+	 * @deprecated use {@link #canAssign(Object, Class)} instead
+	 */
+	@Deprecated
 	public static boolean canCast(final Object src, final Class<?> dest) {
 		if (dest == null) return false;
 		return src == null || canCast(src.getClass(), dest);

src/test/java/org/scijava/convert/ConvertServiceTest.java

@@ -498,6 +498,22 @@ class Struct {
 		setFieldValue(struct, "singleValue", new int[] { 4, 8, 2 });
 	}
 
+	/**
+	 * Test behavior when setting a single element field with a constructor that
+	 * accepts a primitive type (int).
+	 */
+	@Test
+	public void testLegitimateSingletonInt() {
+		class Struct {
+			
+			private IntWrapper intWrapper;
+		}
+		final Struct struct = new Struct();
+		
+		setFieldValue(struct, "intWrapper", Integer.valueOf(12));
+		assertNotNull(struct.intWrapper);
+	}
+
 	/**
 	 * Test behavior when setting a single element field with a constructor that
 	 * accepts a primitive array.
@@ -628,6 +644,18 @@ private static interface INumberList extends List<Number> {
 		// NB: No implementation needed.
 	}
 
+	/**
+	 * Dummy class with an int constructor to ensure that when converting using
+	 * constructors, auto-unboxing should work as expected.
+	 */
+	public static class IntWrapper {
+		
+		@SuppressWarnings("unused")
+		public IntWrapper(final int gonnaWrapThisInt) {
+			// nothing to do
+		}
+	}
+
 	/**
 	 * Dummy class with an array constructor to ensure that the logic to
 	 * recursively convert arrays doesn't consume the array improperly when it

src/test/java/org/scijava/util/ConversionUtilsTest.java

@@ -73,9 +73,8 @@ public void testCanCast() {
 		assertFalse(ConversionUtils.canCast(double.class, float.class));
 		assertFalse(ConversionUtils.canCast(float.class, double.class));
 
-		// boxing is not reported to work
-		// TODO: Consider changing this behavior.
-		assertFalse(ConversionUtils.canCast(int.class, Number.class));
+		// check casting with boxing
+		assertTrue(ConversionUtils.canCast(int.class, Number.class));
 
 		// casting from null always works
 		final Class<?> nullClass = null;