/*
* Copyright 2009 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.uibinder.rebind;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.when;
import com.google.gwt.core.ext.typeinfo.HasAnnotations;
import com.google.gwt.core.ext.typeinfo.HasTypeParameters;
import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JConstructor;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* Creates stub adapters for GWT reflection using EasyMock.
* This takes in a real java reflection class and returns a JClassType which
* forwards all its method calls to the equivalent java reflection methods.
* <p>
* Most reflections are done lazily (only when the method is actually called),
* specially those which potentially require mocking a new class / method /
* field / parameter / constructor / etc.
* <p>
* The support for the typeinfo API is still incomplete, and in fact will
* always be in some way since Java doesn't support all the reflections that
* GWT's typeinfo does.
* <p>
* TODO: With a bit of generalization, this class should make its way
* to core/src/com/google/gwt/junit
*
* To make it public we need to...
* <ol>
* <li>implement the missing parts and TODOs (e.g. generics)
* <li>add tests to it (even though it's a testing utility, it does need
* tests, specially for cases like inner and anonymous classes, generic
* parameters, etc.)
* <li>decide what to do with the parts of JType reflection that java doesn't
* have an equivalent for - e.g. parameter names. This may involve making a
* slightly more complex API to inject those values.
* </ol>
*/
public class JClassTypeAdapter {
private final Map<Class<?>, JClassType> adaptedClasses =
new HashMap<Class<?>, JClassType>();
private final List<Object> allMocks = new ArrayList<Object>();
/**
* Creates a mock GWT class type for the given Java class.
*
* @param clazz the java class
* @return the gwt class
*/
public JClassType adaptJavaClass(final Class<?> clazz) {
if (clazz.isPrimitive()) {
throw new RuntimeException(
"Only classes can be passed to adaptJavaClass");
}
// First try the cache (also avoids infinite recursion if a type references
// itself).
JClassType type = adaptedClasses.get(clazz);
if (type != null) {
return type;
}
// Create and put in the cache
type = createMock(JClassType.class);
final JClassType finalType = type;
adaptedClasses.put(clazz, type);
// Adds behaviour for annotations and generics
addAnnotationBehaviour(clazz, type);
// TODO(rdamazio): Add generics behaviour
// Add behaviour for getting methods
when(type.getMethods()).thenAnswer(new Answer<JMethod[]>() {
@Override
public JMethod[] answer(InvocationOnMock invocation) throws Throwable {
Method[] realMethods = clazz.getDeclaredMethods();
JMethod[] methods = new JMethod[realMethods.length];
for (int i = 0; i < realMethods.length; i++) {
methods[i] = adaptMethod(realMethods[i], finalType);
}
return methods;
}
});
// Add behaviour for getting constructors
when(type.getConstructors()).thenAnswer(new Answer<JConstructor[]>() {
@Override
public JConstructor[] answer(InvocationOnMock invocation) throws Throwable {
Constructor<?>[] realConstructors = clazz.getDeclaredConstructors();
JConstructor[] constructors = new JConstructor[realConstructors.length];
for (int i = 0; i < realConstructors.length; i++) {
constructors[i] = adaptConstructor(realConstructors[i], finalType);
}
return constructors;
}
});
// Add behaviour for getting fields
when(type.getFields()).thenAnswer(new Answer<JField[]>() {
@Override
public JField[] answer(InvocationOnMock invocation) throws Throwable {
Field[] realFields = clazz.getDeclaredFields();
JField[] fields = new JField[realFields.length];
for (int i = 0; i < realFields.length; i++) {
fields[i] = adaptField(realFields[i], finalType);
}
return fields;
}
});
// Add behaviour for getting names
when(type.getName()).thenReturn(clazz.getName());
when(type.getQualifiedSourceName()).thenReturn(
clazz.getCanonicalName());
when(type.getSimpleSourceName()).thenReturn(clazz.getSimpleName());
// Add modifier behaviour
int modifiers = clazz.getModifiers();
when(type.isAbstract()).thenReturn(Modifier.isAbstract(modifiers));
when(type.isFinal()).thenReturn(Modifier.isFinal(modifiers));
when(type.isPublic()).thenReturn(Modifier.isPublic(modifiers));
when(type.isProtected()).thenReturn(Modifier.isProtected(modifiers));
when(type.isPrivate()).thenReturn(Modifier.isPrivate(modifiers));
// Add conversion behaviours
when(type.isArray()).thenReturn(null);
when(type.isEnum()).thenReturn(null);
when(type.isPrimitive()).thenReturn(null);
when(type.isClassOrInterface()).thenReturn(type);
if (clazz.isInterface()) {
when(type.isClass()).thenReturn(null);
when(type.isInterface()).thenReturn(type);
} else {
when(type.isClass()).thenReturn(type);
when(type.isInterface()).thenReturn(null);
}
when(type.getEnclosingType()).thenAnswer(new Answer<JClassType>() {
@Override
public JClassType answer(InvocationOnMock invocation) throws Throwable {
Class<?> enclosingClass = clazz.getEnclosingClass();
if (enclosingClass == null) {
return null;
}
return adaptJavaClass(enclosingClass);
}
});
when(type.getSuperclass()).thenAnswer(new Answer<JClassType>() {
@Override
public JClassType answer(InvocationOnMock invocation) throws Throwable {
Class<?> superclass = clazz.getSuperclass();
if (superclass == null) {
return null;
}
return adaptJavaClass(superclass);
}
});
when(type.getImplementedInterfaces()).thenAnswer(new Answer<JClassType[]>() {
@Override
public JClassType[] answer(InvocationOnMock invocation) throws Throwable {
Class<?>[] interfaces = clazz.getInterfaces();
if ((interfaces == null) || (interfaces.length == 0)) {
return null;
}
JClassType[] adaptedInterfaces = new JClassType[interfaces.length];
for (int i = 0; i < interfaces.length; i++) {
adaptedInterfaces[i] = adaptJavaClass(interfaces[i]);
}
return adaptedInterfaces;
}
});
when(type.getFlattenedSupertypeHierarchy()).thenAnswer(new Answer<Set<JClassType>>() {
@Override
public Set<JClassType> answer(InvocationOnMock invocation) throws Throwable {
return flatten(clazz);
}
private Set<JClassType> flatten(Class<?> clazz) {
Set<JClassType> flattened = new LinkedHashSet<JClassType>();
flattened.add(adaptJavaClass(clazz));
for (Class<?> intf : clazz.getInterfaces()) {
flattened.addAll(flatten(intf));
}
Class<?> superClass = clazz.getSuperclass();
if (superClass != null) {
flattened.addAll(flatten(superClass));
}
return flattened;
}
});
when(type.getInheritableMethods()).thenAnswer(new Answer<JMethod[]>() {
@Override
public JMethod[] answer(InvocationOnMock invocation) throws Throwable {
Map<String, Method> methodsBySignature = new TreeMap<String, Method>();
getInheritableMethodsOnSuperinterfacesAndMaybeThisInterface(clazz, methodsBySignature);
if (!clazz.isInterface()) {
getInheritableMethodsOnSuperclassesAndThisClass(clazz, methodsBySignature);
}
int size = methodsBySignature.size();
if (size == 0) {
return new JMethod[0];
} else {
Iterator<Method> leafMethods = methodsBySignature.values().iterator();
JMethod[] jMethods = new JMethod[size];
for (int i = 0; i < size; i++) {
Method method = leafMethods.next();
jMethods[i] = adaptMethod(method, adaptJavaClass(method.getDeclaringClass()));
}
return jMethods;
}
}
protected void getInheritableMethodsOnSuperinterfacesAndMaybeThisInterface(
Class<?> clazz,
Map<String, Method> methodsBySignature) {
// Recurse first so that more derived methods will clobber less derived
// methods.
Class<?>[] superIntfs = clazz.getInterfaces();
for (Class<?> superIntf : superIntfs) {
getInheritableMethodsOnSuperinterfacesAndMaybeThisInterface(
superIntf,
methodsBySignature);
}
Method[] declaredMethods = clazz.getMethods();
for (Method method : declaredMethods) {
String sig = computeInternalSignature(method);
Method existing = methodsBySignature.get(sig);
if (existing != null) {
Class<?> existingType = existing.getDeclaringClass();
Class<?> thisType = method.getDeclaringClass();
if (thisType.isAssignableFrom(existingType)) {
// The existing method is in a more-derived type, so don't replace it.
continue;
}
}
methodsBySignature.put(sig, method);
}
}
protected void getInheritableMethodsOnSuperclassesAndThisClass(
Class<?> clazz,
Map<String, Method> methodsBySignature) {
// Recurse first so that more derived methods will clobber less derived
// methods.
Class<?> superClass = clazz.getSuperclass();
if (superClass != null) {
getInheritableMethodsOnSuperclassesAndThisClass(
superClass,
methodsBySignature);
}
Method[] declaredMethods = clazz.getMethods();
for (Method method : declaredMethods) {
// Ensure that this method is inheritable.
if (Modifier.isPrivate(method.getModifiers())
|| Modifier.isStatic(method.getModifiers())) {
// We cannot inherit this method, so skip it.
continue;
}
// We can override this method, so record it.
String sig = computeInternalSignature(method);
methodsBySignature.put(sig, method);
}
}
private String computeInternalSignature(Method method) {
StringBuilder sb = new StringBuilder();
sb.setLength(0);
sb.append(method.getName());
Class<?>[] params = method.getParameterTypes();
for (Class<?> param : params) {
sb.append("/");
sb.append(param.getName());
}
return sb.toString();
}
});
// TODO(rdamazio): Mock out other methods as needed
// TODO(rdamazio): Figure out what to do with reflections that GWT allows
// but Java doesn't
return type;
}
/**
* Creates a mock GWT field for the given Java field.
*
* @param realField the java field
* @param enclosingType the GWT enclosing type
* @return the GWT field
*/
public JField adaptField(final Field realField, JClassType enclosingType) {
JField field = createMock(JField.class);
addAnnotationBehaviour(realField, field);
when(field.getType()).thenAnswer(new Answer<JType>() {
@Override
public JType answer(InvocationOnMock invocation) throws Throwable {
return adaptType(realField.getType());
}
});
when(field.getEnclosingType()).thenReturn(enclosingType);
when(field.getName()).thenReturn(realField.getName());
return field;
}
/**
* Creates a mock GWT constructor for the given java constructor.
*
* @param realConstructor the java constructor
* @param enclosingType the type to which the constructor belongs
* @return the GWT constructor
*/
private JConstructor adaptConstructor(final Constructor<?> realConstructor,
JClassType enclosingType) {
final JConstructor constructor = createMock(JConstructor.class);
addCommonAbstractMethodBehaviour(realConstructor, constructor,
enclosingType);
addAnnotationBehaviour(realConstructor, constructor);
// Parameters
when(constructor.getParameters()).thenAnswer(
new Answer<JParameter[]>() {
@Override
public JParameter[] answer(InvocationOnMock invocation) throws Throwable {
return adaptParameters(realConstructor.getParameterTypes(),
realConstructor.getParameterAnnotations(), constructor);
}
});
// Thrown exceptions
when(constructor.getThrows()).thenAnswer(
new Answer<JClassType[]>() {
@Override
public JClassType[] answer(InvocationOnMock invocation) throws Throwable {
Class<?>[] realThrows = realConstructor.getExceptionTypes();
JClassType[] gwtThrows = new JClassType[realThrows.length];
for (int i = 0; i < realThrows.length; i++) {
gwtThrows[i] = (JClassType) adaptType(realThrows[i]);
}
return gwtThrows;
}
});
return constructor;
}
/**
* Creates a mock GWT method for the given java method.
*
* @param realMethod the java method
* @param enclosingType the type to which the method belongs
* @return the GWT method
*/
private JMethod adaptMethod(final Method realMethod,
JClassType enclosingType) {
// TODO(rdamazio): ensure a single instance per method per class
final JMethod method = createMock(JMethod.class);
addCommonAbstractMethodBehaviour(realMethod, method, enclosingType);
addAnnotationBehaviour(realMethod, method);
addGenericsBehaviour(realMethod, method);
when(method.isStatic()).thenReturn(
Modifier.isStatic(realMethod.getModifiers()));
// Return type
when(method.getReturnType()).thenAnswer(new Answer<JType>() {
@Override
public JType answer(InvocationOnMock invocation) throws Throwable {
return adaptType(realMethod.getReturnType());
}
});
// Parameters
when(method.getParameters()).thenAnswer(new Answer<JParameter[]>() {
@Override
public JParameter[] answer(InvocationOnMock invocation) throws Throwable {
return adaptParameters(realMethod.getParameterTypes(),
realMethod.getParameterAnnotations(), method);
}
});
// Thrown exceptions
when(method.getThrows()).thenAnswer(new Answer<JClassType[]>() {
@Override
public JClassType[] answer(InvocationOnMock invocation) throws Throwable {
Class<?>[] realThrows = realMethod.getExceptionTypes();
JClassType[] gwtThrows = new JClassType[realThrows.length];
for (int i = 0; i < realThrows.length; i++) {
gwtThrows[i] = (JClassType) adaptType(realThrows[i]);
}
return gwtThrows;
}
});
return method;
}
/**
* Creates an array of mock GWT parameters for the given array of java
* parameters.
*
* @param parameterTypes the types of the parameters
* @param parameterAnnotations the list of annotations for each parameter
* @param method the method or constructor to which the parameters belong
* @return an array of GWT parameters
*/
@SuppressWarnings("unchecked")
protected JParameter[] adaptParameters(Class<?>[] parameterTypes,
Annotation[][] parameterAnnotations, JAbstractMethod method) {
JParameter[] parameters = new JParameter[parameterTypes.length];
for (int i = 0; i < parameterTypes.length; i++) {
final Class<?> realParameterType = parameterTypes[i];
JParameter parameter = createMock(JParameter.class);
parameters[i] = parameter;
// TODO(rdamazio): getName() has no plain java equivalent.
// Perhaps compiling with -g:vars ?
when(parameter.getEnclosingMethod()).thenReturn(method);
when(parameter.getType()).thenAnswer(new Answer<JType>() {
@Override
public JType answer(InvocationOnMock invocation) throws Throwable {
return adaptType(realParameterType);
}
});
// Add annotation behaviour
final Annotation[] annotations = parameterAnnotations[i];
when(parameter.isAnnotationPresent(any(Class.class))).thenAnswer(
new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
Class<? extends Annotation> annotationClass =
(Class<? extends Annotation>)
invocation.getArguments()[0];
for (Annotation annotation : annotations) {
if (annotation.equals(annotationClass)) {
return true;
}
}
return false;
}
});
when(parameter.getAnnotation(any(Class.class))).thenAnswer(
new Answer<Annotation>() {
@Override
public Annotation answer(InvocationOnMock invocation) throws Throwable {
Class<? extends Annotation> annotationClass =
(Class<? extends Annotation>)
invocation.getArguments()[0];
for (Annotation annotation : annotations) {
if (annotation.equals(annotationClass)) {
return annotation;
}
}
return null;
}
});
}
return parameters;
}
/**
* Creates a GWT mock type for the given java type.
* The type can be a class or a primitive type.
*
* @param type the java type
* @return the GWT type
*/
private JType adaptType(Class<?> type) {
if (!type.isPrimitive()) {
return adaptJavaClass(type);
} else {
return adaptPrimitiveType(type);
}
}
/**
* Returns the GWT primitive type for the given java primitive type.
*
* @param type the java primitive type
* @return the GWT primitive equivalent
*/
private JType adaptPrimitiveType(Class<?> type) {
if (boolean.class.equals(type)) { return JPrimitiveType.BOOLEAN; }
if (int.class.equals(type)) { return JPrimitiveType.INT; }
if (char.class.equals(type)) { return JPrimitiveType.CHAR; }
if (byte.class.equals(type)) { return JPrimitiveType.BYTE; }
if (long.class.equals(type)) { return JPrimitiveType.LONG; }
if (short.class.equals(type)) { return JPrimitiveType.SHORT; }
if (float.class.equals(type)) { return JPrimitiveType.FLOAT; }
if (double.class.equals(type)) { return JPrimitiveType.DOUBLE; }
if (void.class.equals(type)) { return JPrimitiveType.VOID; }
throw new IllegalArgumentException(
"Invalid primitive type: " + type.getName());
}
/**
* Adds expectations common to all method types (methods and constructors).
*
* @param realMember the java method
* @param member the mock GWT method
* @param enclosingType the type to which the method belongs
*/
private void addCommonAbstractMethodBehaviour(Member realMember,
JAbstractMethod member, JClassType enclosingType) {
// Attributes
int modifiers = realMember.getModifiers();
when(member.isPublic()).thenReturn(Modifier.isPublic(modifiers));
when(member.isProtected()).thenReturn(Modifier.isProtected(modifiers));
when(member.isPrivate()).thenReturn(Modifier.isPrivate(modifiers));
when(member.getName()).thenReturn(realMember.getName());
when(member.getEnclosingType()).thenReturn(enclosingType);
}
/**
* Adds expectations for getting annotations from elements (methods, classes,
* parameters, etc.).
*
* @param realElement the java element which contains annotations
* @param element the mock GWT element which contains annotations
*/
@SuppressWarnings("unchecked")
private void addAnnotationBehaviour(final AnnotatedElement realElement,
final HasAnnotations element) {
when(element.isAnnotationPresent(any(Class.class))).thenAnswer(
new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
Class<? extends Annotation> annotationClass =
(Class<? extends Annotation>) invocation.getArguments()[0];
return realElement.isAnnotationPresent(annotationClass);
}
});
when(element.getAnnotation(any(Class.class))).thenAnswer(
new Answer<Annotation>() {
@Override
public Annotation answer(InvocationOnMock invocation) throws Throwable {
Class<? extends Annotation> annotationClass =
(Class<? extends Annotation>) invocation.getArguments()[0];
return realElement.getAnnotation(annotationClass);
}
});
}
/**
* Adds expectations for getting generics types.
*
* @param realGeneric the java generic declaration
* @param generic the mock GWT generic declaration
*/
private void addGenericsBehaviour(final GenericDeclaration realGeneric,
final HasTypeParameters generic) {
// TODO(rdamazio): Implement when necessary
}
/**
* Creates a mock of the given class and adds it to the {@link #allMocks}
* member list.
*
* @param <T> the type of the mock
* @param clazz the class of the mock
* @return the mock
*/
private <T> T createMock(Class<T> clazz) {
T mock = Mockito.mock(clazz);
allMocks.add(mock);
return mock;
}
}