WhiteboxImpl (powermock 1.4.12 API)

java.lang.Object
- org.powermock.reflect.internal.WhiteboxImpl

```
public class WhiteboxImpl
extends Object
```
Various utilities for accessing internals of a class. Basically a simplified reflection utility intended for tests.

Constructor Summary

Constructors
Constructor and Description

WhiteboxImpl()

Constructors
Constructor and Description
`WhiteboxImpl()`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`areAllMethodsStatic(Method... methods)` Are all methods static.
`static boolean`	`checkIfParameterTypesAreSame(boolean isVarArgs, Class<?>[] expectedParameterTypes, Class<?>[] actualParameterTypes)` Check if parameter types are same.
`static Constructor<?>`	`findConstructorOrThrowException(Class<?> type)` Finds and returns any constructor.
`static Constructor<?>`	`findDefaultConstructorOrThrowException(Class<?> type)` Finds and returns the default constructor.
`static <T> Method`	`findMethod(Class<T> type, String methodName, Class<?>... parameterTypes)` Finds and returns a method based on the input parameters.
`static Method`	`findMethodOrThrowException(Class<?> type, String methodName, Class<?>... parameterTypes)` Find method or throw exception.
`static Method`	`findMethodOrThrowException(Object tested, Class<?> declaringClass, String methodToExecute, Object[] arguments)` Finds and returns a certain method.
`static Constructor<?>`	`findUniqueConstructorOrThrowException(Class<?> type, Object... arguments)` Finds and returns a certain constructor.
`static Constructor<?>[]`	`getAllConstructors(Class<?> clazz)` Get all declared constructors in the class and set accessible to `true`.
`static Field[]`	`getAllFields(Class<?> clazz)` Get all fields in a class hierarchy! Both declared an non-declared (no duplicates).
`static Set<Field>`	`getAllInstanceFields(Object object)` Get all instance fields for a particular object.
`static <T> Method[]`	`getAllMethodExcept(Class<T> type, String... methodNames)` Gets the all method except.
`static Method[]`	`getAllMethods(Class<?> clazz)` Get all methods in a class hierarchy! Both declared an non-declared (no duplicates).
`static <T> Method[]`	`getAllMetodsExcept(Class<T> type, String methodNameToExclude, Class<?>[] argumentTypes)` Gets the all metods except.
`static Set<Field>`	`getAllStaticFields(Class<?> type)` Get all static fields for a particular type.
`static Class<Object>`	`getAnonymousInnerClassType(Class<?> declaringClass, int occurrence)` Get the type of an anonymous inner class.
`static Method`	`getBestMethodCandidate(Class<?> cls, String methodName, Class<?>[] signature, boolean exactParameterTypeMatch)` Gets the best method candidate.
`static Constructor<?>`	`getConstructor(Class<?> type, Class<?>... parameterTypes)` Convenience method to get a (declared) constructor from a class type without having to catch the checked exceptions otherwise required.
`static Field`	`getField(Class<?> type, String fieldName)` Convenience method to get a field from a class type.
`static Field[]`	`getFields(Class<?> clazz, String... fieldNames)` Get an array of `Field`'s that matches the supplied list of field names.
`static Set<Field>`	`getFieldsAnnotatedWith(Object object, Class<? extends Annotation>[] annotationTypes)` Get all fields annotated with a particular annotation.
`static Set<Field>`	`getFieldsAnnotatedWith(Object object, Class<? extends Annotation> annotation, Class<? extends Annotation>... additionalAnnotations)` Get all fields annotated with a particular annotation.
`static Set<Field>`	`getFieldsOfType(Object object, Class<?> type)` Get all fields assignable from a particular type.
`static Constructor<?>`	`getFirstParentConstructor(Class<?> klass)` Get the first parent constructor defined in a super class of `klass`.
`static Class<Object>`	`getInnerClassType(Class<?> declaringClass, String name)` Get an inner class type.
`static <T> T`	`getInternalState(Object object, Class<T> fieldType)` Get the value of a field using reflection.
`static <T> T`	`getInternalState(Object object, Class<T> fieldType, Class<?> where)` Get the value of a field using reflection.
`static <T> T`	`getInternalState(Object object, String fieldName)` Get the value of a field using reflection.
`static <T> T`	`getInternalState(Object object, String fieldName, Class<?> where)` Get the value of a field using reflection.
`static Class<Object>`	`getLocalClassType(Class<?> declaringClass, int occurrence, String name)` Get the type of a local inner class.
`static Method`	`getMethod(Class<?> type, Class<?>... parameterTypes)` Convenience method to get a method from a class type without having to catch the checked exceptions otherwise required.
`static Method`	`getMethod(Class<?> type, String methodName, Class<?>... parameterTypes)` Convenience method to get a method from a class type without having to catch the checked exceptions otherwise required.
`static Method[]`	`getMethods(Class<?> clazz, String... methodNames)` Get an array of `Method`'s that matches the supplied list of method names.
`static Method[]`	`getMethods(Class<?> clazz, String methodName, Class<?>[] expectedTypes, boolean exactParameterTypeMatch)` Get an array of `Method`'s that matches the method name and whose argument types are assignable from `expectedTypes`.
`static Class<?>`	`getType(Object object)` Gets the type.
`static <T> Class<?>`	`getUnmockedType(Class<T> type)` Gets the unmocked type.
`static <T> T`	`invokeConstructor(Class<T> classThatContainsTheConstructorToTest, Class<?>[] parameterTypes, Object[] arguments)` Invoke a constructor.
`static <T> T`	`invokeConstructor(Class<T> classThatContainsTheConstructorToTest, Object... arguments)` Invoke a constructor.
`static <T> T`	`invokeMethod(Class<?> tested, Object... arguments)` Invoke a private or inner class method without the need to specify the method name.
`static <T> T`	`invokeMethod(Class<?> clazz, String methodToExecute, Object... arguments)` Invoke a private or inner class method.
`static <T> T`	`invokeMethod(Object object, Class<?> declaringClass, String methodToExecute, Class<?>[] parameterTypes, Object... arguments)` Invoke a private method in that is located in a subclass of an instance.
`static <T> T`	`invokeMethod(Object tested, Class<?> declaringClass, String methodToExecute, Object... arguments)` Invoke a private or inner class method in that is located in a subclass of the tested instance.
`static <T> T`	`invokeMethod(Object tested, Object... arguments)` Invoke a private or inner class method without the need to specify the method name.
`static <T> T`	`invokeMethod(Object tested, String methodToExecute, Class<?>[] argumentTypes, Object... arguments)` Invoke a private or inner class method in cases where power mock cannot automatically determine the type of the parameters, for example when mixing primitive types and wrapper types in the same method.
`static <T> T`	`invokeMethod(Object tested, String methodToExecute, Class<?> definedIn, Class<?>[] argumentTypes, Object... arguments)` Invoke a private or inner class method in a subclass (defined by `definedIn`) in cases where power mock cannot automatically determine the type of the parameters, for example when mixing primitive types and wrapper types in the same method.
`static <T> T`	`invokeMethod(Object tested, String methodToExecute, Object... arguments)` Invoke a private or inner class method.
`static boolean`	`isClass(Object argument)` Checks if is class.
`static boolean`	`isProxy(Class<?> type)` Checks if is proxy.
`static <T> T`	`newInstance(Class<T> classToInstantiate)` Create a new instance of a class without invoking its constructor.
`static <T> T`	`performMethodInvocation(Object tested, Method methodToInvoke, Object... arguments)` Perform method invocation.
`static void`	`setInternalState(Object object, Class<?> fieldType, Object value)` Set the value of a field using reflection.
`static void`	`setInternalState(Object object, Class<?> fieldType, Object value, Class<?> where)` Set the value of a field using reflection at a specific location ( `where`) in the class hierarchy.
`static void`	`setInternalState(Object object, Object value, Class<?> where)` Set the value of a field using reflection at at specific place in the class hierarchy (`where`).
`static void`	`setInternalState(Object object, Object value, Object... additionalValues)` Set the value of a field using reflection.
`static void`	`setInternalState(Object object, String fieldName, Object value)` Set the value of a field using reflection.
`static void`	`setInternalState(Object object, String fieldName, Object[] value)` Set the value of a field using reflection.
`static void`	`setInternalState(Object object, String fieldName, Object value, Class<?> where)` Set the value of a field using reflection.
`static void`	`setInternalStateFromContext(Object object, Class<?> context, Class<?>[] additionalContexts)` Set the values of multiple static fields defined in a context using reflection.
`static void`	`setInternalStateFromContext(Object object, Object context, FieldMatchingStrategy strategy)`
`static void`	`setInternalStateFromContext(Object object, Object context, Object[] additionalContexts)` Set the values of multiple instance fields defined in a context using reflection.
`static void`	`throwExceptionIfFieldWasNotFound(Class<?> type, String fieldName, Field field)` Throw exception if field was not found.
`static void`	`throwExceptionIfMethodWasNotFound(Class<?> type, String methodName, Method methodToMock, Object... arguments)` Throw exception if method was not found.

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

- Constructor Detail
  - WhiteboxImpl
```
public WhiteboxImpl()
```
- Method Detail
  - getMethod
```
public static Method getMethod(Class<?> type,
               Class<?>... parameterTypes)
```
    Convenience method to get a method from a class type without having to catch the checked exceptions otherwise required. These exceptions are wrapped as runtime exceptions.
    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 MethodNotFoundException is thrown. Since the method name is not specified an
    
    Parameters:
    type - The type of the class where the method is located.
    parameterTypes - All parameter types of the method (may be null).
    
    Returns:
    A . TooManyMethodsFoundException is thrown if two or more methods matches the same parameter types in the same class.
  - getMethod
```
public static Method getMethod(Class<?> type,
               String methodName,
               Class<?>... parameterTypes)
```
    Convenience method to get a method from a class type without having to catch the checked exceptions otherwise required. These exceptions are wrapped as runtime exceptions.
    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 IllegalArgumentException is thrown.
    
    Parameters:
    type - The type of the class where the method is located.
    methodName - The method names.
    parameterTypes - All parameter types of the method (may be null).
    
    Returns:
    A .
  - getField
```
public static Field getField(Class<?> type,
             String fieldName)
```
    Convenience method to get a field from a class type.
    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 IllegalArgumentException is thrown.
    
    Parameters:
    type - The type of the class where the method is located.
    fieldName - The method names.
    
    Returns:
    A .
  - newInstance
```
public static <T> T newInstance(Class<T> classToInstantiate)
```
    Create a new instance of a class without invoking its constructor.
    No byte-code manipulation is needed to perform this operation and thus it's not necessary use the PowerMockRunner or PrepareForTest annotation to use this functionality.
    
    Type Parameters:
    T - The type of the instance to create.
    Parameters:
    classToInstantiate - The type of the instance to create.
    
    Returns:
    A new instance of type T, created without invoking the constructor.
  - getConstructor
```
public static Constructor<?> getConstructor(Class<?> type,
                            Class<?>... parameterTypes)
```
    Convenience method to get a (declared) constructor from a class type without having to catch the checked exceptions otherwise required. These exceptions are wrapped as runtime exceptions. The constructor is also set to accessible.
    
    Parameters:
    type - The type of the class where the constructor is located.
    parameterTypes - All parameter types of the constructor (may be null).
    
    Returns:
    A .
  - setInternalState
```
public static void setInternalState(Object object,
                    String fieldName,
                    Object value)
```
    Set the value of a field using reflection. This method will traverse the super class hierarchy until a field with name fieldName is found.
    
    Parameters:
    object - the object whose field to modify
    fieldName - the name of the field
    value - the new value of the field
  - setInternalState
```
public static void setInternalState(Object object,
                    String fieldName,
                    Object[] value)
```
    Set the value of a field using reflection. This method will traverse the super class hierarchy until a field with name fieldName is found.
    
    Parameters:
    object - the object to modify
    fieldName - the name of the field
    value - the new value of the field
  - setInternalState
```
public static void setInternalState(Object object,
                    Class<?> fieldType,
                    Object value)
```
    Set the value of a field using reflection. This method will traverse the super class hierarchy until the first field of type fieldType is found. The value will then be assigned to this field.
    
    Parameters:
    object - the object to modify
    fieldType - the type of the field
    value - the new value of the field
  - setInternalState
```
public static void setInternalState(Object object,
                    Object value,
                    Object... additionalValues)
```
    Set the value of a field using reflection. This method will traverse the super class hierarchy until the first field assignable to the value type is found. The value (or additionaValues if present) will then be assigned to this field.
    
    Parameters:
    object - the object to modify
    value - the new value of the field
    additionalValues - Additional values to set on the object
  - setInternalState
```
public static void setInternalState(Object object,
                    Object value,
                    Class<?> where)
```
    Set the value of a field using reflection at at specific place in the class hierarchy (where). This first field assignable to object will then be set to value.
    
    Parameters:
    object - the object to modify
    value - the new value of the field
    where - the class in the hierarchy where the field is defined
  - setInternalState
```
public static void setInternalState(Object object,
                    Class<?> fieldType,
                    Object value,
                    Class<?> where)
```
    Set the value of a field using reflection at a specific location ( where) in the class hierarchy. The value will then be assigned to this field.
    
    Parameters:
    object - the object to modify
    fieldType - the type of the field the should be set.
    value - the new value of the field
    where - which class in the hierarchy defining the field
  - setInternalState
```
public static void setInternalState(Object object,
                    String fieldName,
                    Object value,
                    Class<?> where)
```
    Set the value of a field using reflection. Use this method when you need to specify in which class the field is declared. This is useful if you have two fields in a class hierarchy that has the same name but you like to modify the latter.
    
    Parameters:
    object - the object to modify
    fieldName - the name of the field
    value - the new value of the field
    where - which class the field is defined
  - getInternalState
```
public static <T> T getInternalState(Object object,
                     String fieldName)
```
    Get the value of a field using reflection. This method will iterate through the entire class hierarchy and return the value of the first field named fieldName. If you want to get a specific field value at specific place in the class hierarchy please refer to
    
    Type Parameters:
    T - the generic type
    Parameters:
    object - the object to modify
    fieldName - the name of the field
    
    Returns:
    the internal state getInternalState(Object, String, Class).
  - getInternalState
```
public static <T> T getInternalState(Object object,
                     Class<T> fieldType)
```
    Get the value of a field using reflection. This method will traverse the super class hierarchy until the first field of type fieldType is found. The value of this field will be returned.
    
    Type Parameters:
    T - the generic type
    Parameters:
    object - the object to modify
    fieldType - the type of the field
    
    Returns:
    the internal state
  - getInternalState
```
public static <T> T getInternalState(Object object,
                     Class<T> fieldType,
                     Class<?> where)
```
    Get the value of a field using reflection. Use this method when you need to specify in which class the field is declared. The first field matching the fieldType in where will is the field whose value will be returned.
    
    Type Parameters:
    T - the expected type of the field
    Parameters:
    object - the object to modify
    fieldType - the type of the field
    where - which class the field is defined
    
    Returns:
    the internal state
  - getInternalState
```
public static <T> T getInternalState(Object object,
                     String fieldName,
                     Class<?> where)
```
    Get the value of a field using reflection. Use this method when you need to specify in which class the field is declared. This might be useful when you have mocked the instance you are trying to access. Use this method to avoid casting.
    
    Type Parameters:
    T - the expected type of the field
    Parameters:
    object - the object to modify
    fieldName - the name of the field
    where - which class the field is defined
    
    Returns:
    the internal state
  - invokeMethod
```
public static <T> T invokeMethod(Object tested,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method without the need to specify the method name. This is thus a more refactor friendly version of the
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - the exception invokeMethod(Object, String, Object...) method and is recommend over this method for that reason. This method might be useful to test private methods.
  - invokeMethod
```
public static <T> T invokeMethod(Class<?> tested,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method without the need to specify the method name. This is thus a more refactor friendly version of the
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - the exception invokeMethod(Object, String, Object...) method and is recommend over this method for that reason. This method might be useful to test private methods.
  - invokeMethod
```
public static <T> T invokeMethod(Object tested,
                 String methodToExecute,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method. This might be useful to test private methods.
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    methodToExecute - the method to execute
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - the exception
  - invokeMethod
```
public static <T> T invokeMethod(Object tested,
                 String methodToExecute,
                 Class<?>[] argumentTypes,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method in cases where power mock cannot automatically determine the type of the parameters, for example when mixing primitive types and wrapper types in the same method. For most situations use invokeMethod(Class, String, Object...) instead.
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    methodToExecute - the method to execute
    argumentTypes - the argument types
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - Exception that may occur when invoking this method.
  - invokeMethod
```
public static <T> T invokeMethod(Object tested,
                 String methodToExecute,
                 Class<?> definedIn,
                 Class<?>[] argumentTypes,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method in a subclass (defined by definedIn) in cases where power mock cannot automatically determine the type of the parameters, for example when mixing primitive types and wrapper types in the same method. For most situations use
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    methodToExecute - the method to execute
    definedIn - the defined in
    argumentTypes - the argument types
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - Exception that may occur when invoking this method. invokeMethod(Class, String, Object...) instead.
  - invokeMethod
```
public static <T> T invokeMethod(Object tested,
                 Class<?> declaringClass,
                 String methodToExecute,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method in that is located in a subclass of the tested instance. This might be useful to test private methods.
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    declaringClass - the declaring class
    methodToExecute - the method to execute
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - Exception that may occur when invoking this method.
  - invokeMethod
```
public static <T> T invokeMethod(Object object,
                 Class<?> declaringClass,
                 String methodToExecute,
                 Class<?>[] parameterTypes,
                 Object... arguments)
                      throws Exception
```
    Invoke a private method in that is located in a subclass of an instance. This might be useful to test overloaded private methods.
    Use this for overloaded methods only, if possible use
    
    Type Parameters:
    T - the generic type
    Parameters:
    object - the object
    declaringClass - the declaring class
    methodToExecute - the method to execute
    parameterTypes - the parameter types
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - Exception that may occur when invoking this method. invokeMethod(Object, Object...) or invokeMethod(Object, String, Object...) instead.
  - invokeMethod
```
public static <T> T invokeMethod(Class<?> clazz,
                 String methodToExecute,
                 Object... arguments)
                      throws Exception
```
    Invoke a private or inner class method. This might be useful to test private methods.
    
    Type Parameters:
    T - the generic type
    Parameters:
    clazz - the clazz
    methodToExecute - the method to execute
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - the exception
  - findMethodOrThrowException
```
public static Method findMethodOrThrowException(Object tested,
                                Class<?> declaringClass,
                                String methodToExecute,
                                Object[] arguments)
```
    Finds and returns a certain method. If the method couldn't be found this method delegates to
    
    Parameters:
    tested - The instance or class containing the method.
    declaringClass - The class where the method is supposed to be declared (may be null).
    methodToExecute - The method name. If null then method will be looked up based on the argument types only.
    arguments - The arguments of the methods.
    
    Returns:
    A single method.
    
    Throws:
    
    {@link - org.powermock.reflect.exceptions.MethodNotFoundException} if no method was found
    
    {@link - org.powermock.reflect.exceptions.TooManyMethodsFoundException} if too methods matched
  - getBestMethodCandidate
```
public static Method getBestMethodCandidate(Class<?> cls,
                            String methodName,
                            Class<?>[] signature,
                            boolean exactParameterTypeMatch)
```
    Gets the best method candidate.
    
    Parameters:
    cls - the cls
    methodName - the method name
    signature - the signature
    exactParameterTypeMatch - true if the expectedTypes must match the parameter types must match exactly, false if the expectedTypes are allowed to be converted into primitive types if they are of a wrapped type and still match.
    
    Returns:
    the best method candidate
  - findDefaultConstructorOrThrowException
```
public static Constructor<?> findDefaultConstructorOrThrowException(Class<?> type)
```
    Finds and returns the default constructor. If the constructor couldn't be found this method delegates to throwExceptionWhenMultipleConstructorMatchesFound(java.lang.reflect.Constructor[]).
    
    Parameters:
    type - The type where the constructor should be located.
    
    Returns:
    The found constructor.
    
    Throws:
    
    {@link - org.powermock.reflect.exceptions.TooManyConstructorsFoundException} if too many constructors was found.
  - findConstructorOrThrowException
```
public static Constructor<?> findConstructorOrThrowException(Class<?> type)
```
    Finds and returns any constructor. If the constructor couldn't be found this method delegates to throwExceptionWhenMultipleConstructorMatchesFound(java.lang.reflect.Constructor[]).
    
    Parameters:
    type - The type where the constructor should be located.
    
    Returns:
    The found constructor.
    
    Throws:
    
    {@link - org.powermock.reflect.exceptions.TooManyConstructorsFoundException} if too many constructors was found.
  - findUniqueConstructorOrThrowException
```
public static Constructor<?> findUniqueConstructorOrThrowException(Class<?> type,
                                                   Object... arguments)
```
    Finds and returns a certain constructor. If the constructor couldn't be found this method delegates to
    
    Parameters:
    type - The type where the constructor should be located.
    arguments - The arguments passed to the constructor.
    
    Returns:
    The found constructor.
    
    Throws:
    
    {@link - org.powermock.reflect.exceptions.ConstructorNotFoundException} if no constructor was found
    
    {@link - org.powermock.reflect.exceptions.TooManyConstructorsFoundException} if too constructors matched
  - throwExceptionIfMethodWasNotFound
```
public static void throwExceptionIfMethodWasNotFound(Class<?> type,
                                     String methodName,
                                     Method methodToMock,
                                     Object... arguments)
```
    Throw exception if method was not found.
    
    Parameters:
    type - the type
    methodName - the method name
    methodToMock - the method to mock
    arguments - the arguments
  - throwExceptionIfFieldWasNotFound
```
public static void throwExceptionIfFieldWasNotFound(Class<?> type,
                                    String fieldName,
                                    Field field)
```
    Throw exception if field was not found.
    
    Parameters:
    type - the type
    fieldName - the field name
    field - the field
  - invokeConstructor
```
public static <T> T invokeConstructor(Class<T> classThatContainsTheConstructorToTest,
                      Class<?>[] parameterTypes,
                      Object[] arguments)
                           throws Exception
```
    Invoke a constructor. Useful for testing classes with a private constructor when PowerMock cannot determine which constructor to invoke. This only happens if you have two constructors with the same number of arguments where one is using primitive data types and the other is using the wrapped counter part. For example:
```
 public class MyClass {
 private MyClass(Integer i) {
 ...
 }

 private MyClass(int i) {
 ...
 }
 
```
    This ought to be a really rare case. So for most situation, use
    Type Parameters:
    T - the generic type
    Parameters:
    classThatContainsTheConstructorToTest - the class that contains the constructor to test
    parameterTypes - the parameter types
    arguments - the arguments
    
    Returns:
    The object created after the constructor has been invoked.
    
    Throws:
    
    Exception - If an exception occur when invoking the constructor. invokeConstructor(Class, Object...) instead.
  - invokeConstructor
```
public static <T> T invokeConstructor(Class<T> classThatContainsTheConstructorToTest,
                      Object... arguments)
                           throws Exception
```
    Invoke a constructor. Useful for testing classes with a private constructor.
    
    Type Parameters:
    T - the generic type
    Parameters:
    classThatContainsTheConstructorToTest - the class that contains the constructor to test
    arguments - the arguments
    
    Returns:
    The object created after the constructor has been invoked.
    
    Throws:
    
    Exception - If an exception occur when invoking the constructor.
  - getAllConstructors
```
public static Constructor<?>[] getAllConstructors(Class<?> clazz)
```
    Get all declared constructors in the class and set accessible to true.
    
    Parameters:
    clazz - The class whose constructors to get.
    
    Returns:
    All constructors declared in this class hierarchy.
  - getAllMethods
```
public static Method[] getAllMethods(Class<?> clazz)
```
    Get all methods in a class hierarchy! Both declared an non-declared (no duplicates).
    
    Parameters:
    clazz - The class whose methods to get.
    
    Returns:
    All methods declared in this class hierarchy.
  - getAllFields
```
public static Field[] getAllFields(Class<?> clazz)
```
    Get all fields in a class hierarchy! Both declared an non-declared (no duplicates).
    
    Parameters:
    clazz - The class whose fields to get.
    
    Returns:
    All fields declared in this class hierarchy.
  - getFirstParentConstructor
```
public static Constructor<?> getFirstParentConstructor(Class<?> klass)
```
    Get the first parent constructor defined in a super class of klass.
    
    Parameters:
    klass - The class where the constructor is located. null ).
    
    Returns:
    A .
  - findMethod
```
public static <T> Method findMethod(Class<T> type,
                    String methodName,
                    Class<?>... parameterTypes)
```
    Finds and returns a method based on the input parameters. If no parameterTypes are present the method will return the first method with name methodNameToMock. If no method was found, null will be returned. If no methodName is specified the method will be found based on the parameter types. If neither method name nor parameters are specified an
    
    Type Parameters:
    T - the generic type
    Parameters:
    type - the type
    methodName - the method name
    parameterTypes - the parameter types
    
    Returns:
    the method IllegalArgumentException will be thrown.
  - isProxy
```
public static boolean isProxy(Class<?> type)
```
    Checks if is proxy.
    
    Parameters:
    type - the type
    
    Returns:
    true, if is proxy
  - getUnmockedType
```
public static <T> Class<?> getUnmockedType(Class<T> type)
```
    Gets the unmocked type.
    
    Type Parameters:
    T - the generic type
    Parameters:
    type - the type
    
    Returns:
    the unmocked type
  - findMethodOrThrowException
```
public static Method findMethodOrThrowException(Class<?> type,
                                String methodName,
                                Class<?>... parameterTypes)
```
    Find method or throw exception.
    
    Parameters:
    type - the type
    methodName - the method name
    parameterTypes - the parameter types
    
    Returns:
    the method
  - getMethods
```
public static Method[] getMethods(Class<?> clazz,
                  String... methodNames)
```
    Get an array of Method's that matches the supplied list of method names. Both instance and static methods are taken into account.
    
    Parameters:
    clazz - The class that should contain the methods.
    methodNames - Names of the methods that will be returned.
    
    Returns:
    An array of Method's.
  - getMethods
```
public static Method[] getMethods(Class<?> clazz,
                  String methodName,
                  Class<?>[] expectedTypes,
                  boolean exactParameterTypeMatch)
```
    Get an array of Method's that matches the method name and whose argument types are assignable from expectedTypes. Both instance and static methods are taken into account.
    
    Parameters:
    clazz - The class that should contain the methods.
    methodName - Names of the methods that will be returned.
    expectedTypes - The methods must match
    exactParameterTypeMatch - true if the expectedTypes must match the parameter types must match exactly, false if the expectedTypes are allowed to be converted into primitive types if they are of a wrapped type and still match.
    
    Returns:
    An array of Method's.
  - getFields
```
public static Field[] getFields(Class<?> clazz,
                String... fieldNames)
```
    Get an array of Field's that matches the supplied list of field names. Both instance and static fields are taken into account.
    
    Parameters:
    clazz - The class that should contain the fields.
    fieldNames - Names of the fields that will be returned.
    
    Returns:
    An array of Field's. May be of length 0 but not .
  - performMethodInvocation
```
public static <T> T performMethodInvocation(Object tested,
                            Method methodToInvoke,
                            Object... arguments)
                                 throws Exception
```
    Perform method invocation.
    
    Type Parameters:
    T - the generic type
    Parameters:
    tested - the tested
    methodToInvoke - the method to invoke
    arguments - the arguments
    
    Returns:
    the t
    
    Throws:
    
    Exception - the exception
  - getAllMethodExcept
```
public static <T> Method[] getAllMethodExcept(Class<T> type,
                              String... methodNames)
```
    Gets the all method except.
    
    Type Parameters:
    T - the generic type
    Parameters:
    type - the type
    methodNames - the method names
    
    Returns:
    the all method except
  - getAllMetodsExcept
```
public static <T> Method[] getAllMetodsExcept(Class<T> type,
                              String methodNameToExclude,
                              Class<?>[] argumentTypes)
```
    Gets the all metods except.
    
    Type Parameters:
    T - the generic type
    Parameters:
    type - the type
    methodNameToExclude - the method name to exclude
    argumentTypes - the argument types
    
    Returns:
    the all metods except
  - areAllMethodsStatic
```
public static boolean areAllMethodsStatic(Method... methods)
```
    Are all methods static.
    
    Parameters:
    methods - the methods
    
    Returns:
    true, if successful
  - getType
```
public static Class<?> getType(Object object)
```
    Gets the type.
    
    Parameters:
    object - the object
    
    Returns:
    The type of the of an object.
  - getInnerClassType
```
public static Class<Object> getInnerClassType(Class<?> declaringClass,
                              String name)
                                       throws ClassNotFoundException
```
    Get an inner class type.
    
    Parameters:
    declaringClass - The class in which the inner class is declared.
    name - The unqualified name (simple name) of the inner class.
    
    Returns:
    The type.
    
    Throws:
    
    ClassNotFoundException - the class not found exception
  - getLocalClassType
```
public static Class<Object> getLocalClassType(Class<?> declaringClass,
                              int occurrence,
                              String name)
                                       throws ClassNotFoundException
```
    Get the type of a local inner class.
    
    Parameters:
    declaringClass - The class in which the local inner class is declared.
    occurrence - The occurrence of the local class. For example if you have two local classes in the declaringClass you must pass in 1 if you want to get the type for the first one or 2 if you want the second one.
    name - The unqualified name (simple name) of the local class.
    
    Returns:
    The type.
    
    Throws:
    
    ClassNotFoundException - the class not found exception
  - getAnonymousInnerClassType
```
public static Class<Object> getAnonymousInnerClassType(Class<?> declaringClass,
                                       int occurrence)
                                                throws ClassNotFoundException
```
    Get the type of an anonymous inner class.
    
    Parameters:
    declaringClass - The class in which the anonymous inner class is declared.
    occurrence - The occurrence of the anonymous inner class. For example if you have two anonymous inner classes classes in the declaringClass you must pass in 1 if you want to get the type for the first one or 2 if you want the second one.
    
    Returns:
    The type.
    
    Throws:
    
    ClassNotFoundException - the class not found exception
  - getFieldsAnnotatedWith
```
public static Set<Field> getFieldsAnnotatedWith(Object object,
                                Class<? extends Annotation> annotation,
                                Class<? extends Annotation>... additionalAnnotations)
```
    Get all fields annotated with a particular annotation. This method traverses the class hierarchy when checking for the annotation.
    
    Parameters:
    object - The object to look for annotations. Note that if're you're passing an object only instance fields are checked, passing a class will only check static fields.
    annotation - The annotation type to look for.
    additionalAnnotations - Optionally more annotations to look for. If any of the annotations are associated with a particular field it will be added to the resulting Set.
    
    Returns:
    A set of all fields containing the particular annotation.
  - getFieldsAnnotatedWith
```
public static Set<Field> getFieldsAnnotatedWith(Object object,
                                Class<? extends Annotation>[] annotationTypes)
```
    Get all fields annotated with a particular annotation. This method traverses the class hierarchy when checking for the annotation.
    
    Parameters:
    object - The object to look for annotations. Note that if're you're passing an object only instance fields are checked, passing a class will only check static fields.
    annotationTypes - The annotation types to look for
    
    Returns:
    A set of all fields containing the particular annotation(s).
    Since:
    
    1.3
  - getFieldsOfType
```
public static Set<Field> getFieldsOfType(Object object,
                         Class<?> type)
```
    Get all fields assignable from a particular type. This method traverses the class hierarchy when checking for the type.
    
    Parameters:
    object - The object to look for type. Note that if're you're passing an object only instance fields are checked, passing a class will only check static fields.
    type - The type to look for.
    
    Returns:
    A set of all fields of the particular type.
  - getAllInstanceFields
```
public static Set<Field> getAllInstanceFields(Object object)
```
    Get all instance fields for a particular object. It returns all fields regardless of the field modifier and regardless of where in the class hierarchy a field is located.
    
    Parameters:
    object - The object whose instance fields to get.
    
    Returns:
    All instance fields in the hierarchy. All fields are set to accessible
  - getAllStaticFields
```
public static Set<Field> getAllStaticFields(Class<?> type)
```
    Get all static fields for a particular type.
    
    Parameters:
    type - The class whose static fields to get.
    
    Returns:
    All static fields in . All fields are set to accessible.
  - isClass
```
public static boolean isClass(Object argument)
```
    Checks if is class.
    
    Parameters:
    argument - the argument
    
    Returns:
    true, if is class
  - checkIfParameterTypesAreSame
```
public static boolean checkIfParameterTypesAreSame(boolean isVarArgs,
                                   Class<?>[] expectedParameterTypes,
                                   Class<?>[] actualParameterTypes)
```
    Check if parameter types are same.
    
    Parameters:
    isVarArgs - Whether or not the method or constructor contains var args.
    expectedParameterTypes - the expected parameter types
    actualParameterTypes - the actual parameter types
    
    Returns:
    if all actual parameter types are assignable from the expected parameter types, otherwise.
  - setInternalStateFromContext
```
public static void setInternalStateFromContext(Object object,
                               Object context,
                               Object[] additionalContexts)
```
    Set the values of multiple instance fields defined in a context using reflection. The values in the context will be assigned to values on the instance. This method will traverse the class hierarchy when searching for the fields. Example usage:
    Given:
```
 public class MyContext {
        private String myString = "myString";
        protected int myInt = 9;
 }

 public class MyInstance {
        private String myInstanceString;
        private int myInstanceInt;

 }
 
```
    then
```
 Whitebox.setInternalStateFromContext(new MyInstance(), new MyContext());
 
```
    will set the instance variables of myInstance to the values specified in MyContext.
    Parameters:
    object - the object
    context - The context where the fields are defined.
    additionalContexts - Optionally more additional contexts.
  - setInternalStateFromContext
```
public static void setInternalStateFromContext(Object object,
                               Object context,
                               FieldMatchingStrategy strategy)
```
  - setInternalStateFromContext
```
public static void setInternalStateFromContext(Object object,
                               Class<?> context,
                               Class<?>[] additionalContexts)
```
    Set the values of multiple static fields defined in a context using reflection. The values in the context will be assigned to values on the classOrInstance. This method will traverse the class hierarchy when searching for the fields. Example usage:
    Given:
```
 public class MyContext {
        private static String myString = "myString";
        protected static int myInt = 9;
 }

 public class MyInstance {
        private static String myInstanceString;
        private static int myInstanceInt;

 }
 
```
    then
```
 Whitebox.setInternalStateFromContext(MyInstance.class, MyContext.class);
 
```
    will set the static variables of MyInstance to the values specified in MyContext.
    Parameters:
    object - the object
    context - The context where the fields are defined.
    additionalContexts - Optionally more additional contexts.

Class WhiteboxImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

WhiteboxImpl

Method Detail

getMethod

getMethod

getField

newInstance

getConstructor

setInternalState

setInternalState

setInternalState

setInternalState

setInternalState

setInternalState

setInternalState

getInternalState

getInternalState

getInternalState

getInternalState

invokeMethod

invokeMethod

invokeMethod

invokeMethod

invokeMethod

invokeMethod

invokeMethod

invokeMethod

findMethodOrThrowException

getBestMethodCandidate

findDefaultConstructorOrThrowException

findConstructorOrThrowException

findUniqueConstructorOrThrowException

throwExceptionIfMethodWasNotFound

throwExceptionIfFieldWasNotFound

invokeConstructor

invokeConstructor

getAllConstructors

getAllMethods

getAllFields

getFirstParentConstructor

findMethod

isProxy

getUnmockedType

findMethodOrThrowException

getMethods

getMethods

getFields

performMethodInvocation

getAllMethodExcept

getAllMetodsExcept

areAllMethodsStatic

getType

getInnerClassType

getLocalClassType

getAnonymousInnerClassType

getFieldsAnnotatedWith

getFieldsAnnotatedWith

getFieldsOfType

getAllInstanceFields

getAllStaticFields

isClass

checkIfParameterTypesAreSame

setInternalStateFromContext

setInternalStateFromContext

setInternalStateFromContext