Skip to content

Commit f125132

Browse files
zeitlingerzeitlinger
committed
pr review
1 parent a946937 commit f125132

File tree

1 file changed

+135
-46
lines changed

1 file changed

+135
-46
lines changed

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

Lines changed: 135 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,8 @@
1515
import static io.opentelemetry.javaagent.tooling.muzzle.references.Flag.OwnershipFlag.STATIC;
1616
import static java.util.Collections.emptySet;
1717
import static java.util.Collections.singleton;
18+
import static java.util.Collections.singletonList;
19+
import static java.util.Collections.singletonMap;
1820
import static org.assertj.core.api.Assertions.assertThat;
1921

2022
import external.LibraryBaseClass;
@@ -142,11 +144,12 @@ private static Stream<Arguments> matchingRefProvider() {
142144

143145
@ParameterizedTest
144146
@MethodSource("matchingRefProvider")
145-
void matchingRef(Class<?> referenceClass, Flag referenceFlag, Class<? extends Mismatch> expectedMismatch) {
147+
void matchingRef(
148+
Class<?> referenceClass, Flag referenceFlag, Class<? extends Mismatch> expectedMismatch) {
146149
ClassRef ref = ClassRef.builder(referenceClass.getName()).addFlag(referenceFlag).build();
147150

148151
List<Mismatch> mismatches =
149-
createMatcher(Collections.singletonMap(ref.getClassName(), ref))
152+
createMatcher(singletonMap(ref.getClassName(), ref))
150153
.getMismatchedReferenceSources(this.getClass().getClassLoader());
151154

152155
if (expectedMismatch == null) {
@@ -158,19 +161,61 @@ void matchingRef(Class<?> referenceClass, Flag referenceFlag, Class<? extends Mi
158161

159162
private static Stream<Arguments> methodMatchProvider() {
160163
return Stream.of(
161-
Arguments.of("method", Type.getMethodType(Type.getType(String.class), Type.getType(String.class)), emptySet(), Nested.B.class, null),
162-
Arguments.of("hashCode", Type.getMethodType(Type.INT_TYPE), emptySet(), Nested.B.class, null),
163-
Arguments.of("someMethod", Type.getMethodType(Type.VOID_TYPE), emptySet(), Nested.SomeInterface.class, null),
164-
Arguments.of("privateStuff", Type.getMethodType(Type.VOID_TYPE), singleton(PRIVATE_OR_HIGHER), Nested.B.class, null),
165-
Arguments.of("privateStuff", Type.getMethodType(Type.VOID_TYPE), singleton(PROTECTED_OR_HIGHER), Nested.B2.class, Mismatch.MissingFlag.class),
166-
Arguments.of("staticMethod", Type.getMethodType(Type.VOID_TYPE), singleton(NON_STATIC), Nested.B.class, Mismatch.MissingFlag.class),
167-
Arguments.of("missingMethod", Type.getMethodType(Type.VOID_TYPE), emptySet(), Nested.B.class, Mismatch.MissingMethod.class));
164+
Arguments.of(
165+
"match method declared in class",
166+
"method",
167+
Type.getMethodType(Type.getType(String.class), Type.getType(String.class)),
168+
emptySet(),
169+
Nested.B.class,
170+
null),
171+
Arguments.of(
172+
"match method declared in superclass",
173+
"hashCode",
174+
Type.getMethodType(Type.INT_TYPE),
175+
emptySet(),
176+
Nested.B.class,
177+
null),
178+
Arguments.of(
179+
"match method declared in interface",
180+
"someMethod",
181+
Type.getMethodType(Type.VOID_TYPE),
182+
emptySet(),
183+
Nested.SomeInterface.class,
184+
null),
185+
Arguments.of(
186+
"match private method",
187+
"privateStuff",
188+
Type.getMethodType(Type.VOID_TYPE),
189+
singleton(PRIVATE_OR_HIGHER),
190+
Nested.B.class,
191+
null),
192+
Arguments.of(
193+
"fail match private in supertype",
194+
"privateStuff",
195+
Type.getMethodType(Type.VOID_TYPE),
196+
singleton(PROTECTED_OR_HIGHER),
197+
Nested.B2.class,
198+
Mismatch.MissingFlag.class),
199+
Arguments.of(
200+
"static method mismatch",
201+
"staticMethod",
202+
Type.getMethodType(Type.VOID_TYPE),
203+
singleton(NON_STATIC),
204+
Nested.B.class,
205+
Mismatch.MissingFlag.class),
206+
Arguments.of(
207+
"missing method mismatch",
208+
"missingMethod",
209+
Type.getMethodType(Type.VOID_TYPE),
210+
emptySet(),
211+
Nested.B.class,
212+
Mismatch.MissingMethod.class));
168213
}
169214

170215
@ParameterizedTest(name = "{0}")
171216
@MethodSource("methodMatchProvider")
172217
void methodMatch(
173-
String name,
218+
String testName,
174219
String methodName,
175220
Type methodType,
176221
Set<Flag> methodFlags,
@@ -187,7 +232,7 @@ void methodMatch(
187232
.build();
188233

189234
List<Mismatch> mismatches =
190-
createMatcher(Collections.singletonMap(reference.getClassName(), reference))
235+
createMatcher(singletonMap(reference.getClassName(), reference))
191236
.getMismatchedReferenceSources(this.getClass().getClassLoader());
192237

193238
if (expectedMismatch == null) {
@@ -199,36 +244,80 @@ void methodMatch(
199244

200245
private static Stream<Arguments> fieldMatchProvider() {
201246
return Stream.of(
202-
Arguments.of("missingField", Type.getType(String.class), emptySet(), Nested.A.class, Mismatch.MissingField.class),
203-
Arguments.of("privateField", Type.getType(String.class), emptySet(), Nested.A.class, Mismatch.MissingField.class),
204-
Arguments.of("privateField", Type.getType(Object.class), singleton(PRIVATE_OR_HIGHER), Nested.A.class, null),
205-
Arguments.of("privateField", Type.getType(Object.class), singleton(PROTECTED_OR_HIGHER), Nested.A2.class, Mismatch.MissingFlag.class),
206-
Arguments.of("protectedField", Type.getType(Object.class), singleton(STATIC), Nested.A.class, Mismatch.MissingFlag.class),
207-
Arguments.of("staticB", Type.getType(Nested.B.class), new HashSet<>(Arrays.asList(STATIC, PROTECTED_OR_HIGHER)), Nested.A.class, null),
208-
Arguments.of("number", Type.INT_TYPE, singleton(PACKAGE_OR_HIGHER), Nested.Primitives.class, null),
209-
Arguments.of("flag", Type.BOOLEAN_TYPE, singleton(PACKAGE_OR_HIGHER), Nested.Primitives.class, null));
247+
Arguments.of(
248+
"mismatch missing field",
249+
"missingField",
250+
Type.getType(String.class),
251+
emptySet(),
252+
Nested.A.class,
253+
Mismatch.MissingField.class),
254+
Arguments.of(
255+
"mismatch field type signature",
256+
"privateField",
257+
Type.getType(String.class),
258+
emptySet(),
259+
Nested.A.class,
260+
Mismatch.MissingField.class),
261+
Arguments.of(
262+
"match private field",
263+
"privateField",
264+
Type.getType(Object.class),
265+
singleton(PRIVATE_OR_HIGHER),
266+
Nested.A.class,
267+
null),
268+
Arguments.of(
269+
"mismatch private field in supertype",
270+
"privateField",
271+
Type.getType(Object.class),
272+
singleton(PROTECTED_OR_HIGHER),
273+
Nested.A2.class,
274+
Mismatch.MissingFlag.class),
275+
Arguments.of(
276+
"mismatch static field",
277+
"protectedField",
278+
Type.getType(Object.class),
279+
singleton(STATIC),
280+
Nested.A.class,
281+
Mismatch.MissingFlag.class),
282+
Arguments.of(
283+
"match static field",
284+
"staticB",
285+
Type.getType(Nested.B.class),
286+
new HashSet<>(Arrays.asList(STATIC, PROTECTED_OR_HIGHER)),
287+
Nested.A.class,
288+
null),
289+
Arguments.of(
290+
"match primitive int",
291+
"number",
292+
Type.INT_TYPE,
293+
singleton(PACKAGE_OR_HIGHER),
294+
Nested.Primitives.class,
295+
null),
296+
Arguments.of(
297+
"match primitive boolean",
298+
"flag",
299+
Type.BOOLEAN_TYPE,
300+
singleton(PACKAGE_OR_HIGHER),
301+
Nested.Primitives.class,
302+
null));
210303
}
211304

212-
@ParameterizedTest
305+
@ParameterizedTest(name = "{0}")
213306
@MethodSource("fieldMatchProvider")
214307
void fieldMatch(
308+
String testName,
215309
String fieldName,
216310
Type fieldType,
217311
Set<Flag> fieldFlags,
218312
Class<?> classToCheck,
219313
Class<? extends Mismatch> expectedMismatch) {
220314
ClassRef reference =
221315
ClassRef.builder(classToCheck.getName())
222-
.addField(
223-
new Source[0],
224-
fieldFlags.toArray(new Flag[0]),
225-
fieldName,
226-
fieldType,
227-
false)
316+
.addField(new Source[0], fieldFlags.toArray(new Flag[0]), fieldName, fieldType, false)
228317
.build();
229318

230319
List<Mismatch> mismatches =
231-
createMatcher(Collections.singletonMap(reference.getClassName(), reference))
320+
createMatcher(singletonMap(reference.getClassName(), reference))
232321
.getMismatchedReferenceSources(this.getClass().getClassLoader());
233322

234323
if (expectedMismatch == null) {
@@ -256,8 +345,8 @@ void shouldNotCheckAbstractHelperClasses(String className) {
256345

257346
List<Mismatch> mismatches =
258347
createMatcher(
259-
Collections.singletonMap(reference.getClassName(), reference),
260-
Collections.singletonList(reference.getClassName()))
348+
singletonMap(reference.getClassName(), reference),
349+
singletonList(reference.getClassName()))
261350
.getMismatchedReferenceSources(this.getClass().getClassLoader());
262351

263352
assertThat(mismatches).isEmpty();
@@ -274,8 +363,8 @@ void shouldNotCheckHelperClassesWithNoSupertypes(String className) {
274363

275364
List<Mismatch> mismatches =
276365
createMatcher(
277-
Collections.singletonMap(reference.getClassName(), reference),
278-
Collections.singletonList(reference.getClassName()))
366+
singletonMap(reference.getClassName(), reference),
367+
singletonList(reference.getClassName()))
279368
.getMismatchedReferenceSources(this.getClass().getClassLoader());
280369

281370
assertThat(mismatches).isEmpty();
@@ -292,8 +381,8 @@ void shouldFailHelperClassesThatDoNotImplementAllAbstractMethods(String classNam
292381

293382
List<Mismatch> mismatches =
294383
createMatcher(
295-
Collections.singletonMap(reference.getClassName(), reference),
296-
Collections.singletonList(reference.getClassName()))
384+
singletonMap(reference.getClassName(), reference),
385+
singletonList(reference.getClassName()))
297386
.getMismatchedReferenceSources(this.getClass().getClassLoader());
298387

299388
assertThat(getMismatchClassSet(mismatches)).containsExactly(Mismatch.MissingMethod.class);
@@ -368,22 +457,23 @@ void shouldCheckHelperClassWhetherUsedFieldsAreDeclaredInTheSuperClass(String cl
368457

369458
List<Mismatch> mismatches =
370459
createMatcher(
371-
Collections.singletonMap(helper.getClassName(), helper),
372-
singletonList(helper.getClass().getClassLoader()))
460+
singletonMap(helper.getClassName(), helper), singletonList(helper.getClassName()))
373461
.getMismatchedReferenceSources(this.getClass().getClassLoader());
374462

375463
assertThat(mismatches).isEmpty();
376464
}
377465

378-
@ParameterizedTest
379-
@CsvSource({
380-
"io.opentelemetry.instrumentation.Helper, differentField, Ljava/lang/Integer;",
381-
"io.opentelemetry.instrumentation.Helper, field, Lcom/external/DifferentType;",
382-
"com.external.otel.instrumentation.Helper, differentField, Ljava/lang/Integer;",
383-
"com.external.otel.instrumentation.Helper, field, Lcom/external/DifferentType;"
384-
})
466+
@ParameterizedTest(name = "{0}")
467+
@CsvSource(
468+
delimiter = '|',
469+
value = {
470+
"internal helper, different field name | io.opentelemetry.instrumentation.Helper | differentField | Ljava/lang/Integer;",
471+
"internal helper, different field type | io.opentelemetry.instrumentation.Helper | field | Lcom/external/DifferentType;",
472+
"external helper, different field name | com.external.otel.instrumentation.Helper | differentField | Ljava/lang/Integer;",
473+
"external helper, different field type | com.external.otel.instrumentation.Helper | field | Lcom/external/DifferentType;"
474+
})
385475
void shouldFailHelperClassWhenItUsesFieldsUndeclaredInTheSuperClass(
386-
String className, String fieldName, String fieldType) {
476+
String testName, String className, String fieldName, String fieldType) {
387477
ClassRef helper =
388478
ClassRef.builder(className)
389479
.setSuperClassName(
@@ -395,8 +485,7 @@ void shouldFailHelperClassWhenItUsesFieldsUndeclaredInTheSuperClass(
395485

396486
List<Mismatch> mismatches =
397487
createMatcher(
398-
Collections.singletonMap(helper.getClassName(), helper),
399-
Collections.singletonList(helper.getClass().getClassLoader()))
488+
singletonMap(helper.getClassName(), helper), singletonList(helper.getClassName()))
400489
.getMismatchedReferenceSources(this.getClass().getClassLoader());
401490

402491
assertThat(getMismatchClassSet(mismatches)).containsExactly(Mismatch.MissingField.class);
@@ -421,7 +510,7 @@ void shouldFailHelperClassWhenTheLibraryParentClassHasDifferentConstructor(Strin
421510
references.put(baseClassRef.getClassName(), baseClassRef);
422511

423512
List<Mismatch> mismatches =
424-
createMatcher(references, Collections.singletonList(helper.getClassName()))
513+
createMatcher(references, singletonList(helper.getClassName()))
425514
.getMismatchedReferenceSources(this.getClass().getClassLoader());
426515

427516
assertThat(getMismatchClassSet(mismatches)).containsExactly(Mismatch.MissingMethod.class);

0 commit comments

Comments
 (0)