Package org.robolectric.internal.bytecode

Class 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 Detail

      • CALL_REAL_CODE

        public static final Method CALL_REAL_CODE

      • DO_NOTHING_METHOD

        public static final Method DO_NOTHING_METHOD

    • Method Detail

      • 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

      • initializing

        public Object initializing​(Object instance)
        Description copied from interface: ClassHandler
        Called by Robolectric when a new instance of an instrumented class has been created and is ready to be initialized (but only on JVMs which don't support the invokedynamic instruction).

        This happens before constructor code executes on the new instance.

        Implementations may return an object which will be associated with the new instance and passed along on future calls to ClassHandler.methodInvoked(String, boolean, Class).

        Specified by:
        initializing in interface ClassHandler
        Parameters:
        instance - the newly-created instance
        Returns:
        a data value to be associated with the new instance
        See Also:
        for newer JVMs

      • methodInvoked

        public ClassHandler.Plan methodInvoked​(String signature,
                                       boolean isStatic,
                                       Class<?> theClass)
        Description copied from interface: ClassHandler
        Called by Robolectric when an instrumented method is invoked.

        Implementations should return an ClassHandler.Plan, 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:
        methodInvoked in interface ClassHandler
        Parameters:
        signature - the JVM internal-format signature of the method being invoked (e.g. android/view/View/measure(II)V)
        isStatic - true if the method is static
        theClass - the class on which the method is declared
        Returns:
        an execution plan, or null if the original method's code should be executed
        See Also:
        for newer JVMs

      • findShadowMethodHandle

        public MethodHandle findShadowMethodHandle​(Class<?> definingClass,
                                           String name,
                                           MethodType methodType,
                                           boolean isStatic)
                                    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:
        for older JVMs, for invalidating the returned

      • pickShadowMethod

        protected Method pickShadowMethod​(Class<?> definingClass,
                                  String name,
                                  Class<?>[] paramTypes)

      • 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 ClassHandler.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:
        for older JVMs, for invalidating the returned