public class ShadowWrangler extends Object implements ClassHandler
ClassHandler.Plan| Modifier and Type | Field and Description |
|---|---|
static Method |
CALL_REAL_CODE |
static ClassHandler.Plan |
CALL_REAL_CODE_PLAN |
static MethodHandle |
DO_NOTHING |
static Function<Object,Object> |
DO_NOTHING_HANDLER |
static Method |
DO_NOTHING_METHOD |
static ClassHandler.Plan |
DO_NOTHING_PLAN |
static Implementation |
IMPLEMENTATION_DEFAULTS |
| Constructor and Description |
|---|
ShadowWrangler(ShadowMap shadowMap,
int apiLevel,
Interceptors interceptors) |
| Modifier and Type | Method and Description |
|---|---|
void |
classInitializing(Class clazz)
Called by Robolectric when an instrumented class is first loaded into a sandbox and is ready to be statically initialized.
|
MethodHandle |
findShadowMethodHandle(Class<?> definingClass,
String name,
MethodType methodType,
boolean isStatic)
Called by Robolectric when an instrumented method is invoked.
|
MethodHandle |
getShadowCreator(Class<?> theClass)
Called by Robolectric to determine how to create and initialize a shadow object when a new instance of an instrumented class has been instantiated.
|
Object |
initializing(Object instance)
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). |
Object |
intercept(String signature,
Object instance,
Object[] params,
Class theClass)
Called by Robolectric when an intercepted method is invoked.
|
static Class<?> |
loadClass(String paramType,
ClassLoader classLoader) |
ClassHandler.Plan |
methodInvoked(String signature,
boolean isStatic,
Class<?> theClass)
Called by Robolectric when an instrumented method is invoked.
|
protected Method |
pickShadowMethod(Class<?> definingClass,
String name,
Class<?>[] paramTypes) |
<T extends Throwable> |
stripStackTrace(T throwable)
Removes Robolectric noise from stack traces.
|
public static final ClassHandler.Plan DO_NOTHING_PLAN
public static final ClassHandler.Plan CALL_REAL_CODE_PLAN
public static final Method CALL_REAL_CODE
public static final MethodHandle DO_NOTHING
public static final Method DO_NOTHING_METHOD
public static final Implementation IMPLEMENTATION_DEFAULTS
public ShadowWrangler(ShadowMap shadowMap, int apiLevel, Interceptors interceptors)
public static Class<?> loadClass(String paramType, ClassLoader classLoader)
public void classInitializing(Class clazz)
ClassHandlerCalled 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>.
classInitializing in interface ClassHandlerclazz - the class being loadedpublic Object initializing(Object instance)
ClassHandlerCalled 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).
initializing in interface ClassHandlerinstance - the newly-created instancefor newer JVMspublic ClassHandler.Plan methodInvoked(String signature, boolean isStatic, Class<?> theClass)
ClassHandlerCalled 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.
methodInvoked in interface ClassHandlersignature - the JVM internal-format signature of the method being invoked (e.g. android/view/View/measure(II)V)isStatic - true if the method is statictheClass - the class on which the method is declarednull if the original method’s code should be executedfor newer JVMspublic MethodHandle findShadowMethodHandle(Class<?> definingClass, String name, MethodType methodType, boolean isStatic) throws IllegalAccessException
ClassHandlerCalled 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.
findShadowMethodHandle in interface ClassHandlerdefiningClass - the class on which the method is declaredname - the name of the methodmethodType - the method typeisStatic - true if the method is staticnull if the original method’s code should be executedIllegalAccessExceptionfor older JVMs,
for invalidating the returned {@link MethodHandle}protected Method pickShadowMethod(Class<?> definingClass, String name, Class<?>[] paramTypes)
public Object intercept(String signature, Object instance, Object[] params, Class theClass) throws Throwable
ClassHandlerCalled 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).
intercept in interface ClassHandlersignature - 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 invokedparams - the parameters to the methodtheClass - the class on which the method is declaredThrowable - if anything bad happenspublic <T extends Throwable> T stripStackTrace(T throwable)
ClassHandlerRemoves Robolectric noise from stack traces.
stripStackTrace in interface ClassHandlerT - the type of exceptionthrowable - the exception to be strippedpublic MethodHandle getShadowCreator(Class<?> theClass)
ClassHandlerCalled 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.
getShadowCreator in interface ClassHandlertheClass - the instrumented classfor older JVMs,
for invalidating the returned {@link MethodHandle}