ReflectionTestUtils (AndHow shared test utilities 1.5.0 API)

java.lang.Object
- org.yarnandtail.andhow.testutil.ReflectionTestUtils

```
public final class ReflectionTestUtils
extends Object
```
Generic (in the sense that they don't specifically apply to AndHow) test utilities that access private fields and methods.

Field Summary

Fields
Modifier and Type Field and Description

static String PERMISSION_MSG

Fields
Modifier and Type	Field and Description
`static String`	`PERMISSION_MSG`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Class<?>`	`getClassByName(String className)` Performs Class.forName, but only throws a RuntimeException so no exception needs to be handled.
`static Object`	`getFieldValue(Field field, Object instance)` Get the value of a field w/o throwing an Exception that needs to be caught.
`static <T> T`	`getInstanceFieldValue(Object instance, String fieldName, Class<T> fieldType)` Get the value of an instance Field.
`static <T> T`	`getStaticFieldValue(Class<?> clazz, String fieldName, Class<T> fieldType)` Get the value of a static Field.
`static Class<?>[]`	`getTypes(Object... args)` Get the types of a list of objects for use as argument types.
`static Field`	`getWritableField(Class<?> clazz, String fieldName)` Get a Field (static or instance), make it accessible and only throw a RuntimeException if there is a problem.
`static Object`	`invokeInstanceMethod(Object instance, String name, Object[] args, Class<?>[] types)` Invokes the named instance method on the instance via reflection, bypassing visibility.
`static Object`	`invokeMethod(Method method, Object instance, Object[] args)` Invoke the Method, static or instance, with the passed arguments.
`static Object`	`invokeStaticMethod(Class<?> clazz, String name, Object[] args, Class<?>[] types)` Invokes the named static method via reflection, bypassing visibility.
`static Object`	`setFieldValue(Field field, Object instance, Object value)` Get the value of a field w/o throwing an Exception that needs to be caught.
`static <T> T`	`setInstanceFieldValue(Object instance, String fieldName, T fieldValue, Class<T> fieldType)` Set the fieldValue of an instance Field.
`static <T> T`	`setStaticFieldValue(Class<?> clazz, String fieldName, T value)` Sets the value of a static Field.
`static String`	`stringMethod(Object instance, String name, Object... args)` Invoke a String returning instance method with an array of arguments, all of which must be non-null.
`static String`	`stringMethod(Object instance, String name, Object[] args, Class<?>[] types)` Invokes the named String returning instance method on the instance via reflection, bypassing visibility.
`static String`	`stringMethod(Object instance, String name, Object arg, Class<?> type)` Invokes the named String returning, single arg, instance method on the instance via reflection, bypassing visibility.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PERMISSION_MSG
```
public static final String PERMISSION_MSG
```
    See Also:
    
    Constant Field Values
- Method Detail
  - stringMethod
```
public static String stringMethod(Object instance,
                                  String name,
                                  Object[] args,
                                  Class<?>[] types)
```
    Invokes the named String returning instance method on the instance via reflection, bypassing visibility. For some tests, this is an easy way test the internal effect of some actions. JUnit ReflectionSupport *should* find methods without having to pass types, but this bug prevents that: https://github.com/junit-team/junit5/issues/2663
    
    Parameters:
    
    instance - The object instance to call the method on.
    
    name - The name of a String returning method, which must be an instance method.
    
    args - Arguments to the method
    
    types - The argument types of the method which must match the method, not the args.
    
    Returns:
    
    The String returned by the method
    
    Throws:
    
    Exception
  - stringMethod
```
public static String stringMethod(Object instance,
                                  String name,
                                  Object arg,
                                  Class<?> type)
```
    Invokes the named String returning, single arg, instance method on the instance via reflection, bypassing visibility.
    
    Parameters:
    
    instance - The object instance to call the method on.
    
    name - The name of a String returning method, which must be an instance method.
    
    arg - The single argument to pass to the method
    
    type - Type of the argument, which allos the argument to be null.
    
    Returns:
    
    The return value of the method
  - stringMethod
```
public static String stringMethod(Object instance,
                                  String name,
                                  Object... args)
```
    Invoke a String returning instance method with an array of arguments, all of which must be non-null. Note: Java will auto-box primitives, causing the type to not match the signiture of a method with primitive arguments. This method cannot be used for methods with primative types. It also cannot be used to pass null arguments, since there is no way to figure out the types.
    
    Parameters:
    
    instance - The object instance to call the method on.
    
    name - The name of a String returning method, which must be an instance method.
    
    args - Arguments to the method, which must be all non-null
    
    Returns:
    
    Return value of the invoked method
  - invokeInstanceMethod
```
public static Object invokeInstanceMethod(Object instance,
                                          String name,
                                          Object[] args,
                                          Class<?>[] types)
```
    Invokes the named instance method on the instance via reflection, bypassing visibility.
    
    Parameters:
    
    instance - The object instance to call the method on.
    
    name - The name of a String returning method, which must be an instance method.
    
    args - Arguments to the method
    
    types - The argument types of the method which must match the method, not the args.
    
    Returns:
    
    The return value of the method
  - invokeStaticMethod
```
public static Object invokeStaticMethod(Class<?> clazz,
                                        String name,
                                        Object[] args,
                                        Class<?>[] types)
```
    Invokes the named static method via reflection, bypassing visibility.
    
    Parameters:
    
    clazz - The class to call the method on.
    
    name - The name of a String returning method, which must be an instance method.
    
    args - Arguments to the method. May be empty or null for zero argument methods
    
    types - The argument types of the method which must match the method, not the args. Must be empty for zero arg methods, not null.
    
    Returns:
    
    The return value of the method
  - invokeMethod
```
public static Object invokeMethod(Method method,
                                  Object instance,
                                  Object[] args)
```
    Invoke the Method, static or instance, with the passed arguments. If an instance method, the instance must be non-null. If a static method, the instance must be null. Normally invoking a method by reflection can throw several different types of exceptions which must be handled - This method only throws a RuntimeException.
    
    Parameters:
    
    method - The method to invoke.
    
    instance - The instance to invoke the method on, or null if a static method.
    
    args - The arguments to pass to the method.
    
    Returns:
    
    The return value of the invocation, which will be null for a void method.
  - getInstanceFieldValue
```
public static <T> T getInstanceFieldValue(Object instance,
                                          String fieldName,
                                          Class<T> fieldType)
```
    Get the value of an instance Field.
    
    Parameters:
    
    instance - The instance to find the field in
    
    fieldName - The name of a static field in the class
    
    fieldType - The type of the field
    
    Returns:
    
    The field value
  - setInstanceFieldValue
```
public static <T> T setInstanceFieldValue(Object instance,
                                          String fieldName,
                                          T fieldValue,
                                          Class<T> fieldType)
```
    Set the fieldValue of an instance Field.
    
    Parameters:
    
    instance - The instance to find the field in
    
    fieldName - The name of a static field in the class
    
    fieldValue - The new fieldValue for the field
    
    fieldType - The type of the field (since fieldValue could be null)
    
    Returns:
    
    The original field fieldValue
  - getStaticFieldValue
```
public static <T> T getStaticFieldValue(Class<?> clazz,
                                        String fieldName,
                                        Class<T> fieldType)
```
    Get the value of a static Field. Unlike an instance field, a static field is not inherited by subclasses. If you have these two classes:
```
 class A {
   static int classAInt;
 }

 class B extends A {
   static int classBInt;
 }
 
```
    To get the value of classAInt, you must call getStaticFieldValue(A.class, "classAInt", int.class). If you call the same method on class B, the field will not be found.
    Parameters:
    
    clazz - The class to find the field in (not a subclass of it)
    
    fieldName - The name of a static field in the class
    
    fieldType - The type of the field - Really just a convenience so the caller doesn't have to cast the result. The value may be null as long as there is a compiler known type for the argument.
    
    Returns:
    
    The field value
  - setStaticFieldValue
```
public static <T> T setStaticFieldValue(Class<?> clazz,
                                        String fieldName,
                                        T value)
```
    Sets the value of a static Field. Unlike an instance field, a static field is not inherited by subclasses. If you have these two classes:
```
 class A {
   static int classAInt;
 }

 class B extends A {
   static int classBInt;
 }
 
```
    To set the value of classAInt, you must call setStaticFieldValue(A.class, "classAInt", 42). If you call the same method on class B, the field will not be found.
    Since static fields must be uniquely named at the class level, primitives and autoboxing of types is not a problem.
    Parameters:
    
    clazz - The class to find the field in (not a subclass of it)
    
    fieldName - The name of a static field in the class
    
    value - The new value for the field.
    
    Returns:
    
    The field value
  - getFieldValue
```
public static Object getFieldValue(Field field,
                                   Object instance)
```
    Get the value of a field w/o throwing an Exception that needs to be caught.
    
    Parameters:
    
    field - The field to retrieve the value of.
    
    instance - The object instance the field is a member of, may be null to access static fields.
    
    Returns:
  - setFieldValue
```
public static Object setFieldValue(Field field,
                                   Object instance,
                                   Object value)
```
    Get the value of a field w/o throwing an Exception that needs to be caught. The value previously assigned to the field is returned.
    
    Parameters:
    
    field - The field to retrieve the value of.
    
    instance - The object instance the field is a member of, may be null to access static fields.
    
    value - The value to assign, which may be null.
    
    Returns:
    
    The value previously assigned to the field.
  - getWritableField
```
public static Field getWritableField(Class<?> clazz,
                                     String fieldName)
```
    Get a Field (static or instance), make it accessible and only throw a RuntimeException if there is a problem.
    
    Parameters:
    
    clazz - The class to find the field in
    
    fieldName - The name of a static field in the class
    
    Returns:
    
    The field, set accessible.
  - getTypes
```
public static Class<?>[] getTypes(Object... args)
```
    Get the types of a list of objects for use as argument types. This may be called with no arguments or a single null argument meaning - I have no arguments. However, if multiple arguments are passed, they must each be non-null.
    
    Parameters:
    
    args -
    
    Returns:
  - getClassByName
```
public static Class<?> getClassByName(String className)
```
    Performs Class.forName, but only throws a RuntimeException so no exception needs to be handled.
    
    Parameters:
    
    className - The full class name, as would be needed for Class.forName
    
    Returns:
    
    The Class for that name.

Class ReflectionTestUtils

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PERMISSION_MSG

Method Detail

stringMethod

stringMethod

stringMethod

invokeInstanceMethod

invokeStaticMethod

invokeMethod

getInstanceFieldValue

setInstanceFieldValue

getStaticFieldValue

setStaticFieldValue

getFieldValue

setFieldValue

getWritableField

getTypes

getClassByName