org.junit.platform.commons.util

Class ReflectionUtils

java.lang.Object

org.junit.platform.commons.util.ReflectionUtils

@API(value=Internal)
public final class ReflectionUtils
extends Object

Collection of utilities for working with the Java reflection APIs.

DISCLAIMER

These utilities are intended solely for usage within the JUnit framework itself. Any usage by external parties is not supported. Use at your own risk!

Some utilities are published via the maintained ReflectionSupport class.

Since:

1.0

See Also:

ReflectionSupport

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ReflectionUtils.HierarchyTraversalMode Modes in which a hierarchy can be traversed — for example, when searching for methods or fields within a class hierarchy.

Method Summary

Modifier and Type	Method and Description
static List<Class<?>>	findAllClassesInClasspathRoot(URI root, Predicate<Class<?>> classTester, Predicate<String> classNameFilter)
static List<Class<?>>	findAllClassesInPackage(String basePackageName, Predicate<Class<?>> classTester, Predicate<String> classNameFilter)
static Optional<Method>	findMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) Find the first Method of the supplied class or interface that meets the specified criteria, beginning with the specified class or interface and traversing up the type hierarchy until such a method is found or the type hierarchy is exhausted.
static Optional<Method>	findMethod(Class<?> clazz, String methodName, String parameterTypeNames) Find the first Method of the supplied class or interface that meets the specified criteria, beginning with the specified class or interface and traversing up the type hierarchy until such a method is found or the type hierarchy is exhausted.
static List<Method>	findMethods(Class<?> clazz, Predicate<Method> predicate) Find all methods of the supplied class or interface that match the specified predicate, using top-down search semantics within the type hierarchy.
static List<Method>	findMethods(Class<?> clazz, Predicate<Method> predicate, ReflectionUtils.HierarchyTraversalMode traversalMode) Find all methods of the supplied class or interface that match the specified predicate.
static List<Class<?>>	findNestedClasses(Class<?> clazz, Predicate<Class<?>> predicate)
static Set<Class<?>>	getAllAssignmentCompatibleClasses(Class<?> clazz) Return all classes and interfaces that can be used as assignment types for instances of the specified Class, including itself.
static Set<Path>	getAllClasspathRootDirectories()
static <T> Constructor<T>	getDeclaredConstructor(Class<T> clazz) Get the sole declared Constructor for the supplied class.
static String	getFullyQualifiedMethodName(Class<?> clazz, String methodName, Class<?>... params) Build the fully qualified method name for the method described by the supplied class, method name, and parameter types.
static Optional<Method>	getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Optional<Object>	getOutermostInstance(Object inner, Class<?> requiredType) Get the outermost instance of the required type, searching recursively through enclosing instances.
static Class<?>	getWrapperType(Class<?> type) Get the wrapper type for the supplied primitive type.
static Object	invokeMethod(Method method, Object target, Object... args) Invoke the supplied method, making it accessible if necessary and masking any checked exception as an unchecked exception.
static boolean	isAbstract(Class<?> clazz)
static boolean	isAbstract(Member member)
static boolean	isArray(Object obj) Determine if the supplied object is an array.
static boolean	isAssignableTo(Object obj, Class<?> type) Determine if the supplied object can be assigned to the supplied type for the purpose of reflective method invocations.
static boolean	isPrivate(Class<?> clazz)
static boolean	isPrivate(Member member)
static boolean	isPublic(Class<?> clazz)
static boolean	isPublic(Member member)
static boolean	isStatic(Class<?> clazz)
static boolean	isStatic(Member member)
static Optional<Class<?>>	loadClass(String name) Load a class by its primitive name or fully qualified name, using the default ClassLoader.
static Optional<Class<?>>	loadClass(String name, ClassLoader classLoader) Load a class by its primitive name or fully qualified name, using the supplied ClassLoader.
static Optional<Method>	loadMethod(String fullyQualifiedMethodName) Load a method by its fully qualified name.
static <T extends AccessibleObject> T	makeAccessible(T object)
static <T> T	newInstance(Class<T> clazz, Object... args) Create a new instance of the specified Class by invoking the constructor whose argument list matches the types of the supplied arguments.
static <T> T	newInstance(Constructor<T> constructor, Object... args) Create a new instance of type T by invoking the supplied constructor with the supplied arguments.
static <T> Optional<Object>	readFieldValue(Class<T> clazz, String fieldName, T instance) Read the value of a potentially inaccessible field.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

isPublic

public static boolean isPublic(Class<?> clazz)

isPublic

public static boolean isPublic(Member member)

isPrivate

public static boolean isPrivate(Class<?> clazz)

isPrivate

public static boolean isPrivate(Member member)

isAbstract

public static boolean isAbstract(Class<?> clazz)

isAbstract

public static boolean isAbstract(Member member)

isStatic

public static boolean isStatic(Class<?> clazz)

isStatic

public static boolean isStatic(Member member)

isArray

public static boolean isArray(Object obj)

Determine if the supplied object is an array.

Parameters:

obj - the object to test; potentially null

Returns:

true if the object is an array

isAssignableTo

public static boolean isAssignableTo(Object obj,
                                     Class<?> type)

Determine if the supplied object can be assigned to the supplied type for the purpose of reflective method invocations.

In contrast to Class.isInstance(Object), this method returns true if the supplied type represents a primitive type whose wrapper matches the supplied object's type.

Returns true if the supplied object is null and the supplied type does not represent a primitive type.

Parameters:

obj - the object to test for assignment compatibility; potentially null

type - the type to check against; never null

Returns:

true if the object is assignment compatible

See Also:

Class.isInstance(Object), Class.isAssignableFrom(Class)

getWrapperType

public static Class<?> getWrapperType(Class<?> type)

Get the wrapper type for the supplied primitive type.

Parameters:

type - the primitive type for which to retrieve the wrapper type

Returns:

the corresponding wrapper type or null if the supplied type is null or not a primitive type

newInstance

public static <T> T newInstance(Class<T> clazz,
                                Object... args)

Create a new instance of the specified Class by invoking the constructor whose argument list matches the types of the supplied arguments.

The constructor will be made accessible if necessary, and any checked exception will be masked as an unchecked exception.

Parameters:

clazz - the class to instantiate; never null

args - the arguments to pass to the constructor none of which may be null

Returns:

the new instance

See Also:

newInstance(Constructor, Object...), ExceptionUtils.throwAsUncheckedException(Throwable)

newInstance

public static <T> T newInstance(Constructor<T> constructor,
                                Object... args)

Create a new instance of type T by invoking the supplied constructor with the supplied arguments.

The constructor will be made accessible if necessary, and any checked exception will be masked as an unchecked exception.

Parameters:

constructor - the constructor to invoke; never null

args - the arguments to pass to the constructor

Returns:

the new instance; never null

See Also:

newInstance(Class, Object...), ExceptionUtils.throwAsUncheckedException(Throwable)

invokeMethod

public static Object invokeMethod(Method method,
                                  Object target,
                                  Object... args)

Invoke the supplied method, making it accessible if necessary and masking any checked exception as an unchecked exception.

Parameters:

method - the method to invoke; never null

target - the object on which to invoke the method; may be null if the method is static

args - the arguments to pass to the method

Returns:

the value returned by the method invocation or null if the return type is void

See Also:

ExceptionUtils.throwAsUncheckedException(Throwable)

loadClass

public static Optional<Class<?>> loadClass(String name)

Load a class by its primitive name or fully qualified name, using the default ClassLoader.

See loadClass(String, ClassLoader) for details on support for class names for arrays.

Parameters:

name - the name of the class to load; never null or blank

See Also:

loadClass(String, ClassLoader)

loadClass

public static Optional<Class<?>> loadClass(String name,
                                           ClassLoader classLoader)

Load a class by its primitive name or fully qualified name, using the supplied ClassLoader.

Class names for arrays may be specified using either the JVM's internal String representation (e.g., [[I for int[][], [Lava.lang.String; for java.lang.String[], etc.) or source code syntax (e.g., int[][], java.lang.String[], etc.).

Parameters:

name - the name of the class to load; never null or blank

classLoader - the ClassLoader to use; never null

See Also:

loadClass(String)

loadMethod

public static Optional<Method> loadMethod(String fullyQualifiedMethodName)

Load a method by its fully qualified name.

The following formats are supported.

• [fully qualified class name]#[methodName]
• [fully qualified class name]#[methodName](parameter type list)

The parameter type list is a comma-separated list of primitive names or fully qualified class names for the types of parameters accepted by the method.

See loadClass(String, ClassLoader) for details on the supported syntax for array parameter types.

Examples

Method	Fully Qualified Method Name
java.lang.String.chars()	java.lang.String#chars
java.lang.String.chars()	java.lang.String#chars()
java.lang.String.equalsIgnoreCase(String)	java.lang.String#equalsIgnoreCase(java.lang.String)
java.lang.String.substring(int, int)	java.lang.String#substring(int, int)
example.Calc.avg(int[])	example.Calc#avg([I)
example.Calc.avg(int[])	example.Calc#avg(int[])
example.Matrix.multiply(double[][])	example.Matrix#multiply([[D)
example.Matrix.multiply(double[][])	example.Matrix#multiply(double[][])
example.Service.process(String[])	example.Service#process([Ljava.lang.String;)
example.Service.process(String[])	example.Service#process(java.lang.String[])
example.Service.process(String[][])	example.Service#process([[Ljava.lang.String;)
example.Service.process(String[][])	example.Service#process(java.lang.String[][])

Parameters:

fullyQualifiedMethodName - the fully qualified name of the method to load; never null or blank

Returns:

an Optional containing the method; never null but potentially empty

See Also:

getFullyQualifiedMethodName(Class, String, Class...)

getFullyQualifiedMethodName

public static String getFullyQualifiedMethodName(Class<?> clazz,
                                                 String methodName,
                                                 Class<?>... params)

Build the fully qualified method name for the method described by the supplied class, method name, and parameter types.

See loadMethod(String) for details on the format.

Parameters:

clazz - the class that declares the method; never null

methodName - the name of the method; never null or blank

params - the parameter types of the method; may be null or empty

Returns:

fully qualified method name; never null

See Also:

loadMethod(String)

getOutermostInstance

public static Optional<Object> getOutermostInstance(Object inner,
                                                    Class<?> requiredType)

Get the outermost instance of the required type, searching recursively through enclosing instances.

If the supplied inner object is of the required type, it will simply be returned.

Parameters:

inner - the inner object from which to begin the search; never null

requiredType - the required type of the outermost instance; never null

Returns:

an Optional containing the outermost instance; never null but potentially empty

getAllClasspathRootDirectories

public static Set<Path> getAllClasspathRootDirectories()

findAllClassesInClasspathRoot

public static List<Class<?>> findAllClassesInClasspathRoot(URI root,
                                                           Predicate<Class<?>> classTester,
                                                           Predicate<String> classNameFilter)

See Also:

ReflectionSupport.findAllClassesInClasspathRoot(URI, Predicate, Predicate)

findAllClassesInPackage

public static List<Class<?>> findAllClassesInPackage(String basePackageName,
                                                     Predicate<Class<?>> classTester,
                                                     Predicate<String> classNameFilter)

See Also:

ReflectionSupport.findAllClassesInPackage(String, Predicate, Predicate)

findNestedClasses

public static List<Class<?>> findNestedClasses(Class<?> clazz,
                                               Predicate<Class<?>> predicate)

getDeclaredConstructor

public static <T> Constructor<T> getDeclaredConstructor(Class<T> clazz)

Get the sole declared Constructor for the supplied class.

Throws a PreconditionViolationException if the supplied class declares more than one constructor.

Parameters:

clazz - the class to get the constructor for

Returns:

the sole declared constructor; never null

See Also:

Class.getDeclaredConstructors()

getMethod

public static Optional<Method> getMethod(Class<?> clazz,
                                         String methodName,
                                         Class<?>... parameterTypes)

findMethod

public static Optional<Method> findMethod(Class<?> clazz,
                                          String methodName,
                                          String parameterTypeNames)

Find the first Method of the supplied class or interface that meets the specified criteria, beginning with the specified class or interface and traversing up the type hierarchy until such a method is found or the type hierarchy is exhausted.

Note, however, that the current algorithm traverses the entire type hierarchy even after having found a match.

Parameters:

clazz - the class or interface in which to find the method; never null

methodName - the name of the method to find; never null or empty

parameterTypeNames - the fully qualified names of the types of parameters accepted by the method, if any, provided as a comma-separated list

Returns:

an Optional containing the method found; never null but potentially empty if no such method could be found

See Also:

findMethod(Class, String, Class...), ReflectionUtils.HierarchyTraversalMode.BOTTOM_UP

findMethod

public static Optional<Method> findMethod(Class<?> clazz,
                                          String methodName,
                                          Class<?>... parameterTypes)

Find the first Method of the supplied class or interface that meets the specified criteria, beginning with the specified class or interface and traversing up the type hierarchy until such a method is found or the type hierarchy is exhausted.

Note, however, that the current algorithm traverses the entire type hierarchy even after having found a match.

Parameters:

clazz - the class or interface in which to find the method; never null

methodName - the name of the method to find; never null or empty

parameterTypes - the types of parameters accepted by the method, if any; never null

Returns:

an Optional containing the method found; never null but potentially empty if no such method could be found

See Also:

findMethod(Class, String, String), ReflectionUtils.HierarchyTraversalMode.BOTTOM_UP

findMethods

public static List<Method> findMethods(Class<?> clazz,
                                       Predicate<Method> predicate)

Find all methods of the supplied class or interface that match the specified predicate, using top-down search semantics within the type hierarchy.

Parameters:

clazz - the class or interface in which to find the methods; never null

predicate - the method filter; never null

Returns:

an immutable list of all such methods found; never null

See Also:

ReflectionUtils.HierarchyTraversalMode.TOP_DOWN, findMethods(Class, Predicate, HierarchyTraversalMode)

findMethods

public static List<Method> findMethods(Class<?> clazz,
                                       Predicate<Method> predicate,
                                       ReflectionUtils.HierarchyTraversalMode traversalMode)

Find all methods of the supplied class or interface that match the specified predicate.

Parameters:

clazz - the class or interface in which to find the methods; never null

predicate - the method filter; never null

traversalMode - the hierarchy traversal mode; never null

Returns:

an immutable list of all such methods found; never null

See Also:

ReflectionSupport.findMethods(Class, Predicate, org.junit.platform.commons.support.HierarchyTraversalMode)

readFieldValue

public static <T> Optional<Object> readFieldValue(Class<T> clazz,
                                                  String fieldName,
                                                  T instance)

Read the value of a potentially inaccessible field.

If the field does not exist, an exception occurs while reading it, or the value of the field is null, an empty Optional is returned.

Parameters:

clazz - the class where the field is declared; never null

fieldName - the name of the field; never null or empty

instance - the instance from where the value is to be read; may be null for a static field

makeAccessible

public static <T extends AccessibleObject> T makeAccessible(T object)

getAllAssignmentCompatibleClasses

public static Set<Class<?>> getAllAssignmentCompatibleClasses(Class<?> clazz)

Return all classes and interfaces that can be used as assignment types for instances of the specified Class, including itself.

Parameters:

clazz - the Class to lookup

See Also:

Class.isAssignableFrom(java.lang.Class<?>)