MemberMatcher.java

/*
 * Copyright 2009 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.
 * 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 org.powermock.api.support.membermodification;

import org.powermock.reflect.Whitebox;
import org.powermock.reflect.exceptions.*;
import org.powermock.reflect.internal.WhiteboxImpl;
import org.powermock.tests.utils.impl.ArrayMergerImpl;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import static java.util.Arrays.asList;

/**
 * Finds members in classes.
 */
public class MemberMatcher {

    /**
     * Get all methods in a class hierarchy of the supplied classes. Both
     * declared an non-declared (no duplicates).
     * 
     * @param cls
     *            The class whose methods to get.
     * @param additionalClasses
     *            Additional classes whose methods to get.
     * @return All methods declared in this class hierarchy.
     */
    public static Method[] methodsDeclaredIn(final Class<?> cls, final Class<?>... additionalClasses) {
        if (cls == null) {
            throw new IllegalArgumentException("You need to supply at least one class.");
        }
        Set<Method> methods = new HashSet<Method>();
        methods.addAll(asList(WhiteboxImpl.getAllMethods(cls)));
        for (Class<?> klass : additionalClasses) {
            methods.addAll(asList(WhiteboxImpl.getAllMethods(klass)));
        }
        return methods.toArray(new Method[methods.size()]);
    }

    /**
     * Get a method when it cannot be determined by methodName or parameter
     * types only.
     * <p>
     * The method will first try to look for a declared method in the same
     * class. If the method is not declared in this class it will look for the
     * method in the super class. This will continue throughout the whole class
     * hierarchy. If the method is not found an {@link IllegalArgumentException}
     * is thrown.
     * 
     * @param declaringClass
     *            The declaringClass of the class where the method is located.
     * @param methodName
     *            The method names.
     * @param parameterTypes
     *            All parameter types of the method (may be <code>null</code>).
     * @return A <code>java.lang.reflect.Method</code>.
     * @throws MethodNotFoundException
     *             If a method cannot be found in the hierarchy.
     */
    public static Method method(Class<?> declaringClass, String methodName, Class<?>... parameterTypes) {
        final Method method = WhiteboxImpl.findMethod(declaringClass, methodName, parameterTypes);
        WhiteboxImpl.throwExceptionIfMethodWasNotFound(declaringClass, methodName, method, (Object[]) parameterTypes);
        return method;
    }

    /**
     * Get a method without having to specify the method name.
     * <p>
     * The method will first try to look for a declared method in the same
     * class. If the method is not declared in this class it will look for the
     * method in the super class. This will continue throughout the whole class
     * hierarchy. If the method is not found an {@link IllegalArgumentException}
     * is thrown. Since the method name is not specified an
     * {@link IllegalArgumentException} is thrown if two or more methods matches
     * the same parameter types in the same class.
     * 
     * @param declaringClass
     *            The declaringClass of the class where the method is located.
     * @param parameterTypes
     *            All parameter types of the method (may be <code>null</code>).
     * @return A <code>java.lang.reflect.Method</code>.
     * @throws MethodNotFoundException
     *             If a method cannot be found in the hierarchy.
     * @throws TooManyMethodsFoundException
     *             If several methods were found.
     */
    public static Method method(Class<?> declaringClass, Class<?>... parameterTypes) {
        return Whitebox.getMethod(declaringClass, parameterTypes);
    }

    /**
     * Get an array of {@link Method}'s that matches the supplied list of method
     * names. Both instance and static methods are taken into account.
     * 
     * @param clazz
     *            The class that should contain the methods.
     * @param methodName
     *            The name of the first method.
     * @param additionalMethodNames
     *            Additional names of the methods that will be returned.
     * @return An array of Method's. May be of length 0 but not
     *         <code>null</code>.
     * @throws MethodNotFoundException
     *             If no method was found.
     */
    public static Method[] methods(Class<?> clazz, String methodName, String... additionalMethodNames) {
        return Whitebox.getMethods(clazz, merge(methodName, additionalMethodNames));
    }

    /**
     * Get an array of {@link Field}'s.
     * 
     * @param method
     *            The first field.
     * @param additionalMethods
     *            Additional fields
     * @return An array of {@link Field}.
     */
    public static Method[] methods(Method method, Method... additionalMethods) {
        return merge(method, additionalMethods);
    }

    /**
     * Get an array of {@link Method}'s that matches the supplied list of method
     * names. Both instance and static methods are taken into account.
     * 
     * @param clazz
     *            The class that should contain the methods.
     * @param methodNames
     *            The names of the methods.
     * @return An array of Method's. May be of length 0 but not
     *         <code>null</code>.
     * @throws MethodNotFoundException
     *             If no method was found.
     */
    public static Method[] methods(Class<?> clazz, String[] methodNames) {
        return Whitebox.getMethods(clazz, methodNames);
    }

    /**
     * Get a field from a class.
     * <p>
     * The method will first try to look for a declared field in the same class.
     * If the method is not declared in this class it will look for the field in
     * the super class. This will continue throughout the whole class hierarchy.
     * If the field is not found an {@link IllegalArgumentException} is thrown.
     * 
     * @param declaringClass
     *            The declaringClass of the class where the method is located.
     * @param fieldName
     *            The method names.
     * @return A <code>java.lang.reflect.Field</code>.
     * @throws FieldNotFoundException
     *             If a field cannot be found in the hierarchy.
     */
    public static Field field(Class<?> declaringClass, String fieldName) {
        return Whitebox.getField(declaringClass, fieldName);
    }

    /**
     * Get an array of {@link Field}'s that matches the supplied list of field
     * names.
     * 
     * @param clazz
     *            The class that should contain the fields.
     * @param firstFieldName
     *            The name of the first field.
     * @param additionalfieldNames
     *            The additional names of the fields that will be returned.
     * @return An array of Field's. May be of length 0 but not <code>null</code>
     * 
     */
    public static Field[] fields(Class<?> clazz, String firstFieldName, String... additionalfieldNames) {
        return Whitebox.getFields(clazz, merge(firstFieldName, additionalfieldNames));
    }

    /**
     * Get all fields in a class hierarchy.
     * 
     * @param clazz
     *            The class that should contain the fields.
     * @param firstFieldName
     *            The name of the first field.
     * @param additionalfieldNames
     *            The additional names of the fields that will be returned.
     * @return An array of Field's. May be of length 0 but not <code>null</code>
     * 
     */
    public static Field[] fields(Class<?> clazz) {
        return WhiteboxImpl.getAllFields(clazz);
    }

    /**
     * Get an array of {@link Field}'s.
     * 
     * @param field
     *            The first field.
     * @param additionalFields
     *            Additional fields
     * @return An array of {@link Field}.
     */
    public static Field[] fields(Field field, Field... additionalFields) {
        return merge(field, additionalFields);
    }

    /**
     * Get an array of {@link Field}'s that matches the supplied list of field
     * names.
     * 
     * @param clazz
     *            The class that should contain the fields.
     * @param fieldNames
     *            The names of the fields that will be returned.
     * @return An array of Field's. May be of length 0 but not <code>null</code>
     * 
     */
    public static Field[] fields(Class<?> clazz, String[] fieldNames) {
        return Whitebox.getFields(clazz, fieldNames);
    }

    /**
     * Returns a constructor specified in declaringClass.
     * 
     * @param declaringClass
     *            The declaringClass of the class where the constructor is
     *            located.
     * @param parameterTypes
     *            All parameter types of the constructor (may be
     *            <code>null</code>).
     * @return A <code>java.lang.reflect.Constructor</code>.
     * @throws ConstructorNotFoundException
     *             if the constructor cannot be found.
     */
    @SuppressWarnings("unchecked")
    public static <T> Constructor<T> constructor(Class<T> declaringClass, Class<?>... parameterTypes) {
        return (Constructor<T>) WhiteboxImpl.findUniqueConstructorOrThrowException(declaringClass,
                (Object[]) parameterTypes);
    }

    /**
     * Returns any one constructor specified in declaringClass. Is is useful when you only have ONE constructor
     * declared in <code>declaringClass</code> but you don't care which parameters it take.
     * 
     * @param declaringClass
     *            The declaringClass of the class where the constructor is
     *            located.
     * @return A <code>java.lang.reflect.Constructor</code>.
     * @throws TooManyConstructorsFoundException
     *             If more than one constructor was present in
     *             <code>declaringClass</code>
     */
    @SuppressWarnings("unchecked")
    public static <T> Constructor<T> constructor(Class<T> declaringClass) {
        return (Constructor<T>) WhiteboxImpl.findConstructorOrThrowException(declaringClass);
    }

    /**
     * Returns the default constructor in <code>declaringClass</code>
     *
     * @param declaringClass
     *            The declaringClass of the class where the constructor is
     *            located.
     * @return A <code>java.lang.reflect.Constructor</code>.
     * @throws ConstructorNotFoundException
     *             If no default constructor was found in  <code>declaringClass</code>
     */
    @SuppressWarnings("unchecked")
    public static <T> Constructor<T> defaultConstructorIn(Class<T> declaringClass) {
        return (Constructor<T>) WhiteboxImpl.findDefaultConstructorOrThrowException(declaringClass);
    }

    /**
     * Get all constructors in the supplied class(es).
     * 
     * @param cls
     *            The class whose constructors to get.
     * @param additionalClasses
     *            Additional classes whose constructors to get.
     * @return All constructors declared in this class.
     */
    public static Constructor<?>[] constructorsDeclaredIn(final Class<?> cls, final Class<?>... additionalClasses) {
        if (cls == null) {
            throw new IllegalArgumentException("You need to supply at least one class.");
        }
        Set<Constructor<?>> constructors = new HashSet<Constructor<?>>();
        constructors.addAll(asList(WhiteboxImpl.getAllConstructors(cls)));
        for (Class<?> klass : additionalClasses) {
            constructors.addAll(asList(WhiteboxImpl.getAllConstructors(klass)));
        }
        return constructors.toArray(new Constructor[constructors.size()]);
    }

    /**
     * Convenience method to get a constructor from a class.
     * 
     * @param constructor
     *            The first constructor.
     * @param additionalConstructors
     *            Additional constructors
     * @return An array of <code>java.lang.reflect.Constructor</code>.
     */
    public static Constructor<?>[] constructors(Constructor<?> constructor, Constructor<?>... additionalConstructors) {
        return merge(constructor, additionalConstructors);
    }

    /**
     * Get all constructors and methods in the supplied class(es).
     * 
     * @param cls
     *            The class whose constructors and methods to get.
     * @param additionalClasses
     *            Additional classes whose constructors and methods to get.
     * @return All constructors and methods declared in this class.
     */
    public static AccessibleObject[] everythingDeclaredIn(final Class<?> cls, final Class<?>... additionalClasses) {
        if (cls == null) {
            throw new IllegalArgumentException("You need to supply at least one class.");
        }
        Set<AccessibleObject> accessibleObjects = new HashSet<AccessibleObject>();
        accessibleObjects.addAll(Collections.unmodifiableCollection(asList(methodsDeclaredIn(cls, additionalClasses))));
        accessibleObjects.addAll(Collections.unmodifiableCollection(asList(constructorsDeclaredIn(cls,
                additionalClasses))));
        return accessibleObjects.toArray(new AccessibleObject[accessibleObjects.size()]);
    }

    private static String[] merge(String first, String... additional) {
        return new ArrayMergerImpl().mergeArrays(String.class, new String[] { first }, additional);
    }

    private static Method[] merge(Method first, Method... additional) {
        return new ArrayMergerImpl().mergeArrays(Method.class, new Method[] { first }, additional);
    }

    private static Field[] merge(Field first, Field... additional) {
        return new ArrayMergerImpl().mergeArrays(Field.class, new Field[] { first }, additional);
    }

    private static Constructor<?>[] merge(Constructor<?> first, Constructor<?>... additional) {
        return new ArrayMergerImpl().mergeArrays(Constructor.class, new Constructor<?>[] { first }, additional);
    }
}