15
15
import static io .opentelemetry .javaagent .tooling .muzzle .references .Flag .OwnershipFlag .STATIC ;
16
16
import static java .util .Collections .emptySet ;
17
17
import static java .util .Collections .singleton ;
18
+ import static java .util .Collections .singletonList ;
19
+ import static java .util .Collections .singletonMap ;
18
20
import static org .assertj .core .api .Assertions .assertThat ;
19
21
20
22
import external .LibraryBaseClass ;
@@ -142,11 +144,12 @@ private static Stream<Arguments> matchingRefProvider() {
142
144
143
145
@ ParameterizedTest
144
146
@ 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 ) {
146
149
ClassRef ref = ClassRef .builder (referenceClass .getName ()).addFlag (referenceFlag ).build ();
147
150
148
151
List <Mismatch > mismatches =
149
- createMatcher (Collections . singletonMap (ref .getClassName (), ref ))
152
+ createMatcher (singletonMap (ref .getClassName (), ref ))
150
153
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
151
154
152
155
if (expectedMismatch == null ) {
@@ -158,19 +161,61 @@ void matchingRef(Class<?> referenceClass, Flag referenceFlag, Class<? extends Mi
158
161
159
162
private static Stream <Arguments > methodMatchProvider () {
160
163
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 ));
168
213
}
169
214
170
215
@ ParameterizedTest (name = "{0}" )
171
216
@ MethodSource ("methodMatchProvider" )
172
217
void methodMatch (
173
- String name ,
218
+ String testName ,
174
219
String methodName ,
175
220
Type methodType ,
176
221
Set <Flag > methodFlags ,
@@ -187,7 +232,7 @@ void methodMatch(
187
232
.build ();
188
233
189
234
List <Mismatch > mismatches =
190
- createMatcher (Collections . singletonMap (reference .getClassName (), reference ))
235
+ createMatcher (singletonMap (reference .getClassName (), reference ))
191
236
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
192
237
193
238
if (expectedMismatch == null ) {
@@ -199,36 +244,80 @@ void methodMatch(
199
244
200
245
private static Stream <Arguments > fieldMatchProvider () {
201
246
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 ));
210
303
}
211
304
212
- @ ParameterizedTest
305
+ @ ParameterizedTest ( name = "{0}" )
213
306
@ MethodSource ("fieldMatchProvider" )
214
307
void fieldMatch (
308
+ String testName ,
215
309
String fieldName ,
216
310
Type fieldType ,
217
311
Set <Flag > fieldFlags ,
218
312
Class <?> classToCheck ,
219
313
Class <? extends Mismatch > expectedMismatch ) {
220
314
ClassRef reference =
221
315
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 )
228
317
.build ();
229
318
230
319
List <Mismatch > mismatches =
231
- createMatcher (Collections . singletonMap (reference .getClassName (), reference ))
320
+ createMatcher (singletonMap (reference .getClassName (), reference ))
232
321
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
233
322
234
323
if (expectedMismatch == null ) {
@@ -256,8 +345,8 @@ void shouldNotCheckAbstractHelperClasses(String className) {
256
345
257
346
List <Mismatch > mismatches =
258
347
createMatcher (
259
- Collections . singletonMap (reference .getClassName (), reference ),
260
- Collections . singletonList (reference .getClassName ()))
348
+ singletonMap (reference .getClassName (), reference ),
349
+ singletonList (reference .getClassName ()))
261
350
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
262
351
263
352
assertThat (mismatches ).isEmpty ();
@@ -274,8 +363,8 @@ void shouldNotCheckHelperClassesWithNoSupertypes(String className) {
274
363
275
364
List <Mismatch > mismatches =
276
365
createMatcher (
277
- Collections . singletonMap (reference .getClassName (), reference ),
278
- Collections . singletonList (reference .getClassName ()))
366
+ singletonMap (reference .getClassName (), reference ),
367
+ singletonList (reference .getClassName ()))
279
368
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
280
369
281
370
assertThat (mismatches ).isEmpty ();
@@ -292,8 +381,8 @@ void shouldFailHelperClassesThatDoNotImplementAllAbstractMethods(String classNam
292
381
293
382
List <Mismatch > mismatches =
294
383
createMatcher (
295
- Collections . singletonMap (reference .getClassName (), reference ),
296
- Collections . singletonList (reference .getClassName ()))
384
+ singletonMap (reference .getClassName (), reference ),
385
+ singletonList (reference .getClassName ()))
297
386
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
298
387
299
388
assertThat (getMismatchClassSet (mismatches )).containsExactly (Mismatch .MissingMethod .class );
@@ -368,22 +457,23 @@ void shouldCheckHelperClassWhetherUsedFieldsAreDeclaredInTheSuperClass(String cl
368
457
369
458
List <Mismatch > mismatches =
370
459
createMatcher (
371
- Collections .singletonMap (helper .getClassName (), helper ),
372
- singletonList (helper .getClass ().getClassLoader ()))
460
+ singletonMap (helper .getClassName (), helper ), singletonList (helper .getClassName ()))
373
461
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
374
462
375
463
assertThat (mismatches ).isEmpty ();
376
464
}
377
465
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
+ })
385
475
void shouldFailHelperClassWhenItUsesFieldsUndeclaredInTheSuperClass (
386
- String className , String fieldName , String fieldType ) {
476
+ String testName , String className , String fieldName , String fieldType ) {
387
477
ClassRef helper =
388
478
ClassRef .builder (className )
389
479
.setSuperClassName (
@@ -395,8 +485,7 @@ void shouldFailHelperClassWhenItUsesFieldsUndeclaredInTheSuperClass(
395
485
396
486
List <Mismatch > mismatches =
397
487
createMatcher (
398
- Collections .singletonMap (helper .getClassName (), helper ),
399
- Collections .singletonList (helper .getClass ().getClassLoader ()))
488
+ singletonMap (helper .getClassName (), helper ), singletonList (helper .getClassName ()))
400
489
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
401
490
402
491
assertThat (getMismatchClassSet (mismatches )).containsExactly (Mismatch .MissingField .class );
@@ -421,7 +510,7 @@ void shouldFailHelperClassWhenTheLibraryParentClassHasDifferentConstructor(Strin
421
510
references .put (baseClassRef .getClassName (), baseClassRef );
422
511
423
512
List <Mismatch > mismatches =
424
- createMatcher (references , Collections . singletonList (helper .getClassName ()))
513
+ createMatcher (references , singletonList (helper .getClassName ()))
425
514
.getMismatchedReferenceSources (this .getClass ().getClassLoader ());
426
515
427
516
assertThat (getMismatchClassSet (mismatches )).containsExactly (Mismatch .MissingMethod .class );
0 commit comments