/** * Resolve current method generic return type to a {@link GenericMetadataSupport}. * * @param method Method to resolve the return type. * @return {@link GenericMetadataSupport} representing this generic return type. */ public GenericMetadataSupport resolveGenericReturnType(Method method) { Type genericReturnType = method.getGenericReturnType(); // logger.log("Method '" + method.toGenericString() + "' has return type : " + // genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " + genericReturnType); if (genericReturnType instanceof Class) { return new NotGenericReturnTypeSupport(genericReturnType); } if (genericReturnType instanceof ParameterizedType) { return new ParameterizedReturnType( this, method.getTypeParameters(), (ParameterizedType) method.getGenericReturnType()); } if (genericReturnType instanceof TypeVariable) { return new TypeVariableReturnType( this, method.getTypeParameters(), (TypeVariable) genericReturnType); } throw new MockitoException( "Ouch, it shouldn't happen, type '" + genericReturnType.getClass().getCanonicalName() + "' on method : '" + method.toGenericString() + "' is not supported : " + genericReturnType); }
public static Class<?> determineGenericsType(Type type) { Class<?> result = null; if (type != null && ParameterizedType.class.isAssignableFrom(type.getClass())) { Type genericType = ((ParameterizedType) type).getActualTypeArguments()[0]; if (genericType != null) { result = (Class<?>) genericType; } } return result; }
/** * Create an new instance of {@link GenericMetadataSupport} inferred from a {@link Type}. * * <p>At the moment <code>type</code> can only be a {@link Class} or a {@link ParameterizedType}, * otherwise it'll throw a {@link MockitoException}. * * @param type The class from which the {@link GenericMetadataSupport} should be built. * @return The new {@link GenericMetadataSupport}. * @throws MockitoException Raised if type is not a {@link Class} or a {@link ParameterizedType}. */ public static GenericMetadataSupport inferFrom(Type type) { Checks.checkNotNull(type, "type"); if (type instanceof Class) { return new FromClassGenericMetadataSupport((Class<?>) type); } if (type instanceof ParameterizedType) { return new FromParameterizedTypeGenericMetadataSupport((ParameterizedType) type); } throw new MockitoException( "Type meta-data for this Type (" + type.getClass().getCanonicalName() + ") is not supported : " + type); }
public TypeList(Type t) { myclass = t.getClass(); instances = new SafeArrayList<Type>(Type.class); hash = new Hashtable<String, Type>(); }