Fixed type resolution for uninitialized factory-method declaration

Issue: SPR-11112
(cherry picked from commit 5dcd287)

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

@@ -135,21 +135,21 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	 * Dependency types to ignore on dependency check and autowire, as Set of
 	 * Class objects: for example, String. Default is none.
 	 */
-	private final Set<Class> ignoredDependencyTypes = new HashSet<Class>();
+	private final Set<Class<?>> ignoredDependencyTypes = new HashSet<Class<?>>();
 
 	/**
 	 * Dependency interfaces to ignore on dependency check and autowire, as Set of
 	 * Class objects. By default, only the BeanFactory interface is ignored.
 	 */
-	private final Set<Class> ignoredDependencyInterfaces = new HashSet<Class>();
+	private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<Class<?>>();
 
 	/** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
 	private final Map<String, BeanWrapper> factoryBeanInstanceCache =
 			new ConcurrentHashMap<String, BeanWrapper>(16);
 
 	/** Cache of filtered PropertyDescriptors: bean Class -> PropertyDescriptor array */
-	private final Map<Class, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
+	private final Map<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
-			new ConcurrentHashMap<Class, PropertyDescriptor[]>(64);
+			new ConcurrentHashMap<Class<?>, PropertyDescriptor[]>(64);
 
 
 	/**
@@ -506,7 +506,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 				logger.debug("Eagerly caching bean '" + beanName +
 						"' to allow for resolving potential circular references");
 			}
-			addSingletonFactory(beanName, new ObjectFactory() {
+			addSingletonFactory(beanName, new ObjectFactory<Object>() {
 				public Object getObject() throws BeansException {
 					return getEarlyBeanReference(beanName, mbd, bean);
 				}
@@ -634,9 +634,9 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 
 		// If all factory methods have the same return type, return that type.
 		// Can't clearly figure out exact method due to type converting / autowiring!
+		Class<?> commonType = null;
 		int minNrOfArgs = mbd.getConstructorArgumentValues().getArgumentCount();
 		Method[] candidates = ReflectionUtils.getUniqueDeclaredMethods(factoryClass);
-		Set<Class<?>> returnTypes = new HashSet<Class<?>>(1);
 		for (Method factoryMethod : candidates) {
 			if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic &&
 					factoryMethod.getName().equals(mbd.getFactoryMethodName()) &&
@@ -669,7 +669,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 						Class<?> returnType = AutowireUtils.resolveReturnTypeForFactoryMethod(
 								factoryMethod, args, getBeanClassLoader());
 						if (returnType != null) {
-							returnTypes.add(returnType);
+							commonType = ClassUtils.determineCommonAncestor(returnType, commonType);
 						}
 					}
 					catch (Throwable ex) {
@@ -679,14 +679,14 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 					}
 				}
 				else {
-					returnTypes.add(factoryMethod.getReturnType());
+					commonType = ClassUtils.determineCommonAncestor(factoryMethod.getReturnType(), commonType);
 				}
 			}
 		}
 
-		if (returnTypes.size() == 1) {
+		if (commonType != null) {
 			// Clear return type found: all factory methods return same type.
-			return returnTypes.iterator().next();
+			return commonType;
 		}
 		else {
 			// Ambiguous return types found: return null to indicate "not determinable".
@@ -788,11 +788,11 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	 * @return the FactoryBean instance, or {@code null} to indicate
 	 * that we couldn't obtain a shortcut FactoryBean instance
 	 */
-	private FactoryBean getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
+	private FactoryBean<?> getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
 		synchronized (getSingletonMutex()) {
 			BeanWrapper bw = this.factoryBeanInstanceCache.get(beanName);
 			if (bw != null) {
-				return (FactoryBean) bw.getWrappedInstance();
+				return (FactoryBean<?>) bw.getWrappedInstance();
 			}
 			if (isSingletonCurrentlyInCreation(beanName)) {
 				return null;
@@ -812,7 +812,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 				// Finished partial creation of this bean.
 				afterSingletonCreation(beanName);
 			}
-			FactoryBean fb = getFactoryBean(beanName, instance);
+			FactoryBean<?> fb = getFactoryBean(beanName, instance);
 			if (bw != null) {
 				this.factoryBeanInstanceCache.put(beanName, bw);
 			}
@@ -829,7 +829,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	 * @return the FactoryBean instance, or {@code null} to indicate
 	 * that we couldn't obtain a shortcut FactoryBean instance
 	 */
-	private FactoryBean getNonSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
+	private FactoryBean<?> getNonSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
 		if (isPrototypeCurrentlyInCreation(beanName)) {
 			return null;
 		}
@@ -972,7 +972,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 		}
 
 		// Need to determine the constructor...
-		Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
+		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
 		if (ctors != null ||
 				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
 				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
@@ -992,14 +992,14 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	 * @throws org.springframework.beans.BeansException in case of errors
 	 * @see org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors
 	 */
-	protected Constructor[] determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName)
+	protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName)
 			throws BeansException {
 
 		if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
 			for (BeanPostProcessor bp : getBeanPostProcessors()) {
 				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
 					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
-					Constructor[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
+					Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
 					if (ctors != null) {
 						return ctors;
 					}
@@ -1070,7 +1070,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	 * @return BeanWrapper for the new instance
 	 */
 	protected BeanWrapper autowireConstructor(
-			String beanName, RootBeanDefinition mbd, Constructor[] ctors, Object[] explicitArgs) {
+			String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
 
 		return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
 	}

spring-beans/src/main/java/org/springframework/beans/factory/support/AutowireUtils.java

@@ -56,9 +56,9 @@ abstract class AutowireUtils {
 	 * decreasing number of arguments.
 	 * @param constructors the constructor array to sort
 	 */
-	public static void sortConstructors(Constructor[] constructors) {
+	public static void sortConstructors(Constructor<?>[] constructors) {
-		Arrays.sort(constructors, new Comparator<Constructor>() {
+		Arrays.sort(constructors, new Comparator<Constructor<?>>() {
-			public int compare(Constructor c1, Constructor c2) {
+			public int compare(Constructor<?> c1, Constructor<?> c2) {
 				boolean p1 = Modifier.isPublic(c1.getModifiers());
 				boolean p2 = Modifier.isPublic(c2.getModifiers());
 				if (p1 != p2) {
@@ -110,7 +110,7 @@ abstract class AutowireUtils {
 		}
 		// It was declared by CGLIB, but we might still want to autowire it
 		// if it was actually declared by the superclass.
-		Class superclass = wm.getDeclaringClass().getSuperclass();
+		Class<?> superclass = wm.getDeclaringClass().getSuperclass();
 		return !ClassUtils.hasMethod(superclass, wm.getName(), wm.getParameterTypes());
 	}
 
@@ -121,7 +121,7 @@ abstract class AutowireUtils {
 	 * @param interfaces the Set of interfaces (Class objects)
 	 * @return whether the setter method is defined by an interface
 	 */
-	public static boolean isSetterDefinedInInterface(PropertyDescriptor pd, Set<Class> interfaces) {
+	public static boolean isSetterDefinedInInterface(PropertyDescriptor pd, Set<Class<?>> interfaces) {
 		Method setter = pd.getWriteMethod();
 		if (setter != null) {
 			Class<?> targetClass = setter.getDeclaringClass();
@@ -144,10 +144,10 @@ abstract class AutowireUtils {
 	 */
 	public static Object resolveAutowiringValue(Object autowiringValue, Class<?> requiredType) {
 		if (autowiringValue instanceof ObjectFactory && !requiredType.isInstance(autowiringValue)) {
-			ObjectFactory factory = (ObjectFactory) autowiringValue;
+			ObjectFactory<?> factory = (ObjectFactory<?>) autowiringValue;
 			if (autowiringValue instanceof Serializable && requiredType.isInterface()) {
 				autowiringValue = Proxy.newProxyInstance(requiredType.getClassLoader(),
-						new Class[] {requiredType}, new ObjectFactoryDelegatingInvocationHandler(factory));
+						new Class<?>[] {requiredType}, new ObjectFactoryDelegatingInvocationHandler(factory));
 			}
 			else {
 				return factory.getObject();
@@ -281,9 +281,9 @@ abstract class AutowireUtils {
 	@SuppressWarnings("serial")
 	private static class ObjectFactoryDelegatingInvocationHandler implements InvocationHandler, Serializable {
 
-		private final ObjectFactory objectFactory;
+		private final ObjectFactory<?> objectFactory;
 
-		public ObjectFactoryDelegatingInvocationHandler(ObjectFactory objectFactory) {
+		public ObjectFactoryDelegatingInvocationHandler(ObjectFactory<?> objectFactory) {
 			this.objectFactory = objectFactory;
 		}
 

spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -84,7 +84,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);
 
 	/** Cache of singleton factories: bean name --> ObjectFactory */
-	private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>(16);
+	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
 
 	/** Cache of early singleton objects: bean name --> bean instance */
 	private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
@@ -181,7 +181,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 			synchronized (this.singletonObjects) {
 				singletonObject = this.earlySingletonObjects.get(beanName);
 				if (singletonObject == null && allowEarlyReference) {
-					ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
+					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
 					if (singletonFactory != null) {
 						singletonObject = singletonFactory.getObject();
 						this.earlySingletonObjects.put(beanName, singletonObject);
@@ -201,7 +201,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	 * with, if necessary
 	 * @return the registered singleton object
 	 */
-	public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
+	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
 		Assert.notNull(beanName, "'beanName' must not be null");
 		synchronized (this.singletonObjects) {
 			Object singletonObject = this.singletonObjects.get(beanName);

spring-beans/src/main/java/org/springframework/beans/factory/support/FactoryBeanRegistrySupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -52,11 +52,11 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
 	 * @return the FactoryBean's object type,
 	 * or {@code null} if the type cannot be determined yet
 	 */
-	protected Class getTypeForFactoryBean(final FactoryBean factoryBean) {
+	protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
 		try {
 			if (System.getSecurityManager() != null) {
-				return AccessController.doPrivileged(new PrivilegedAction<Class>() {
+				return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
-					public Class run() {
+					public Class<?> run() {
 						return factoryBean.getObjectType();
 					}
 				}, getAccessControlContext());
@@ -120,7 +120,7 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
 	 * @see org.springframework.beans.factory.FactoryBean#getObject()
 	 */
 	private Object doGetObjectFromFactoryBean(
-			final FactoryBean factory, final String beanName, final boolean shouldPostProcess)
+			final FactoryBean<?> factory, final String beanName, final boolean shouldPostProcess)
 			throws BeanCreationException {
 
 		Object object;
@@ -190,12 +190,12 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
 	 * @return the bean instance as FactoryBean
 	 * @throws BeansException if the given bean cannot be exposed as a FactoryBean
 	 */
-	protected FactoryBean getFactoryBean(String beanName, Object beanInstance) throws BeansException {
+	protected FactoryBean<?> getFactoryBean(String beanName, Object beanInstance) throws BeansException {
 		if (!(beanInstance instanceof FactoryBean)) {
 			throw new BeanCreationException(beanName,
 					"Bean instance of type [" + beanInstance.getClass() + "] is not a FactoryBean");
 		}
-		return (FactoryBean) beanInstance;
+		return (FactoryBean<?>) beanInstance;
 	}
 
 	/**

spring-beans/src/test/java/org/springframework/beans/factory/xml/FactoryMethods.java

@@ -55,11 +55,11 @@ public class FactoryMethods {
 		return new FactoryMethods(tb, name, num);
 	}
 
-	static FactoryMethods newInstance(TestBean tb, int num, Integer something) {
+	static ExtendedFactoryMethods newInstance(TestBean tb, int num, Integer something) {
 		if (something != null) {
 			throw new IllegalStateException("Should never be called with non-null value");
 		}
-		return new FactoryMethods(tb, null, num);
+		return new ExtendedFactoryMethods(tb, null, num);
 	}
 
 	@SuppressWarnings("unused")
@@ -120,4 +120,12 @@ public class FactoryMethods {
 		this.name = name;
 	}
 
+
+	public static class ExtendedFactoryMethods extends FactoryMethods {
+
+		ExtendedFactoryMethods(TestBean tb, String name, int num) {
+			super(tb, name, num);
+		}
+	}
+
 }

spring-core/src/main/java/org/springframework/util/ClassUtils.java

@@ -1155,6 +1155,39 @@ public abstract class ClassUtils {
 		return Proxy.getProxyClass(classLoader, interfaces);
 	}
 
+	/**
+	 * Determine the common ancestor of the given classes, if any.
+	 * @param clazz1 the class to introspect
+	 * @param clazz2 the other class to introspect
+	 * @return the common ancestor (i.e. common superclass, one interface
+	 * extending the other), or {@code null} if none found. If any of the
+	 * given classes is {@code null}, the other class will be returned.
+	 * @since 3.2.6
+	 */
+	public static Class<?> determineCommonAncestor(Class<?> clazz1, Class<?> clazz2) {
+		if (clazz1 == null) {
+			return clazz2;
+		}
+		if (clazz2 == null) {
+			return clazz1;
+		}
+		if (clazz1.isAssignableFrom(clazz2)) {
+			return clazz1;
+		}
+		if (clazz2.isAssignableFrom(clazz1)) {
+			return clazz2;
+		}
+		Class<?> ancestor = clazz1;
+		do {
+			ancestor = ancestor.getSuperclass();
+			if (ancestor == null || Object.class.equals(ancestor)) {
+				return null;
+			}
+		}
+		while (!ancestor.isAssignableFrom(clazz2));
+		return ancestor;
+	}
+
 	/**
 	 * Check whether the given class is visible in the given ClassLoader.
 	 * @param clazz the class to check (typically an interface)

spring-core/src/test/java/org/springframework/util/ClassUtilsTests.java

@@ -20,41 +20,48 @@ import java.io.Serializable;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
-
+import java.util.Set;
-import junit.framework.TestCase;
 
 import org.springframework.tests.sample.objects.DerivedTestObject;
 import org.springframework.tests.sample.objects.ITestInterface;
 import org.springframework.tests.sample.objects.ITestObject;
 import org.springframework.tests.sample.objects.TestObject;
 
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
 /**
  * @author Colin Sampaleanu
  * @author Juergen Hoeller
  * @author Rob Harrop
  * @author Rick Evans
  */
-public class ClassUtilsTests extends TestCase {
+public class ClassUtilsTests {
 
 	private ClassLoader classLoader = getClass().getClassLoader();
 
-	@Override
+	@Before
 	public void setUp() {
 		InnerClass.noArgCalled = false;
 		InnerClass.argCalled = false;
 		InnerClass.overloadedCalled = false;
 	}
 
+	@Test
 	public void testIsPresent() throws Exception {
 		assertTrue(ClassUtils.isPresent("java.lang.String", classLoader));
 		assertFalse(ClassUtils.isPresent("java.lang.MySpecialString", classLoader));
 	}
 
+	@Test
 	public void testForName() throws ClassNotFoundException {
 		assertEquals(String.class, ClassUtils.forName("java.lang.String", classLoader));
 		assertEquals(String[].class, ClassUtils.forName("java.lang.String[]", classLoader));
@@ -69,6 +76,7 @@ public class ClassUtilsTests extends TestCase {
 		assertEquals(short[][][].class, ClassUtils.forName("[[[S", classLoader));
 	}
 
+	@Test
 	public void testForNameWithPrimitiveClasses() throws ClassNotFoundException {
 		assertEquals(boolean.class, ClassUtils.forName("boolean", classLoader));
 		assertEquals(byte.class, ClassUtils.forName("byte", classLoader));
@@ -81,6 +89,7 @@ public class ClassUtilsTests extends TestCase {
 		assertEquals(void.class, ClassUtils.forName("void", classLoader));
 	}
 
+	@Test
 	public void testForNameWithPrimitiveArrays() throws ClassNotFoundException {
 		assertEquals(boolean[].class, ClassUtils.forName("boolean[]", classLoader));
 		assertEquals(byte[].class, ClassUtils.forName("byte[]", classLoader));
@@ -92,6 +101,7 @@ public class ClassUtilsTests extends TestCase {
 		assertEquals(double[].class, ClassUtils.forName("double[]", classLoader));
 	}
 
+	@Test
 	public void testForNameWithPrimitiveArraysInternalName() throws ClassNotFoundException {
 		assertEquals(boolean[].class, ClassUtils.forName(boolean[].class.getName(), classLoader));
 		assertEquals(byte[].class, ClassUtils.forName(byte[].class.getName(), classLoader));
@@ -103,76 +113,91 @@ public class ClassUtilsTests extends TestCase {
 		assertEquals(double[].class, ClassUtils.forName(double[].class.getName(), classLoader));
 	}
 
+	@Test
 	public void testGetShortName() {
 		String className = ClassUtils.getShortName(getClass());
 		assertEquals("Class name did not match", "ClassUtilsTests", className);
 	}
 
+	@Test
 	public void testGetShortNameForObjectArrayClass() {
 		String className = ClassUtils.getShortName(Object[].class);
 		assertEquals("Class name did not match", "Object[]", className);
 	}
 
+	@Test
 	public void testGetShortNameForMultiDimensionalObjectArrayClass() {
 		String className = ClassUtils.getShortName(Object[][].class);
 		assertEquals("Class name did not match", "Object[][]", className);
 	}
 
+	@Test
 	public void testGetShortNameForPrimitiveArrayClass() {
 		String className = ClassUtils.getShortName(byte[].class);
 		assertEquals("Class name did not match", "byte[]", className);
 	}
 
+	@Test
 	public void testGetShortNameForMultiDimensionalPrimitiveArrayClass() {
 		String className = ClassUtils.getShortName(byte[][][].class);
 		assertEquals("Class name did not match", "byte[][][]", className);
 	}
 
+	@Test
 	public void testGetShortNameForInnerClass() {
 		String className = ClassUtils.getShortName(InnerClass.class);
 		assertEquals("Class name did not match", "ClassUtilsTests.InnerClass", className);
 	}
 
+	@Test
 	public void testGetShortNameAsProperty() {
 		String shortName = ClassUtils.getShortNameAsProperty(this.getClass());
 		assertEquals("Class name did not match", "classUtilsTests", shortName);
 	}
 
+	@Test
 	public void testGetClassFileName() {
 		assertEquals("String.class", ClassUtils.getClassFileName(String.class));
 		assertEquals("ClassUtilsTests.class", ClassUtils.getClassFileName(getClass()));
 	}
 
+	@Test
 	public void testGetPackageName() {
 		assertEquals("java.lang", ClassUtils.getPackageName(String.class));
 		assertEquals(getClass().getPackage().getName(), ClassUtils.getPackageName(getClass()));
 	}
 
+	@Test
 	public void testGetQualifiedName() {
 		String className = ClassUtils.getQualifiedName(getClass());
 		assertEquals("Class name did not match", "org.springframework.util.ClassUtilsTests", className);
 	}
 
+	@Test
 	public void testGetQualifiedNameForObjectArrayClass() {
 		String className = ClassUtils.getQualifiedName(Object[].class);
 		assertEquals("Class name did not match", "java.lang.Object[]", className);
 	}
 
+	@Test
 	public void testGetQualifiedNameForMultiDimensionalObjectArrayClass() {
 		String className = ClassUtils.getQualifiedName(Object[][].class);
 		assertEquals("Class name did not match", "java.lang.Object[][]", className);
 	}
 
+	@Test
 	public void testGetQualifiedNameForPrimitiveArrayClass() {
 		String className = ClassUtils.getQualifiedName(byte[].class);
 		assertEquals("Class name did not match", "byte[]", className);
 	}
 
+	@Test
 	public void testGetQualifiedNameForMultiDimensionalPrimitiveArrayClass() {
 		String className = ClassUtils.getQualifiedName(byte[][].class);
 		assertEquals("Class name did not match", "byte[][]", className);
 	}
 
+	@Test
 	public void testHasMethod() throws Exception {
 		assertTrue(ClassUtils.hasMethod(Collection.class, "size"));
 		assertTrue(ClassUtils.hasMethod(Collection.class, "remove", Object.class));
@@ -180,6 +205,7 @@ public class ClassUtilsTests extends TestCase {
 		assertFalse(ClassUtils.hasMethod(Collection.class, "someOtherMethod"));
 	}
 
+	@Test
 	public void testGetMethodIfAvailable() throws Exception {
 		Method method = ClassUtils.getMethodIfAvailable(Collection.class, "size");
 		assertNotNull(method);
@@ -193,6 +219,7 @@ public class ClassUtilsTests extends TestCase {
 		assertNull(ClassUtils.getMethodIfAvailable(Collection.class, "someOtherMethod"));
 	}
 
+	@Test
 	public void testGetMethodCountForName() {
 		assertEquals("Verifying number of overloaded 'print' methods for OverloadedMethodsClass.", 2,
 				ClassUtils.getMethodCountForName(OverloadedMethodsClass.class, "print"));
@@ -200,6 +227,7 @@ public class ClassUtilsTests extends TestCase {
 				ClassUtils.getMethodCountForName(SubOverloadedMethodsClass.class, "print"));
 	}
 
+	@Test
 	public void testCountOverloadedMethods() {
 		assertFalse(ClassUtils.hasAtLeastOneMethodWithName(TestObject.class, "foobar"));
 		// no args
@@ -208,6 +236,7 @@ public class ClassUtilsTests extends TestCase {
 		assertTrue(ClassUtils.hasAtLeastOneMethodWithName(TestObject.class, "setAge"));
 	}
 
+	@Test
 	public void testNoArgsStaticMethod() throws IllegalAccessException, InvocationTargetException {
 		Method method = ClassUtils.getStaticMethod(InnerClass.class, "staticMethod", (Class[]) null);
 		method.invoke(null, (Object[]) null);
@@ -215,6 +244,7 @@ public class ClassUtilsTests extends TestCase {
 				InnerClass.noArgCalled);
 	}
 
+	@Test
 	public void testArgsStaticMethod() throws IllegalAccessException, InvocationTargetException {
 		Method method = ClassUtils.getStaticMethod(InnerClass.class, "argStaticMethod",
 				new Class[] {String.class});
@@ -222,6 +252,7 @@ public class ClassUtilsTests extends TestCase {
 		assertTrue("argument method was not invoked.", InnerClass.argCalled);
 	}
 
+	@Test
 	public void testOverloadedStaticMethod() throws IllegalAccessException, InvocationTargetException {
 		Method method = ClassUtils.getStaticMethod(InnerClass.class, "staticMethod",
 				new Class[] {String.class});
@@ -230,6 +261,7 @@ public class ClassUtilsTests extends TestCase {
 				InnerClass.overloadedCalled);
 	}
 
+	@Test
 	public void testIsAssignable() {
 		assertTrue(ClassUtils.isAssignable(Object.class, Object.class));
 		assertTrue(ClassUtils.isAssignable(String.class, String.class));
@@ -245,11 +277,13 @@ public class ClassUtilsTests extends TestCase {
 		assertFalse(ClassUtils.isAssignable(double.class, Integer.class));
 	}
 
+	@Test
 	public void testClassPackageAsResourcePath() {
 		String result = ClassUtils.classPackageAsResourcePath(Proxy.class);
 		assertTrue(result.equals("java/lang/reflect"));
 	}
 
+	@Test
 	public void testAddResourcePathToPackagePath() {
 		String result = "java/lang/reflect/xyzabc.xml";
 		assertEquals(result, ClassUtils.addResourcePathToPackagePath(Proxy.class, "xyzabc.xml"));
@@ -259,6 +293,7 @@ public class ClassUtilsTests extends TestCase {
 				ClassUtils.addResourcePathToPackagePath(Proxy.class, "a/b/c/d.xml"));
 	}
 
+	@Test
 	public void testGetAllInterfaces() {
 		DerivedTestObject testBean = new DerivedTestObject();
 		List ifcs = Arrays.asList(ClassUtils.getAllInterfaces(testBean));
@@ -268,6 +303,7 @@ public class ClassUtilsTests extends TestCase {
 		assertTrue("Contains IOther", ifcs.contains(ITestInterface.class));
 	}
 
+	@Test
 	public void testClassNamesToString() {
 		List ifcs = new LinkedList();
 		ifcs.add(Serializable.class);
@@ -288,6 +324,36 @@ public class ClassUtilsTests extends TestCase {
 		assertEquals("[]", ClassUtils.classNamesToString(Collections.EMPTY_LIST));
 	}
 
+	@Test
+	public void testDetermineCommonAncestor() {
+		assertEquals(Number.class, ClassUtils.determineCommonAncestor(Integer.class, Number.class));
+		assertEquals(Number.class, ClassUtils.determineCommonAncestor(Number.class, Integer.class));
+		assertEquals(Number.class, ClassUtils.determineCommonAncestor(Number.class, null));
+		assertEquals(Integer.class, ClassUtils.determineCommonAncestor(null, Integer.class));
+		assertEquals(Integer.class, ClassUtils.determineCommonAncestor(Integer.class, Integer.class));
+
+		assertEquals(Number.class, ClassUtils.determineCommonAncestor(Integer.class, Float.class));
+		assertEquals(Number.class, ClassUtils.determineCommonAncestor(Float.class, Integer.class));
+		assertNull(ClassUtils.determineCommonAncestor(Integer.class, String.class));
+		assertNull(ClassUtils.determineCommonAncestor(String.class, Integer.class));
+
+		assertEquals(Collection.class, ClassUtils.determineCommonAncestor(List.class, Collection.class));
+		assertEquals(Collection.class, ClassUtils.determineCommonAncestor(Collection.class, List.class));
+		assertEquals(Collection.class, ClassUtils.determineCommonAncestor(Collection.class, null));
+		assertEquals(List.class, ClassUtils.determineCommonAncestor(null, List.class));
+		assertEquals(List.class, ClassUtils.determineCommonAncestor(List.class, List.class));
+
+		assertNull(ClassUtils.determineCommonAncestor(List.class, Set.class));
+		assertNull(ClassUtils.determineCommonAncestor(Set.class, List.class));
+		assertNull(ClassUtils.determineCommonAncestor(List.class, Runnable.class));
+		assertNull(ClassUtils.determineCommonAncestor(Runnable.class, List.class));
+
+		assertEquals(List.class, ClassUtils.determineCommonAncestor(List.class, ArrayList.class));
+		assertEquals(List.class, ClassUtils.determineCommonAncestor(ArrayList.class, List.class));
+		assertNull(ClassUtils.determineCommonAncestor(List.class, String.class));
+		assertNull(ClassUtils.determineCommonAncestor(String.class, List.class));
+	}
+
 
 	public static class InnerClass {