Java Code Examples for net.bytebuddy.description.method.MethodDescription#ForLoadedMethod

@Test
@JavaVersionRule.Enforce(14)
@Ignore("Requires preview features")
public void testRecordComponentsField() throws Exception {
    Class<?> sampleRecord = Class.forName("net.bytebuddy.test.precompiled.SampleRecord");
    @SuppressWarnings("unchecked")
    Class<? extends Annotation> typeAnnotation = (Class<? extends Annotation>) Class.forName("net.bytebuddy.test.precompiled.TypeAnnotation");
    MethodDescription.InDefinedShape value = new MethodDescription.ForLoadedMethod(typeAnnotation.getMethod("value"));
    FieldDescription fieldDescription = describe(sampleRecord).getDeclaredFields().filter(named(FOO)).getOnly();
    assertThat(fieldDescription.getDeclaredAnnotations().size(), is(1));
    assertThat(fieldDescription.getDeclaredAnnotations().getOnly().getAnnotationType().represents(SampleAnnotation.class), is(true));
    assertThat(fieldDescription.getType().asErasure().represents(List.class), is(true));
    assertThat(fieldDescription.getType().getSort(), is(TypeDefinition.Sort.PARAMETERIZED));
    assertThat(fieldDescription.getType().getDeclaredAnnotations().size(), is(1));
    assertThat(fieldDescription.getType().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(fieldDescription.getType().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 42));
    assertThat(fieldDescription.getType().getTypeArguments().size(), is(1));
    assertThat(fieldDescription.getType().getTypeArguments().getOnly().getSort(), is(TypeDefinition.Sort.NON_GENERIC));
    assertThat(fieldDescription.getType().getTypeArguments().getOnly().asErasure().represents(String.class), is(true));
    assertThat(fieldDescription.getType().getTypeArguments().getOnly().getDeclaredAnnotations().size(), is(1));
    assertThat(fieldDescription.getType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(fieldDescription.getType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 84));
}
 

@Test
@JavaVersionRule.Enforce(14)
@Ignore("javac does not currently add type annotation meta data correctly")
public void testRecordComponentsAccessor() throws Exception {
    Class<?> sampleRecord = Class.forName("net.bytebuddy.test.precompiled.SampleRecord");
    @SuppressWarnings("unchecked")
    Class<? extends Annotation> typeAnnotation = (Class<? extends Annotation>) Class.forName("net.bytebuddy.test.precompiled.TypeAnnotation");
    MethodDescription.InDefinedShape value = new MethodDescription.ForLoadedMethod(typeAnnotation.getMethod("value"));
    MethodDescription methodDescription = describe(sampleRecord).getDeclaredMethods().filter(named(FOO)).getOnly();
    assertThat(methodDescription.getDeclaredAnnotations().size(), is(1));
    assertThat(methodDescription.getDeclaredAnnotations().getOnly().getAnnotationType().represents(SampleAnnotation.class), is(true));
    assertThat(methodDescription.getReturnType().asErasure().represents(List.class), is(true));
    assertThat(methodDescription.getReturnType().getSort(), is(TypeDefinition.Sort.PARAMETERIZED));
    assertThat(methodDescription.getReturnType().getDeclaredAnnotations().size(), is(1));
    assertThat(methodDescription.getReturnType().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(methodDescription.getReturnType().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 42));
    assertThat(methodDescription.getReturnType().getTypeArguments().size(), is(1));
    assertThat(methodDescription.getReturnType().getTypeArguments().getOnly().getSort(), is(TypeDefinition.Sort.NON_GENERIC));
    assertThat(methodDescription.getReturnType().getTypeArguments().getOnly().asErasure().represents(String.class), is(true));
    assertThat(methodDescription.getReturnType().getTypeArguments().getOnly().getDeclaredAnnotations().size(), is(1));
    assertThat(methodDescription.getReturnType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(methodDescription.getReturnType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 84));
}
 

@Test
@JavaVersionRule.Enforce(14)
@Ignore("javac does not currently add type annotation meta data correctly")
public void testRecordComponentsConstructorParameter() throws Exception {
    Class<?> sampleRecord = Class.forName("net.bytebuddy.test.precompiled.SampleRecord");
    @SuppressWarnings("unchecked")
    Class<? extends Annotation> typeAnnotation = (Class<? extends Annotation>) Class.forName("net.bytebuddy.test.precompiled.TypeAnnotation");
    MethodDescription.InDefinedShape value = new MethodDescription.ForLoadedMethod(typeAnnotation.getMethod("value"));
    ParameterDescription parameterDescription = describe(sampleRecord).getDeclaredMethods().filter(isConstructor()).getOnly().getParameters().getOnly();
    assertThat(parameterDescription.getDeclaredAnnotations().size(), is(1));
    assertThat(parameterDescription.getDeclaredAnnotations().getOnly().getAnnotationType().represents(SampleAnnotation.class), is(true));
    assertThat(parameterDescription.getType().asErasure().represents(List.class), is(true));
    assertThat(parameterDescription.getType().getSort(), is(TypeDefinition.Sort.PARAMETERIZED));
    assertThat(parameterDescription.getType().getDeclaredAnnotations().size(), is(1));
    assertThat(parameterDescription.getType().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(parameterDescription.getType().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 42));
    assertThat(parameterDescription.getType().getTypeArguments().size(), is(1));
    assertThat(parameterDescription.getType().getTypeArguments().getOnly().getSort(), is(TypeDefinition.Sort.NON_GENERIC));
    assertThat(parameterDescription.getType().getTypeArguments().getOnly().asErasure().represents(String.class), is(true));
    assertThat(parameterDescription.getType().getTypeArguments().getOnly().getDeclaredAnnotations().size(), is(1));
    assertThat(parameterDescription.getType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(parameterDescription.getType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 84));
}
 

@Test
public void testNestedInnerType() throws Exception {
    TypeDescription.Generic foo = describeReturnType(NestedInnerType.InnerType.class.getDeclaredMethod(FOO));
    assertThat(foo.getSort(), is(TypeDefinition.Sort.VARIABLE));
    assertThat(foo.getSymbol(), is(T));
    assertThat(foo.getUpperBounds().size(), is(1));
    assertThat(foo.getUpperBounds().getOnly(), is(TypeDescription.Generic.OBJECT));
    assertThat(foo.getTypeVariableSource(), is((TypeVariableSource) TypeDescription.ForLoadedType.of(NestedInnerType.class)));
    TypeDescription.Generic bar = describeReturnType(NestedInnerType.InnerType.class.getDeclaredMethod(BAR));
    assertThat(bar.getSort(), is(TypeDefinition.Sort.VARIABLE));
    assertThat(bar.getSymbol(), is(S));
    assertThat(bar.getUpperBounds().size(), is(1));
    assertThat(bar.getUpperBounds().getOnly(), is(foo));
    assertThat(bar.getTypeVariableSource(), is((TypeVariableSource) TypeDescription.ForLoadedType.of(NestedInnerType.InnerType.class)));
    TypeDescription.Generic qux = describeReturnType(NestedInnerType.InnerType.class.getDeclaredMethod(QUX));
    assertThat(qux.getSort(), is(TypeDefinition.Sort.VARIABLE));
    assertThat(qux.getSymbol(), is(U));
    assertThat(qux.getUpperBounds().size(), is(1));
    assertThat(qux.getUpperBounds().getOnly(), is(bar));
    MethodDescription quxMethod = new MethodDescription.ForLoadedMethod(NestedInnerType.InnerType.class.getDeclaredMethod(QUX));
    assertThat(qux.getTypeVariableSource(), is((TypeVariableSource) quxMethod));
}
 

/**
 * Returns a {@link StackManipulation} that returns the {@link
 * com.google.protobuf.Descriptors.EnumDescriptor} for the given enum field.
 */
static StackManipulation getEnumDescriptor(ProtoFieldInfo info) {
  Class<?> clz = info.enumClass();
  final MethodDescription.ForLoadedMethod getDescriptor;
  try {
    getDescriptor = new MethodDescription.ForLoadedMethod(clz.getDeclaredMethod("getDescriptor"));
  } catch (NoSuchMethodException e) {
    throw new IllegalStateException("Not an enum class: " + clz, e);
  }
  return MethodInvocation.invoke(getDescriptor);
}
 

@Test
public void testMatch() throws Throwable {
    ElementMatcher<MethodDescription> matcher = named("addHttpListener").and(takesArgument(2, HttpHandler.class));
    Method method = Undertow.Builder.class.getMethod("addHttpListener", int.class, String.class, HttpHandler.class);
    MethodDescription md = new MethodDescription.ForLoadedMethod(method);
    boolean r = matcher.matches(md);
    Assert.assertTrue(r);
}
 

@Test
@JavaVersionRule.Enforce(14)
@Ignore("Requires preview features")
public void testRecordComponents() throws Exception {
    Class<?> sampleRecord = Class.forName("net.bytebuddy.test.precompiled.SampleRecord");
    assertThat(describe(sampleRecord).isRecord(), is(true));
    @SuppressWarnings("unchecked")
    Class<? extends Annotation> typeAnnotation = (Class<? extends Annotation>) Class.forName("net.bytebuddy.test.precompiled.TypeAnnotation");
    MethodDescription.InDefinedShape value = new MethodDescription.ForLoadedMethod(typeAnnotation.getMethod("value"));
    RecordComponentList<RecordComponentDescription.InDefinedShape> recordComponents = describe(sampleRecord).getRecordComponents();
    assertThat(recordComponents.size(), is(1));
    assertThat(recordComponents.getOnly().getActualName(), is(FOO));
    assertThat(recordComponents.getOnly().getAccessor(), is((MethodDescription) new MethodDescription.ForLoadedMethod(sampleRecord.getMethod(FOO))));
    assertThat(recordComponents.getOnly().getDeclaringType(), is((TypeDefinition) TypeDescription.ForLoadedType.of(sampleRecord)));
    assertThat(recordComponents.getOnly().getDeclaredAnnotations().size(), is(1));
    assertThat(recordComponents.getOnly().getDeclaredAnnotations().getOnly().getAnnotationType().represents(SampleAnnotation.class), is(true));
    assertThat(recordComponents.getOnly().getType().asErasure().represents(List.class), is(true));
    assertThat(recordComponents.getOnly().getType().getSort(), is(TypeDefinition.Sort.PARAMETERIZED));
    assertThat(recordComponents.getOnly().getType().getDeclaredAnnotations().size(), is(1));
    assertThat(recordComponents.getOnly().getType().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(recordComponents.getOnly().getType().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 42));
    assertThat(recordComponents.getOnly().getType().getTypeArguments().size(), is(1));
    assertThat(recordComponents.getOnly().getType().getTypeArguments().getOnly().getSort(), is(TypeDefinition.Sort.NON_GENERIC));
    assertThat(recordComponents.getOnly().getType().getTypeArguments().getOnly().asErasure().represents(String.class), is(true));
    assertThat(recordComponents.getOnly().getType().getTypeArguments().getOnly().getDeclaredAnnotations().size(), is(1));
    assertThat(recordComponents.getOnly().getType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().getAnnotationType().represents(typeAnnotation), is(true));
    assertThat(recordComponents.getOnly().getType().getTypeArguments().getOnly().getDeclaredAnnotations().getOnly().prepare(typeAnnotation).getValue(value).resolve(), is((Object) 84));
}
 

@Test
public void testGenericMethod() throws Exception {
    DynamicType.Unloaded<?> unloaded = new ByteBuddy()
            .redefine(GenericMethod.class)
            .method(named(FOO))
            .intercept(FixedValue.nullValue())
            .make();
    Class<?> type = unloaded.load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER).getLoaded();
    MethodDescription createdMethod = new MethodDescription.ForLoadedMethod(type.getDeclaredMethod(FOO, Exception.class));
    MethodDescription originalMethod = new MethodDescription.ForLoadedMethod(GenericMethod.class.getDeclaredMethod(FOO, Exception.class));
    assertThat(createdMethod.getTypeVariables(), is(originalMethod.getTypeVariables()));
    assertThat(createdMethod.getReturnType(), is(originalMethod.getReturnType()));
    assertThat(createdMethod.getParameters().getOnly().getType(), is(originalMethod.getParameters().getOnly().getType()));
    assertThat(createdMethod.getExceptionTypes().getOnly(), is(originalMethod.getExceptionTypes().getOnly()));
}
 

@Test
public void testGenericMethodWithoutGenericExceptionTypes() throws Exception {
    DynamicType.Unloaded<?> unloaded = new ByteBuddy()
            .redefine(GenericMethod.class)
            .method(named(BAR))
            .intercept(FixedValue.nullValue())
            .make();
    Class<?> type = unloaded.load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER).getLoaded();
    MethodDescription createdMethod = new MethodDescription.ForLoadedMethod(type.getDeclaredMethod(BAR, Object.class));
    MethodDescription originalMethod = new MethodDescription.ForLoadedMethod(GenericMethod.class.getDeclaredMethod(BAR, Object.class));
    assertThat(createdMethod.getTypeVariables(), is(originalMethod.getTypeVariables()));
    assertThat(createdMethod.getReturnType(), is(originalMethod.getReturnType()));
    assertThat(createdMethod.getParameters().getOnly().getType(), is(originalMethod.getParameters().getOnly().getType()));
    assertThat(createdMethod.getExceptionTypes().getOnly(), is(originalMethod.getExceptionTypes().getOnly()));
}
 

@Test
public void testMethodMatch() throws Exception {
    final ElementMatcher<MethodDescription> matcher = Play2xInstrumentation.getFiltersMethodMatcher();
    final MethodDescription method = new MethodDescription.ForLoadedMethod(EnabledFilters.class.getMethod("filters"));
    Assert.assertTrue(matcher.matches(method));
}
 

@Override
public MethodDescription.InDefinedShape getAccessor() {
    return new MethodDescription.ForLoadedMethod(DISPATCHER.getAccessor(recordComponent));
}
 

protected MethodDescription.InDefinedShape asElement(Method element) {
    return new MethodDescription.ForLoadedMethod(element);
}