Java Code Examples for net.bytebuddy.implementation.Implementation#SpecialMethodInvocation

@Test
@SuppressWarnings("unchecked")
public void testAccessorIsValid() throws Exception {
    TypeProxy typeProxy = new TypeProxy(mock(TypeDescription.class),
            mock(Implementation.Target.class),
            mock(TypeProxy.InvocationFactory.class),
            false,
            false);
    TypeProxy.MethodCall methodCall = typeProxy.new MethodCall(mock(MethodAccessorFactory.class));
    TypeDescription instrumentedType = mock(TypeDescription.class);
    FieldList<FieldDescription.InDefinedShape> fieldList = mock(FieldList.class);
    when(fieldList.filter(any(ElementMatcher.class))).thenReturn(fieldList);
    when(fieldList.getOnly()).thenReturn(mock(FieldDescription.InDefinedShape.class));
    when(instrumentedType.getDeclaredFields()).thenReturn(fieldList);
    TypeProxy.MethodCall.Appender appender = methodCall.new Appender(instrumentedType);
    Implementation.SpecialMethodInvocation specialMethodInvocation = mock(Implementation.SpecialMethodInvocation.class);
    when(specialMethodInvocation.isValid()).thenReturn(true);
    StackManipulation stackManipulation = appender.new AccessorMethodInvocation(mock(MethodDescription.class), specialMethodInvocation);
    assertThat(stackManipulation.isValid(), is(true));
    verify(specialMethodInvocation).isValid();
    verifyNoMoreInteractions(specialMethodInvocation);
}
 

@Test
public void testSuperTypeMethodIsInvokable() throws Exception {
    when(invokableMethod.isSpecializableFor(rawSuperClass)).thenReturn(true);
    Implementation.SpecialMethodInvocation specialMethodInvocation = makeImplementationTarget().invokeSuper(invokableToken);
    assertThat(specialMethodInvocation.isValid(), is(true));
    assertThat(specialMethodInvocation.getMethodDescription(), is((MethodDescription) invokableMethod));
    assertThat(specialMethodInvocation.getTypeDescription(), is(rawSuperClass));
    MethodVisitor methodVisitor = mock(MethodVisitor.class);
    Implementation.Context implementationContext = mock(Implementation.Context.class);
    StackManipulation.Size size = specialMethodInvocation.apply(methodVisitor, implementationContext);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKESPECIAL, BAR, FOO, QUX, false);
    verifyNoMoreInteractions(methodVisitor);
    verifyZeroInteractions(implementationContext);
    assertThat(size.getSizeImpact(), is(0));
    assertThat(size.getMaximalSize(), is(0));
}
 

@Test
public void testNonRebasedMethodIsInvokable() throws Exception {
    when(invokableMethod.getDeclaringType()).thenReturn(instrumentedType);
    when(invokableMethod.isSpecializableFor(instrumentedType)).thenReturn(true);
    when(resolution.isRebased()).thenReturn(false);
    when(resolution.getResolvedMethod()).thenReturn(invokableMethod);
    Implementation.SpecialMethodInvocation specialMethodInvocation = makeImplementationTarget().invokeSuper(rebasedSignatureToken);
    assertThat(specialMethodInvocation.isValid(), is(true));
    assertThat(specialMethodInvocation.getMethodDescription(), is((MethodDescription) invokableMethod));
    assertThat(specialMethodInvocation.getTypeDescription(), is(instrumentedType));
    MethodVisitor methodVisitor = mock(MethodVisitor.class);
    Implementation.Context implementationContext = mock(Implementation.Context.class);
    StackManipulation.Size size = specialMethodInvocation.apply(methodVisitor, implementationContext);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKESPECIAL, BAZ, FOO, QUX, false);
    verifyNoMoreInteractions(methodVisitor);
    verifyZeroInteractions(implementationContext);
    assertThat(size.getSizeImpact(), is(0));
    assertThat(size.getMaximalSize(), is(0));
}
 

/**
 * {@inheritDoc}
 */
public Implementation.SpecialMethodInvocation resolve(Implementation.Target implementationTarget, MethodDescription source) {
    if (!typeDescription.isInterface()) {
        throw new IllegalStateException(source + " method carries default method call parameter on non-interface type");
    }
    return implementationTarget.invokeDefault(source.asSignatureToken(), typeDescription);
}
 

@Test
public void testNonSpecializableSuperClassMethodIsNotInvokable() throws Exception {
    when(invokableMethod.isSpecializableFor(rawSuperClass)).thenReturn(false);
    when(resolution.isRebased()).thenReturn(false);
    when(resolution.getResolvedMethod()).thenReturn(invokableMethod);
    Implementation.SpecialMethodInvocation specialMethodInvocation = makeImplementationTarget().invokeSuper(invokableToken);
    assertThat(specialMethodInvocation.isValid(), is(false));
}
 

/**
 * Resolves a special method invocation for a non-constructor invocation.
 *
 * @param token A token describing the method to be invoked.
 * @return A special method invocation for a method representing the given method token, if available.
 */
private Implementation.SpecialMethodInvocation invokeMethod(MethodDescription.SignatureToken token) {
    MethodGraph.Node methodNode = methodGraph.getSuperClassGraph().locate(token);
    return methodNode.getSort().isUnique()
            ? Implementation.SpecialMethodInvocation.Simple.of(methodNode.getRepresentative(), instrumentedType.getSuperClass().asErasure())
            : Implementation.SpecialMethodInvocation.Illegal.INSTANCE;
}
 

/**
 * Resolves a special method invocation for a constructor invocation.
 *
 * @param token A token describing the constructor to be invoked.
 * @return A special method invocation for a constructor representing the given method token, if available.
 */
private Implementation.SpecialMethodInvocation invokeConstructor(MethodDescription.SignatureToken token) {
    TypeDescription.Generic superClass = instrumentedType.getSuperClass();
    MethodList<?> candidates = superClass == null
            ? new MethodList.Empty<MethodDescription.InGenericShape>()
            : superClass.getDeclaredMethods().filter(hasSignature(token).and(isVisibleTo(instrumentedType)));
    return candidates.size() == 1
            ? Implementation.SpecialMethodInvocation.Simple.of(candidates.getOnly(), instrumentedType.getSuperClass().asErasure())
            : Implementation.SpecialMethodInvocation.Illegal.INSTANCE;
}
 

/**
 * {@inheritDoc}
 */
public Implementation.SpecialMethodInvocation resolve(Implementation.Target implementationTarget, MethodDescription source) {
    if (!typeDescription.isInterface()) {
        throw new IllegalStateException(source + " method carries default method call parameter on non-interface type");
    }
    return implementationTarget.invokeDefault(source.asSignatureToken(), TargetType.resolve(typeDescription, implementationTarget.getInstrumentedType()));
}
 

@Test
public void testNonSpecializableRebaseMethodIsNotInvokable() throws Exception {
    when(invokableMethod.getDeclaringType()).thenReturn(instrumentedType);
    when(resolution.isRebased()).thenReturn(true);
    when(resolution.getResolvedMethod()).thenReturn(rebasedMethod);
    when(resolution.getPrependedParameters()).thenReturn(new TypeList.Empty());
    when(rebasedMethod.isSpecializableFor(instrumentedType)).thenReturn(false);
    Implementation.SpecialMethodInvocation specialMethodInvocation = makeImplementationTarget().invokeSuper(rebasedSignatureToken);
    assertThat(specialMethodInvocation.isValid(), is(false));
}
 

/**
 * {@inheritDoc}
 */
public Implementation.SpecialMethodInvocation resolve(Implementation.Target implementationTarget, MethodDescription source) {
    return implementationTarget.invokeDefault(source.asSignatureToken());
}
 

/** {@inheritDoc} */
public Implementation.SpecialMethodInvocation invoke(Implementation.Target implementationTarget,
                                                     TypeDescription proxiedType,
                                                     MethodDescription instrumentedMethod) {
    return implementationTarget.invokeDefault(instrumentedMethod.asSignatureToken(), proxiedType);
}
 

/**
 * {@inheritDoc}
 */
public Implementation.SpecialMethodInvocation invokeSuper(MethodDescription.SignatureToken token) {
    return token.getName().equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME)
            ? invokeConstructor(token)
            : invokeMethod(token);
}
 

@Test
public void testNonSpecializableSuperClassMethodIsNotInvokable() throws Exception {
    when(invokableMethod.isSpecializableFor(rawSuperClass)).thenReturn(false);
    Implementation.SpecialMethodInvocation specialMethodInvocation = makeImplementationTarget().invokeSuper(invokableToken);
    assertThat(specialMethodInvocation.isValid(), is(false));
}
 

protected Implementation.SpecialMethodInvocation make(MethodDescription methodDescription, TypeDescription typeDescription) {
    return new RebaseImplementationTarget.RebasedMethodInvocation(methodDescription,
            typeDescription,
            mock(StackManipulation.class),
            new TypeList.Empty());
}
 

/**
 * Creates a special method invocation for the given rebase resolution.
 *
 * @param resolution The resolution for which a special method invocation is to be created.
 * @return A special method invocation for the provided resolution.
 */
private Implementation.SpecialMethodInvocation invokeSuper(MethodRebaseResolver.Resolution resolution) {
    return resolution.isRebased()
            ? RebasedMethodInvocation.of(resolution.getResolvedMethod(), instrumentedType, resolution.getPrependedParameters())
            : Implementation.SpecialMethodInvocation.Simple.of(resolution.getResolvedMethod(), instrumentedType);
}
 

/**
 * Creates a new delegation method.
 *
 * @param specialMethodInvocation The special method invocation that represents the super method call.
 * @param cached                  {@code true} if the method constant should be cached.
 * @param privileged              {@code true} if this method should be looked up using an {@link java.security.AccessController}.
 */
protected DelegationMethod(Implementation.SpecialMethodInvocation specialMethodInvocation, boolean cached, boolean privileged) {
    this.specialMethodInvocation = specialMethodInvocation;
    this.cached = cached;
    this.privileged = privileged;
}
 

/**
 * Resolves the special method invocation to this target.
 *
 * @param implementationTarget The implementation target.
 * @param source               The method being instrumented.
 * @return A special method invocation that represents the super call of this binding.
 */
Implementation.SpecialMethodInvocation resolve(Implementation.Target implementationTarget, MethodDescription source);
 

/**
 * Creates a new delegation method.
 *
 * @param specialMethodInvocation The special method invocation that represents the super method call.
 * @param cached                  {@code true} if the method constant should be cached.
 * @param privileged              {@code true} if the method should be looked up using an {@link java.security.AccessController}.
 */
protected DelegationMethod(Implementation.SpecialMethodInvocation specialMethodInvocation, boolean cached, boolean privileged) {
    this.specialMethodInvocation = specialMethodInvocation;
    this.cached = cached;
    this.privileged = privileged;
}
 

/**
 * Creates a special method invocation to implement for a given method.
 *
 * @param implementationTarget The implementation target the type proxy is created for.
 * @param proxiedType          The type for the type proxy to subclass or implement.
 * @param instrumentedMethod   The instrumented method that is to be invoked.
 * @return A special method invocation of the given method or an illegal invocation if the proxy should
 * throw an {@link java.lang.AbstractMethodError} when the instrumented method is invoked.
 */
Implementation.SpecialMethodInvocation invoke(Implementation.Target implementationTarget,
                                              TypeDescription proxiedType,
                                              MethodDescription instrumentedMethod);
 

/**
 * Creates a new method call proxy for a given method and uses a default assigner for assigning the method's return
 * value to either the {@link java.util.concurrent.Callable#call()} or {@link Runnable#run()} method returns.
 *
 * @param specialMethodInvocation The special method invocation which should be invoked by this method call proxy.
 * @param serializableProxy       Determines if the generated proxy should be serializableProxy.
 */
public MethodCallProxy(Implementation.SpecialMethodInvocation specialMethodInvocation, boolean serializableProxy) {
    this(specialMethodInvocation, serializableProxy, Assigner.DEFAULT);
}