Package org.robolectric.internal.bytecode

Class ShadowWrangler

java.lang.Object
org.robolectric.internal.bytecode.ShadowWrangler
All Implemented Interfaces:
ClassHandler
@AutoService(ClassHandler.class) @Priority(-2147483648) public class ShadowWrangler extends Object implements ClassHandler
ShadowWrangler matches shadowed classes up with corresponding shadows based on a ShadowMap.

ShadowWrangler has no specific knowledge of Android SDK levels or other peculiarities of the affected classes and shadows.

To apply additional rules about which shadow classes and methods are considered matches, pass in a ShadowMatcher.

ShadowWrangler is Robolectric's default ClassHandler implementation. To inject your own, create a subclass and annotate it with AutoService(ClassHandler).

  • Field Details

    • DO_NOTHING_HANDLER

      public static final Function<Object,Object> DO_NOTHING_HANDLER

    • CALL_REAL_CODE

      public static final Method CALL_REAL_CODE

    • DO_NOTHING

      public static final MethodHandle DO_NOTHING

    • DO_NOTHING_METHOD

      public static final Method DO_NOTHING_METHOD

  • Constructor Details

  • Method Details

    • classInitializing

      public void classInitializing(Class<?> clazz)
      Description copied from interface: ClassHandler
      Called by Robolectric when an instrumented class is first loaded into a sandbox and is ready to be statically initialized.

      This happens *in place of* any static initialization that may be performed by the class being loaded. The class will have a method named __staticInitializer__ which may be invoked to perform its normal initialization from <clinit>.

      Specified by:
      classInitializing in interface ClassHandler
      Parameters:
      clazz - the class being loaded

    • findShadowMethodHandle

      public MethodHandle findShadowMethodHandle(Class<?> definingClass, String name, MethodType methodType, boolean isStatic, boolean isNative) throws IllegalAccessException
      Description copied from interface: ClassHandler
      Called by Robolectric when an instrumented method is invoked.

      Implementations should return an MethodHandle, which will be invoked with details about the current instance and parameters.

      Implementations may also return null, in which case the method's original code will be executed.

      Specified by:
      findShadowMethodHandle in interface ClassHandler
      Parameters:
      definingClass - the class on which the method is declared
      name - the name of the method
      methodType - the method type
      isStatic - true if the method is static
      Returns:
      a method handle to invoke, or null if the original method's code should be executed
      Throws:
      IllegalAccessException
      See Also:

    • pickShadowMethod

      protected Method pickShadowMethod(Class<?> definingClass, String name, Class<?>[] paramTypes)
      Return a method handle of the shadow class which matches the given function signature of the shadowed class.
      Parameters:
      definingClass - The shadowed class
      name - The name of the method
      paramTypes - The parameter list of the method
      Returns:
      A method handle of the corresponding shadow class

    • intercept

      public Object intercept(String signature, Object instance, Object[] params, Class<?> theClass) throws Throwable
      Description copied from interface: ClassHandler
      Called by Robolectric when an intercepted method is invoked.

      Unlike instrumented methods, calls to intercepted methods are modified in place by Robolectric in the calling code. This is useful when the method about to be invoked doesn't exist in the current JVM (e.g. because of Android differences).

      Specified by:
      intercept in interface ClassHandler
      Parameters:
      signature - the JVM internal-format signature of the method being invoked (e.g. android/view/View/measure(II)V)
      instance - the instance on which the method would have been invoked
      params - the parameters to the method
      theClass - the class on which the method is declared
      Returns:
      the value to be returned
      Throws:
      Throwable - if anything bad happens

    • stripStackTrace

      public <T extends Throwable> T stripStackTrace(T throwable)
      Description copied from interface: ClassHandler
      Removes Robolectric noise from stack traces.
      Specified by:
      stripStackTrace in interface ClassHandler
      Type Parameters:
      T - the type of exception
      Parameters:
      throwable - the exception to be stripped
      Returns:
      the stripped stack trace

    • getShadowCreator

      public MethodHandle getShadowCreator(Class<?> theClass)
      Description copied from interface: ClassHandler
      Called by Robolectric to determine how to create and initialize a shadow object when a new instance of an instrumented class has been instantiated. (but only on JVMs which support the invokedynamic instruction).

      The returned MethodHandle will be invoked after the new object has been allocated but before its constructor code is executed.

      Note that this is not directly analogous to

      invalid reference 
      #initializing(Object)
      ; the return value from this method will be cached and used again for other instantiations of instances of the same class.
      Specified by:
      getShadowCreator in interface ClassHandler
      Parameters:
      theClass - the instrumented class
      Returns:
      a data value to be associated with the new instance
      See Also: