Skip to content

Commit e112026

Browse files
zeitlingerzeitlinger
committed
convert test
1 parent 94ba3d8 commit e112026

File tree

3 files changed

+160
-154
lines changed

3 files changed

+160
-154
lines changed

‎muzzle/src/test/groovy/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.groovy‎

Lines changed: 0 additions & 152 deletions
This file was deleted.

‎muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/HelperReferenceWrapperTest.java‎

Lines changed: 158 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,158 @@
1+
/*
2+
* Copyright The OpenTelemetry Authors
3+
* SPDX-License-Identifier: Apache-2.0
4+
*/
5+
6+
package io.opentelemetry.javaagent.tooling.muzzle;
7+
8+
import io.opentelemetry.javaagent.tooling.muzzle.references.Flag.ManifestationFlag;
9+
import static org.assertj.core.api.Assertions.assertThat;
10+
11+
import io.opentelemetry.javaagent.tooling.muzzle.references.ClassRef;
12+
import io.opentelemetry.javaagent.tooling.muzzle.references.Flag;
13+
import io.opentelemetry.javaagent.tooling.muzzle.references.Source;
14+
import java.util.HashMap;
15+
import java.util.List;
16+
import java.util.Map;
17+
import java.util.stream.Collectors;
18+
import muzzle.HelperReferenceWrapperTestClasses;
19+
import net.bytebuddy.pool.TypePool;
20+
import org.junit.jupiter.api.BeforeAll;
21+
import org.junit.jupiter.api.Test;
22+
import org.objectweb.asm.Type;
23+
24+
class HelperReferenceWrapperTest {
25+
26+
private static ClassRef baseHelperClass;
27+
private static ClassRef helperClass;
28+
29+
@BeforeAll
30+
static void setup() {
31+
baseHelperClass =
32+
ClassRef.builder(HelperReferenceWrapperTest.class.getName() + "$BaseHelper")
33+
.setSuperClassName(
34+
HelperReferenceWrapperTestClasses.AbstractClasspathType.class.getName())
35+
.addFlag(ManifestationFlag.ABSTRACT)
36+
.addMethod(new Source[0], new Flag[0], "foo", Type.VOID_TYPE)
37+
.addMethod(
38+
new Source[0], new Flag[] {ManifestationFlag.ABSTRACT}, "abstract", Type.INT_TYPE)
39+
.build();
40+
41+
helperClass =
42+
ClassRef.builder(HelperReferenceWrapperTest.class.getName() + "$Helper")
43+
.setSuperClassName(baseHelperClass.getClassName())
44+
.addInterfaceName(HelperReferenceWrapperTestClasses.Interface2.class.getName())
45+
.addMethod(new Source[0], new Flag[0], "bar", Type.VOID_TYPE)
46+
.addField(
47+
new Source[0], new Flag[0], "field", Type.getType("Ljava/lang/Object;"), false)
48+
.addField(
49+
new Source[0],
50+
new Flag[0],
51+
"declaredField",
52+
Type.getType("Ljava/lang/Object;"),
53+
true)
54+
.addField(
55+
new Source[0],
56+
new Flag[] {Flag.VisibilityFlag.PRIVATE},
57+
"privateFieldsAreSkipped",
58+
Type.getType("Ljava/lang/Object;"),
59+
true)
60+
.build();
61+
}
62+
63+
@Test
64+
void shouldWrapHelperTypes() {
65+
TypePool typePool = TypePool.Default.of(HelperReferenceWrapperTest.class.getClassLoader());
66+
Map<String, ClassRef> references = new HashMap<>();
67+
references.put(helperClass.getClassName(), helperClass);
68+
references.put(baseHelperClass.getClassName(), baseHelperClass);
69+
70+
HelperClassPredicate helperClassPredicate = new HelperClassPredicate(cls -> false);
71+
HelperReferenceWrapper helperWrapper =
72+
new HelperReferenceWrapper.Factory(typePool, references, helperClassPredicate)
73+
.create(helperClass);
74+
75+
// helperWrapper assertions
76+
assertThat(helperWrapper.isAbstract()).isFalse();
77+
78+
List<HelperReferenceWrapper.Method> helperMethods =
79+
helperWrapper.getMethods().collect(Collectors.toList());
80+
assertThat(helperMethods).hasSize(1);
81+
HelperReferenceWrapper.Method barMethod = helperMethods.get(0);
82+
assertThat(barMethod.isAbstract()).isFalse();
83+
assertThat(barMethod.getName()).isEqualTo("bar");
84+
assertThat(barMethod.getDescriptor()).isEqualTo("()V");
85+
86+
List<HelperReferenceWrapper.Field> helperFields =
87+
helperWrapper.getFields().collect(Collectors.toList());
88+
assertThat(helperFields).hasSize(1);
89+
HelperReferenceWrapper.Field declaredField = helperFields.get(0);
90+
assertThat(declaredField.getName()).isEqualTo("declaredField");
91+
assertThat(declaredField.getDescriptor()).isEqualTo("Ljava/lang/Object;");
92+
93+
assertThat(helperWrapper.hasSuperTypes()).isTrue();
94+
List<HelperReferenceWrapper> superTypes =
95+
helperWrapper.getSuperTypes().collect(Collectors.toList());
96+
assertThat(superTypes).hasSize(2);
97+
98+
// baseHelper assertions
99+
HelperReferenceWrapper baseHelper = superTypes.get(0);
100+
assertThat(baseHelper.isAbstract()).isTrue();
101+
List<HelperReferenceWrapper.Method> baseHelperMethods =
102+
baseHelper.getMethods().collect(Collectors.toList());
103+
assertThat(baseHelperMethods).hasSize(2);
104+
HelperReferenceWrapper.Method fooMethod = baseHelperMethods.get(0);
105+
assertThat(fooMethod.isAbstract()).isFalse();
106+
assertThat(fooMethod.getName()).isEqualTo("foo");
107+
assertThat(fooMethod.getDescriptor()).isEqualTo("()V");
108+
HelperReferenceWrapper.Method abstractMethod = baseHelperMethods.get(1);
109+
assertThat(abstractMethod.isAbstract()).isTrue();
110+
assertThat(abstractMethod.getName()).isEqualTo("abstract");
111+
assertThat(abstractMethod.getDescriptor()).isEqualTo("()I");
112+
113+
assertThat(baseHelper.hasSuperTypes()).isTrue();
114+
List<HelperReferenceWrapper> baseSuperTypes =
115+
baseHelper.getSuperTypes().collect(Collectors.toList());
116+
assertThat(baseSuperTypes).hasSize(1);
117+
HelperReferenceWrapper abstractClasspathType = baseSuperTypes.get(0);
118+
assertThat(abstractClasspathType.isAbstract()).isTrue();
119+
assertThat(abstractClasspathType.getMethods().collect(Collectors.toList())).isEmpty();
120+
List<HelperReferenceWrapper.Field> abstractFields =
121+
abstractClasspathType.getFields().collect(Collectors.toList());
122+
assertThat(abstractFields).hasSize(1);
123+
HelperReferenceWrapper.Field field = abstractFields.get(0);
124+
assertThat(field.getName()).isEqualTo("field");
125+
assertThat(field.getDescriptor()).isEqualTo("Ljava/lang/Object;");
126+
127+
assertThat(abstractClasspathType.hasSuperTypes()).isTrue();
128+
List<HelperReferenceWrapper> abstractSuperTypes =
129+
abstractClasspathType.getSuperTypes().collect(Collectors.toList());
130+
assertThat(abstractSuperTypes).hasSize(2);
131+
HelperReferenceWrapper objectType = abstractSuperTypes.get(0);
132+
assertThat(objectType.hasSuperTypes()).isFalse();
133+
HelperReferenceWrapper interface1 = abstractSuperTypes.get(1);
134+
assertThat(interface1.isAbstract()).isTrue();
135+
List<HelperReferenceWrapper.Method> interface1Methods =
136+
interface1.getMethods().collect(Collectors.toList());
137+
assertThat(interface1Methods).hasSize(1);
138+
HelperReferenceWrapper.Method interface1Method = interface1Methods.get(0);
139+
assertThat(interface1Method.isAbstract()).isTrue();
140+
assertThat(interface1Method.getName()).isEqualTo("foo");
141+
assertThat(interface1Method.getDescriptor()).isEqualTo("()V");
142+
assertThat(interface1.hasSuperTypes()).isFalse();
143+
assertThat(interface1.getSuperTypes().collect(Collectors.toList())).isEmpty();
144+
145+
// interface2 assertions
146+
HelperReferenceWrapper interface2 = superTypes.get(1);
147+
assertThat(interface2.isAbstract()).isTrue();
148+
List<HelperReferenceWrapper.Method> interface2Methods =
149+
interface2.getMethods().collect(Collectors.toList());
150+
assertThat(interface2Methods).hasSize(1);
151+
HelperReferenceWrapper.Method interface2Method = interface2Methods.get(0);
152+
assertThat(interface2Method.isAbstract()).isTrue();
153+
assertThat(interface2Method.getName()).isEqualTo("bar");
154+
assertThat(interface2Method.getDescriptor()).isEqualTo("()V");
155+
assertThat(interface2.hasSuperTypes()).isFalse();
156+
assertThat(interface2.getSuperTypes().collect(Collectors.toList())).isEmpty();
157+
}
158+
}

‎muzzle/src/test/java/muzzle/HelperReferenceWrapperTestClasses.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,11 @@ interface Interface1 {
1212
void foo();
1313
}
1414

15-
interface Interface2 {
15+
public interface Interface2 {
1616
void bar();
1717
}
1818

19-
abstract static class AbstractClasspathType implements Interface1 {
19+
public abstract static class AbstractClasspathType implements Interface1 {
2020
private Object privateFieldsAreIgnored;
2121
protected Object field;
2222

0 commit comments

Comments
 (0)