root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Fixed type resolution for uninitialized factory-method declaration 

Issue: SPR-11112
(cherry picked from commit 5dcd287)
This commit is contained in:
Juergen Hoeller 2013-12-10 13:12:32 +01:00
parent 71650c0a44
commit 8e52e650f4
7 changed files with 151 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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 =
new ConcurrentHashMap<Class, PropertyDescriptor[]>(64);
private final Map<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
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);
}

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

@ -56,9 +56,9 @@ abstract class AutowireUtils {
* decreasing number of arguments.
* @param constructors the constructor array to sort
*/
public static void sortConstructors(Constructor[] constructors) {
Arrays.sort(constructors, new Comparator<Constructor>() {
public int compare(Constructor c1, Constructor c2) {
public static void sortConstructors(Constructor<?>[] constructors) {
Arrays.sort(constructors, new Comparator<Constructor<?>>() {
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;
}

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

@ -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);

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

@ -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>() {
public Class run() {
return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
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;
}
/**

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

@ -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);
}
}
}

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

@ -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)

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

@ -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 junit.framework.TestCase;
import java.util.Set;
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 {