diff --git a/muzzle/src/test/groovy/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.groovy b/muzzle/src/test/groovy/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.groovy deleted file mode 100644 index 32d869e87afa..000000000000 --- a/muzzle/src/test/groovy/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.groovy +++ /dev/null @@ -1,152 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.javaagent.tooling.muzzle - -import io.opentelemetry.javaagent.tooling.muzzle.references.ClassRef -import io.opentelemetry.javaagent.tooling.muzzle.references.Flag -import io.opentelemetry.javaagent.tooling.muzzle.references.Source -import muzzle.HelperReferenceWrapperTestClasses -import net.bytebuddy.pool.TypePool -import org.objectweb.asm.Type -import spock.lang.Shared -import spock.lang.Specification - -import static io.opentelemetry.javaagent.tooling.muzzle.references.Flag.ManifestationFlag -import static java.util.stream.Collectors.toList - -class HelperReferenceWrapperTest extends Specification { - - @Shared - def baseHelperClass = ClassRef.builder(HelperReferenceWrapperTest.name + '$BaseHelper') - .setSuperClassName(HelperReferenceWrapperTestClasses.AbstractClasspathType.name) - .addFlag(ManifestationFlag.ABSTRACT) - .addMethod(new Source[0], new Flag[0], "foo", Type.VOID_TYPE) - .addMethod(new Source[0], [ManifestationFlag.ABSTRACT] as Flag[], "abstract", Type.INT_TYPE) - .build() - - @Shared - def helperClass = ClassRef.builder(HelperReferenceWrapperTest.name + '$Helper') - .setSuperClassName(baseHelperClass.className) - .addInterfaceName(HelperReferenceWrapperTestClasses.Interface2.name) - .addMethod(new Source[0], new Flag[0], "bar", Type.VOID_TYPE) - .addField(new Source[0], new Flag[0], "field", Type.getType("Ljava/lang/Object;"), false) - .addField(new Source[0], new Flag[0], "declaredField", Type.getType("Ljava/lang/Object;"), true) - .addField(new Source[0], [Flag.VisibilityFlag.PRIVATE] as Flag[], "privateFieldsAreSkipped", Type.getType("Ljava/lang/Object;"), true) - .build() - - def "should wrap helper types"() { - given: - def typePool = TypePool.Default.of(HelperReferenceWrapperTest.classLoader) - def references = [ - (helperClass.className) : helperClass, - (baseHelperClass.className): baseHelperClass - ] - - when: - def helperClassPredicate = new HelperClassPredicate({ false }) - def helperWrapper = new HelperReferenceWrapper.Factory(typePool, references, helperClassPredicate).create(helperClass) - - then: - with(helperWrapper) { helper -> - !helper.abstract - - with(helper.methods.collect(toList())) { - it.size() == 1 - with(it[0]) { - !it.abstract - it.name == "bar" - it.descriptor == "()V" - } - } - - with(helper.fields.collect(toList())) { - it.size() == 1 - with(it[0]) { - it.name == "declaredField" - it.descriptor == "Ljava/lang/Object;" - } - } - - helper.hasSuperTypes() - with(helper.superTypes.collect(toList())) { - it.size() == 2 - with(it[0]) { baseHelper -> - baseHelper.abstract - - with(baseHelper.methods.collect(toList())) { - it.size() == 2 - with(it[0]) { - !it.abstract - it.name == 'foo' - it.descriptor == '()V' - } - with(it[1]) { - it.abstract - it.name == 'abstract' - it.descriptor == '()I' - } - } - - baseHelper.hasSuperTypes() - with(baseHelper.superTypes.collect(toList())) { - it.size() == 1 - with(it[0]) { abstractClasspathType -> - abstractClasspathType.abstract - - abstractClasspathType.getMethods().collect(toList()).isEmpty() - - with(abstractClasspathType.fields.collect(toList())) { - it.size() == 1 - with(it[0]) { - it.name == "field" - it.descriptor == "Ljava/lang/Object;" - } - } - - abstractClasspathType.hasSuperTypes() - with(abstractClasspathType.superTypes.collect(toList())) { - it.size() == 2 - with(it[0]) { object -> - !object.hasSuperTypes() - } - with(it[1]) { interface1 -> - interface1.abstract - - with(interface1.methods.collect(toList())) { - it.size() == 1 - with(it[0]) { - it.abstract - it.name == "foo" - it.descriptor == "()V" - } - } - - !interface1.hasSuperTypes() - interface1.getSuperTypes().collect(toList()).isEmpty() - } - } - } - } - } - with(it[1]) { interface2 -> - interface2.abstract - - with(interface2.methods.collect(toList())) { - it.size() == 1 - with(it[0]) { - it.abstract - it.name == "bar" - it.descriptor == "()V" - } - } - - !interface2.hasSuperTypes() - interface2.getSuperTypes().collect(toList()).isEmpty() - } - } - } - } -} diff --git a/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.java b/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.java new file mode 100644 index 000000000000..8518336e9d69 --- /dev/null +++ b/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.java @@ -0,0 +1,153 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.muzzle; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.opentelemetry.javaagent.tooling.muzzle.references.ClassRef; +import io.opentelemetry.javaagent.tooling.muzzle.references.Flag; +import io.opentelemetry.javaagent.tooling.muzzle.references.Flag.ManifestationFlag; +import io.opentelemetry.javaagent.tooling.muzzle.references.Source; +import java.util.HashMap; +import java.util.Map; +import muzzle.HelperReferenceWrapperTestClasses; +import net.bytebuddy.pool.TypePool; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.objectweb.asm.Type; + +class HelperReferenceWrapperTest { + + private static ClassRef baseHelperClass; + private static ClassRef helperClass; + + @BeforeAll + static void setup() { + baseHelperClass = + ClassRef.builder(HelperReferenceWrapperTest.class.getName() + "$BaseHelper") + .setSuperClassName( + HelperReferenceWrapperTestClasses.AbstractClasspathType.class.getName()) + .addFlag(ManifestationFlag.ABSTRACT) + .addMethod(new Source[0], new Flag[0], "foo", Type.VOID_TYPE) + .addMethod( + new Source[0], new Flag[] {ManifestationFlag.ABSTRACT}, "abstract", Type.INT_TYPE) + .build(); + + helperClass = + ClassRef.builder(HelperReferenceWrapperTest.class.getName() + "$Helper") + .setSuperClassName(baseHelperClass.getClassName()) + .addInterfaceName(HelperReferenceWrapperTestClasses.Interface2.class.getName()) + .addMethod(new Source[0], new Flag[0], "bar", Type.VOID_TYPE) + .addField( + new Source[0], new Flag[0], "field", Type.getType("Ljava/lang/Object;"), false) + .addField( + new Source[0], + new Flag[0], + "declaredField", + Type.getType("Ljava/lang/Object;"), + true) + .addField( + new Source[0], + new Flag[] {Flag.VisibilityFlag.PRIVATE}, + "privateFieldsAreSkipped", + Type.getType("Ljava/lang/Object;"), + true) + .build(); + } + + @Test + void shouldWrapHelperTypes() { + TypePool typePool = TypePool.Default.of(HelperReferenceWrapperTest.class.getClassLoader()); + Map references = new HashMap<>(); + references.put(helperClass.getClassName(), helperClass); + references.put(baseHelperClass.getClassName(), baseHelperClass); + + HelperClassPredicate helperClassPredicate = new HelperClassPredicate(cls -> false); + HelperReferenceWrapper helperWrapper = + new HelperReferenceWrapper.Factory(typePool, references, helperClassPredicate) + .create(helperClass); + + assertThat(helperWrapper.isAbstract()).isFalse(); + + assertThat(helperWrapper.getMethods()) + .satisfiesExactly( + method -> { + assertThat(method.isAbstract()).isFalse(); + assertThat(method.getName()).isEqualTo("bar"); + assertThat(method.getDescriptor()).isEqualTo("()V"); + }); + + assertThat(helperWrapper.getFields()) + .satisfiesExactly( + field -> { + assertThat(field.getName()).isEqualTo("declaredField"); + assertThat(field.getDescriptor()).isEqualTo("Ljava/lang/Object;"); + }); + + assertThat(helperWrapper.hasSuperTypes()).isTrue(); + assertThat(helperWrapper.getSuperTypes()) + .satisfiesExactly( + baseHelper -> { + assertThat(baseHelper.isAbstract()).isTrue(); + assertThat(baseHelper.getMethods()) + .satisfiesExactly( + method -> { + assertThat(method.isAbstract()).isFalse(); + assertThat(method.getName()).isEqualTo("foo"); + assertThat(method.getDescriptor()).isEqualTo("()V"); + }, + method -> { + assertThat(method.isAbstract()).isTrue(); + assertThat(method.getName()).isEqualTo("abstract"); + assertThat(method.getDescriptor()).isEqualTo("()I"); + }); + + assertThat(baseHelper.hasSuperTypes()).isTrue(); + assertThat(baseHelper.getSuperTypes()) + .satisfiesExactly( + helperReferenceWrapper -> { + assertThat(helperReferenceWrapper.isAbstract()).isTrue(); + assertThat(helperReferenceWrapper.getMethods()).isEmpty(); + + assertThat(helperReferenceWrapper.getFields()) + .satisfiesExactly( + field -> { + assertThat(field.getName()).isEqualTo("field"); + assertThat(field.getDescriptor()).isEqualTo("Ljava/lang/Object;"); + }); + + assertThat(helperReferenceWrapper.hasSuperTypes()).isTrue(); + assertThat(helperReferenceWrapper.getSuperTypes()) + .satisfiesExactly( + wrapper -> assertThat(wrapper.hasSuperTypes()).isFalse(), + wrapper -> { + assertThat(wrapper.isAbstract()).isTrue(); + assertThat(wrapper.getMethods()) + .satisfiesExactly( + method -> { + assertThat(method.isAbstract()).isTrue(); + assertThat(method.getName()).isEqualTo("foo"); + assertThat(method.getDescriptor()).isEqualTo("()V"); + }); + assertThat(wrapper.hasSuperTypes()).isFalse(); + assertThat(wrapper.getSuperTypes()).isEmpty(); + }); + }); + }, + wrapper -> { + assertThat(wrapper.isAbstract()).isTrue(); + assertThat(wrapper.getMethods()) + .satisfiesExactly( + method -> { + assertThat(method.isAbstract()).isTrue(); + assertThat(method.getName()).isEqualTo("bar"); + assertThat(method.getDescriptor()).isEqualTo("()V"); + }); + assertThat(wrapper.hasSuperTypes()).isFalse(); + assertThat(wrapper.getSuperTypes()).isEmpty(); + }); + } +} diff --git a/muzzle/src/test/java/muzzle/HelperReferenceWrapperTestClasses.java b/muzzle/src/test/java/muzzle/HelperReferenceWrapperTestClasses.java index 33aa01c97d48..62c4369e7804 100644 --- a/muzzle/src/test/java/muzzle/HelperReferenceWrapperTestClasses.java +++ b/muzzle/src/test/java/muzzle/HelperReferenceWrapperTestClasses.java @@ -12,11 +12,11 @@ interface Interface1 { void foo(); } - interface Interface2 { + public interface Interface2 { void bar(); } - abstract static class AbstractClasspathType implements Interface1 { + public abstract static class AbstractClasspathType implements Interface1 { private Object privateFieldsAreIgnored; protected Object field;