Class WhiteboxImpl

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.
  • Field Details

    • proxyFramework

      private static ProxyFramework proxyFramework
      The proxy framework.
  • Constructor Details

    • WhiteboxImpl

      public WhiteboxImpl()
  • Method Details

    • 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).
    • findFieldInHierarchy

      private static Field findFieldInHierarchy(Object object, String fieldName)
      Find field in hierarchy.
      Parameters:
      object - the object
      fieldName - the field name
      Returns:
      the field
    • findFieldInHierarchy

      private static Field findFieldInHierarchy(Object object, FieldMatcherStrategy strategy)
      Find field in hierarchy.
      Parameters:
      object - the object
      strategy - the strategy
      Returns:
      the field
    • findField

      private static Field findField(Object object, FieldMatcherStrategy strategy, Class<?> where)
      Find field.
      Parameters:
      object - the object
      strategy - the strategy
      where - the where
      Returns:
      the field
    • findSingleFieldUsingStrategy

      private static Field findSingleFieldUsingStrategy(FieldMatcherStrategy strategy, Object object, boolean checkHierarchy, Class<?> startClass)
      Find single field using strategy.
      Parameters:
      strategy - the strategy
      object - the object
      checkHierarchy - the check hierarchy
      startClass - the start class
      Returns:
      the field
    • findAllFieldsUsingStrategy

      private static Set<Field> findAllFieldsUsingStrategy(FieldMatcherStrategy strategy, Object object, boolean checkHierarchy, Class<?> startClass)
      Find all fields using strategy.
      Parameters:
      strategy - the strategy
      object - the object
      checkHierarchy - the check hierarchy
      startClass - the start class
      Returns:
      the set
    • hasFieldProperModifier

      private static boolean hasFieldProperModifier(Object object, Field field)
      Checks for field proper modifier.
      Parameters:
      object - the object
      field - the field
      Returns:
      true, if successful
    • 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
    • doInvokeMethod

      private static <T> T doInvokeMethod(Object tested, Class<?> declaringClass, String methodToExecute, Object... arguments) throws Exception
      Do invoke method.
      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 - 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.
    • getMethodWithMostSpecificParameterTypes

      private static Method getMethodWithMostSpecificParameterTypes(Method firstMethodCandidate, Method secondMethodCandidate)
      Find the method whose parameter types most closely matches the types.
      Parameters:
      firstMethodCandidate - The first method candidate
      secondMethodCandidate - The second method candidate
      Returns:
      The method that most closely matches the provided types or null if no method match.
    • toBoxedIfPrimitive

      private static Class<?> toBoxedIfPrimitive(Class<?> type)
    • getTypes

      private static Class<?>[] getTypes(Object[] arguments)
      Gets the types.
      Parameters:
      arguments - the arguments
      Returns:
      the types
    • 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.
    • 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.
    • filterPowerMockConstructor

      private static Constructor<?>[] filterPowerMockConstructor(Constructor<?>[] declaredConstructors)
      Filter power mock constructor.
      Parameters:
      declaredConstructors - the declared constructors
      Returns:
      the constructor[]
    • 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.
    • convertArgumentTypesToPrimitive

      private static Class<?>[] convertArgumentTypesToPrimitive(Class<?>[] paramTypes, Object[] arguments)
      Convert argument types to primitive.
      Parameters:
      paramTypes - the param types
      arguments - the arguments
      Returns:
      the class[]
    • 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
    • throwExceptionIfConstructorWasNotFound

      static void throwExceptionIfConstructorWasNotFound(Class<?> type, Constructor<?> potentialConstructor, Object... arguments)
      Throw exception if constructor was not found.
      Parameters:
      type - the type
      potentialConstructor - the potential constructor
      arguments - the arguments
    • getArgumentTypesAsString

      private static String getArgumentTypesAsString(Object... arguments)
      Gets the argument types as string.
      Parameters:
      arguments - the arguments
      Returns:
      the argument types as string
    • appendArgument

      private static void appendArgument(StringBuilder argumentsAsString, int index, String argumentName, Object[] arguments)
      Append argument.
      Parameters:
      argumentsAsString - the arguments as string
      index - the index
      argumentName - the argument name
      arguments - the arguments
    • 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.
    • getBestCandidateConstructor

      private static <T> Constructor<T> getBestCandidateConstructor(Class<T> classThatContainsTheConstructorToTest, Class<?>[] argumentTypes, Object[] arguments)
    • getPotentialConstructorWrapped

      private static <T> Constructor<T> getPotentialConstructorWrapped(Class<T> classThatContainsTheConstructorToTest, Class<?>[] argumentTypes)
    • getPotentialConstructorPrimitive

      private static <T> Constructor<T> getPotentialConstructorPrimitive(Class<T> classThatContainsTheConstructorToTest, Class<?>[] argumentTypes)
    • argumentTypesEqualsPrimitiveTypes

      private static boolean argumentTypesEqualsPrimitiveTypes(Class<?>[] argumentTypes, Class<?>[] primitiveType)
    • getPotentialVarArgsConstructor

      private static <T> Constructor<T> getPotentialVarArgsConstructor(Class<T> classThatContainsTheConstructorToTest, Object... arguments)
      Gets the potential var args constructor.
      Type Parameters:
      T - the generic type
      Parameters:
      classThatContainsTheConstructorToTest - the class that contains the constructor to test
      arguments - the arguments
      Returns:
      the potential var args constructor
    • createInstance

      private static <T> T createInstance(Constructor<T> constructor, Object... arguments) throws Exception
      Creates the instance.
      Type Parameters:
      T - the generic type
      Parameters:
      constructor - the constructor
      arguments - the arguments
      Returns:
      the t
      Throws:
      Exception - the exception
    • createAndPopulateVarArgsArray

      private static Object createAndPopulateVarArgsArray(Class<?> varArgsType, int varArgsStartPosition, Object... arguments)
      Creates the and populate var args array.
      Parameters:
      varArgsType - the var args type
      varArgsStartPosition - the var args start position
      arguments - the arguments
      Returns:
      the object
    • 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.
    • getAllPublicMethods

      private static Method[] getAllPublicMethods(Class<?> clazz)
      Get all public methods for a class (no duplicates)! Note that the class-hierarchy will not be traversed.
      Parameters:
      clazz - The class whose methods to get.
      Returns:
      All public methods declared in class.
    • 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
    • throwExceptionWhenMultipleMethodMatchesFound

      static void throwExceptionWhenMultipleMethodMatchesFound(String helpInfo, Method[] methods)
      Throw exception when multiple method matches found.
      Parameters:
      helpInfo - the help info
      methods - the methods
    • throwExceptionWhenMultipleConstructorMatchesFound

      static void throwExceptionWhenMultipleConstructorMatchesFound(Constructor<?>[] constructors)
      Throw exception when multiple constructor matches found.
      Parameters:
      constructors - the constructors
    • 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
    • areAllArgumentsOfSameType

      static boolean areAllArgumentsOfSameType(Object[] arguments)
      Check if all arguments are of the same type.
      Parameters:
      arguments - the arguments
      Returns:
      true, if successful
    • checkArgumentTypesMatchParameterTypes

      private static boolean checkArgumentTypesMatchParameterTypes(boolean isVarArgs, Class<?>[] parameterTypes, Object[] arguments)
      Check argument types match parameter types.
      Parameters:
      isVarArgs - If the last parameter is a var args.
      parameterTypes - the parameter types
      arguments - the arguments
      Returns:
      if all actual parameter types are assignable from the expected arguments, otherwise.
    • isAssignableFrom

      private static boolean isAssignableFrom(Class<?> type, Class<?> from)
    • getComponentType

      private static Class<?> getComponentType(Class<?> type)
    • 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.
    • getField

      private static Field getField(String fieldName, Class<?> where)
      Gets the field.
      Parameters:
      fieldName - the field name
      where - the where
      Returns:
      the field
    • findFieldOrThrowException

      private static Field findFieldOrThrowException(Class<?> fieldType, Class<?> where)
      Find field or throw exception.
      Parameters:
      fieldType - the field type
      where - the where
      Returns:
      the field
    • setField

      private static void setField(Object object, Object value, Field foundField)
      Sets the field.
      Parameters:
      object - the object
      value - the value
      foundField - the found field
    • concatenateStrings

      private static String concatenateStrings(String... stringsToConcatenate)
      Concatenate strings.
      Parameters:
      stringsToConcatenate - the strings to concatenate
      Returns:
      the string
    • isPotentialVarArgsMethod

      private static boolean isPotentialVarArgsMethod(Method method, Object[] arguments)
      Checks if is potential var args method.
      Parameters:
      method - the method
      arguments - the arguments
      Returns:
      true, if is potential var args method
    • isPotentialVarArgsConstructor

      private static boolean isPotentialVarArgsConstructor(Constructor<?> constructor, Object[] arguments)
      Checks if is potential var args constructor.
      Parameters:
      constructor - the constructor
      arguments - the arguments
      Returns:
      true, if is potential var args constructor
    • doesParameterTypesMatchForVarArgsInvocation

      private static boolean doesParameterTypesMatchForVarArgsInvocation(boolean isVarArgs, Class<?>[] parameterTypes, Object[] arguments)
      Does parameter types match for var args invocation.
      Parameters:
      isVarArgs - the is var args
      parameterTypes - the parameter types
      arguments - the arguments
      Returns:
      true, if successful
    • getTypeAsPrimitiveIfWrapped

      private static Class<?> getTypeAsPrimitiveIfWrapped(Object object)
      Get the type of an object and convert it to primitive if the type has a primitive counter-part. E.g. if object is an instance of java.lang.Integer this method will return int.class.
      Parameters:
      object - The object whose type to get.
      Returns:
      the type as primitive if wrapped
    • 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.
    • copyState

      static void copyState(Object object, Object context, FieldMatchingStrategy strategy)
      Copy state.
      Parameters:
      object - the object
      context - the context
      strategy - The field matching strategy.
    • assertObjectInGetInternalStateIsNotNull

      private static void assertObjectInGetInternalStateIsNotNull(Object object)
      Assert object in get internal state is not null.
      Parameters:
      object - the object
    • convertParameterTypesToPrimitive

      private static Class<?>[] convertParameterTypesToPrimitive(Class<?>[] parameterTypes)
      Convert parameter types to primitive.
      Parameters:
      parameterTypes - the parameter types
      Returns:
      the class[]