View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.maven.shared.dependency.analyzer.asm;
20  
21  import org.junit.jupiter.api.BeforeEach;
22  import org.junit.jupiter.api.Test;
23  import org.objectweb.asm.AnnotationVisitor;
24  import org.objectweb.asm.Attribute;
25  import org.objectweb.asm.FieldVisitor;
26  import org.objectweb.asm.Label;
27  import org.objectweb.asm.MethodVisitor;
28  import org.objectweb.asm.Opcodes;
29  import org.objectweb.asm.Type;
30  import org.objectweb.asm.signature.SignatureVisitor;
31  
32  import static org.assertj.core.api.Assertions.assertThat;
33  
34  /**
35   * Tests <code>DependencyVisitor</code>.
36   *
37   * @author <a href="mailto:markhobson@gmail.com">Mark Hobson</a>
38   */
39  class DependencyVisitorTest {
40      private final ResultCollector resultCollector = new ResultCollector();
41      private DefaultClassVisitor visitor;
42      private MethodVisitor mv;
43  
44      @BeforeEach
45      void setUp() {
46          AnnotationVisitor annotationVisitor = new DefaultAnnotationVisitor(resultCollector);
47          SignatureVisitor signatureVisitor = new DefaultSignatureVisitor(resultCollector);
48          FieldVisitor fieldVisitor = new DefaultFieldVisitor(annotationVisitor, resultCollector);
49          mv = new DefaultMethodVisitor(annotationVisitor, signatureVisitor, resultCollector);
50          visitor = new DefaultClassVisitor(signatureVisitor, annotationVisitor, fieldVisitor, mv, resultCollector);
51      }
52  
53      @Test
54      void testVisitWithDefaultSuperclass() {
55          // class a.b.c
56          visitor.visit(50, 0, "a/b/c", null, "java/lang/Object", null);
57  
58          assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object");
59      }
60  
61      @Test
62      void testVisitWithSuperclass() {
63          // class a.b.c
64          visitor.visit(50, 0, "a/b/c", null, "x/y/z", null);
65  
66          assertThat(resultCollector.getDependencies()).containsOnly("x.y.z");
67      }
68  
69      @Test
70      void testVisitWithInterface() {
71          // class a.b.c implements x.y.z
72          visitor.visit(50, 0, "a/b/c", null, "java/lang/Object", new String[] {"x/y/z"});
73  
74          assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", "x.y.z");
75      }
76  
77      @Test
78      void testVisitWithInterfaces() {
79          // class a.b.c implements p.q.r, x.y.z
80          visitor.visit(50, 0, "a/b/c", null, "java/lang/Object", new String[] {"p/q/r", "x/y/z"});
81  
82          assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", "p.q.r", "x.y.z");
83      }
84  
85      @Test
86      void testVisitWithUnboundedClassTypeParameter() {
87          // class a.b.c<T>
88          String signature = "<T:Ljava/lang/Object;>Ljava/lang/Object;";
89  
90          visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", null);
91  
92          assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object");
93      }
94  
95      @Test
96      void testVisitWithBoundedClassTypeParameter() {
97          // class a.b.c<T extends x.y.z>
98          String signature = "<T:Lx/y/z;>Ljava/lang/Object;";
99  
100         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", null);
101 
102         assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", "x.y.z");
103     }
104 
105     @Test
106     void testVisitWithBoundedClassTypeParameters() {
107         // class a.b.c<K extends p.q.r, V extends x.y.z>
108         String signature = "<K:Lp/q/r;V:Lx/y/z;>Ljava/lang/Object;";
109 
110         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", null);
111 
112         assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", "p.q.r", "x.y.z");
113     }
114 
115     @Test
116     void testVisitWithGenericInterface() {
117         // class a.b.c implements p.q.r<x.y.z>
118         String signature = "Ljava/lang/Object;Lp/q/r<Lx/y/z;>;";
119 
120         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", new String[] {"p.q.r"});
121 
122         assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", "p.q.r", "x.y.z");
123     }
124 
125     @Test
126     void testVisitWithInterfaceBound() {
127         // class a.b.c<T> implements x.y.z<T>
128         String signature = "<T:Ljava/lang/Object;>Ljava/lang/Object;Lx/y/z<TT;>;";
129 
130         visitor.visit(50, 0, "a/b/c", signature, "java/lang/Object", new String[] {"x.y.z"});
131 
132         assertThat(resultCollector.getDependencies()).containsOnly("java.lang.Object", "x.y.z");
133     }
134 
135     // visitSource tests ------------------------------------------------------
136 
137     @Test
138     void testVisitSource() {
139         visitor.visitSource(null, null);
140 
141         assertThat(resultCollector.getDependencies()).isEmpty();
142     }
143 
144     // visitOuterClass tests --------------------------------------------------
145 
146     @Test
147     void testVisitOuterClass() {
148         // class a.b.c
149         // {
150         //     class ...
151         //     {
152         //     }
153         // }
154         visitor.visitOuterClass("a/b/c", null, null);
155 
156         assertThat(resultCollector.getDependencies()).isEmpty();
157     }
158 
159     @Test
160     void testVisitOuterClassInMethod() {
161         // class a.b.c
162         // {
163         //     x.y.z x(p.q.r p)
164         //     {
165         //         class ...
166         //         {
167         //         }
168         //     }
169         // }
170         visitor.visitOuterClass("a/b/c", "x", "(Lp/q/r;)Lx/y/z;");
171 
172         assertThat(resultCollector.getDependencies()).isEmpty();
173     }
174 
175     // visitAnnotation tests --------------------------------------------------
176 
177     @Test
178     void testVisitAnnotation() {
179         assertVisitor(visitor.visitAnnotation("La/b/c;", false));
180 
181         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
182     }
183 
184     @Test
185     void testVisitAnnotationWithRuntimeVisibility() {
186         assertVisitor(visitor.visitAnnotation("La/b/c;", true));
187 
188         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
189     }
190 
191     // visitAttribute tests ---------------------------------------------------
192 
193     @Test
194     void testVisitAttribute() {
195         visitor.visitAttribute(new MockAttribute("a"));
196 
197         assertThat(resultCollector.getDependencies()).isEmpty();
198     }
199 
200     // visitInnerClass tests --------------------------------------------------
201 
202     @Test
203     void testVisitInnerClass() {
204         // TODO: ensure innerName is correct
205 
206         // class a.b.c { class x.y.z { } }
207         visitor.visitInnerClass("x/y/z", "a/b/c", "z", 0);
208 
209         assertThat(resultCollector.getDependencies()).isEmpty();
210     }
211 
212     @Test
213     void testVisitInnerClassAnonymous() {
214         // class a.b.c { new class x.y.z { } }
215         visitor.visitInnerClass("x/y/z$1", "a/b/c", null, 0);
216 
217         assertThat(resultCollector.getDependencies()).isEmpty();
218     }
219 
220     // visitField tests -------------------------------------------------------
221 
222     @Test
223     void testVisitField() {
224         // a.b.c a
225         assertVisitor(visitor.visitField(0, "a", "La/b/c;", null, null));
226 
227         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
228     }
229 
230     // TODO: determine actual use of default values
231     // void testVisitFieldWithValue()
232     // {
233     // }
234 
235     @Test
236     void testVisitFieldArray() {
237         // a.b.c[] a
238         assertVisitor(visitor.visitField(0, "a", "[La/b/c;", null, null));
239 
240         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
241     }
242 
243     @Test
244     void testVisitFieldGeneric() {
245         // a.b.c<x.y.z> a
246         assertVisitor(visitor.visitField(0, "a", "La/b/c;", "La/b/c<Lx/y/z;>;", null));
247 
248         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", "x.y.z");
249     }
250 
251     // visitMethod tests ------------------------------------------------------
252 
253     @Test
254     void testVisitMethod() {
255         // void a()
256         assertVisitor(visitor.visitMethod(0, "a", "()V", null, null));
257 
258         assertThat(resultCollector.getDependencies()).isEmpty();
259     }
260 
261     @Test
262     void testVisitMethodWithPrimitiveArgument() {
263         // void a(int)
264         assertVisitor(visitor.visitMethod(0, "a", "(I)V", null, null));
265 
266         assertThat(resultCollector.getDependencies()).isEmpty();
267     }
268 
269     @Test
270     void testVisitMethodWithPrimitiveArrayArgument() {
271         // void a(int[])
272         assertVisitor(visitor.visitMethod(0, "a", "([I)V", null, null));
273 
274         assertThat(resultCollector.getDependencies()).isEmpty();
275     }
276 
277     @Test
278     void testVisitMethodWithObjectArgument() {
279         // void a(a.b.c)
280         assertVisitor(visitor.visitMethod(0, "a", "(La/b/c;)V", null, null));
281 
282         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
283     }
284 
285     @Test
286     void testVisitMethodWithObjectArguments() {
287         // void a(a.b.c, x.y.z)
288         assertVisitor(visitor.visitMethod(0, "a", "(La/b/c;Lx/y/z;)V", null, null));
289 
290         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", "x.y.z");
291     }
292 
293     @Test
294     void testVisitMethodWithObjectArrayArgument() {
295         // void a(a.b.c[])
296         assertVisitor(visitor.visitMethod(0, "a", "([La/b/c;)V", null, null));
297 
298         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
299     }
300 
301     @Test
302     void testVisitMethodWithGenericArgument() {
303         // void a(a.b.c<x.y.z>)
304         assertVisitor(visitor.visitMethod(0, "a", "(La/b/c;)V", "(La/b/c<Lx/y/z;>;)V", null));
305 
306         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", "x.y.z");
307     }
308 
309     @Test
310     void testVisitMethodWithPrimitiveReturnType() {
311         // int a()
312         assertVisitor(visitor.visitMethod(0, "a", "()I", null, null));
313 
314         assertThat(resultCollector.getDependencies()).isEmpty();
315     }
316 
317     @Test
318     void testVisitMethodWithPrimitiveArrayReturnType() {
319         // int[] a()
320         assertVisitor(visitor.visitMethod(0, "a", "()[I", null, null));
321 
322         assertThat(resultCollector.getDependencies()).isEmpty();
323     }
324 
325     @Test
326     void testVisitMethodWithObjectReturnType() {
327         // a.b.c a()
328         assertVisitor(visitor.visitMethod(0, "a", "()La/b/c;", null, null));
329 
330         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
331     }
332 
333     @Test
334     void testVisitMethodWithObjectArrayReturnType() {
335         // a.b.c[] a()
336         assertVisitor(visitor.visitMethod(0, "a", "()[La/b/c;", null, null));
337 
338         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
339     }
340 
341     @Test
342     void testVisitMethodWithException() {
343         // void a() throws a.b.c
344         assertVisitor(visitor.visitMethod(0, "a", "()V", null, new String[] {"a/b/c"}));
345 
346         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
347     }
348 
349     @Test
350     void testVisitMethodWithExceptions() {
351         // void a() throws a.b.c, x.y.z
352         assertVisitor(visitor.visitMethod(0, "a", "()V", null, new String[] {"a/b/c", "x/y/z"}));
353 
354         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", "x.y.z");
355     }
356 
357     // visitAnnotationDefault tests -------------------------------------------
358 
359     @Test
360     void testVisitAnnotationDefault() {
361         assertVisitor(mv.visitAnnotationDefault());
362         assertThat(resultCollector.getDependencies()).isEmpty();
363     }
364 
365     // visitParameterAnnotation tests -------------------------------------------
366 
367     @Test
368     void testVisitParameterAnnotation() {
369         // @a.b.c
370         assertVisitor(mv.visitParameterAnnotation(0, "La/b/c;", false));
371 
372         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
373     }
374 
375     // visitCode tests --------------------------------------------------------
376 
377     @Test
378     void testVisitCode() {
379         mv.visitCode();
380 
381         assertThat(resultCollector.getDependencies()).isEmpty();
382     }
383 
384     // visitFrame tests -------------------------------------------------------
385 
386     @Test
387     void testVisitFrame() {
388         mv.visitFrame(Opcodes.F_NEW, 0, new Object[0], 0, new Object[0]);
389 
390         assertThat(resultCollector.getDependencies()).isEmpty();
391     }
392 
393     // visitInsn tests --------------------------------------------------------
394 
395     @Test
396     void testVisitInsn() {
397         mv.visitInsn(Opcodes.NOP);
398 
399         assertThat(resultCollector.getDependencies()).isEmpty();
400     }
401 
402     // visitIntInsn tests -----------------------------------------------------
403 
404     @Test
405     void testVisitIntInsn() {
406         mv.visitIntInsn(Opcodes.BIPUSH, 0);
407 
408         assertThat(resultCollector.getDependencies()).isEmpty();
409     }
410 
411     // visitVarInsn tests -----------------------------------------------------
412 
413     @Test
414     void testVisitVarInsn() {
415         mv.visitVarInsn(Opcodes.ILOAD, 0);
416 
417         assertThat(resultCollector.getDependencies()).isEmpty();
418     }
419 
420     // visitTypeInsn tests ----------------------------------------------------
421 
422     @Test
423     void testVisitTypeInsn() {
424         mv.visitTypeInsn(Opcodes.NEW, "a/b/c");
425 
426         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
427     }
428 
429     // visitFieldInsn tests ---------------------------------------------------
430 
431     @Test
432     void testVisitFieldInsnWithPrimitive() {
433         mv.visitFieldInsn(Opcodes.GETFIELD, "a/b/c", "x", "I");
434 
435         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
436     }
437 
438     @Test
439     void testVisitFieldInsnWithObject() {
440         mv.visitFieldInsn(Opcodes.GETFIELD, "a/b/c", "x", "Lx/y/z;");
441 
442         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
443     }
444 
445     // visitMethodInsn tests --------------------------------------------------
446 
447     @Test
448     void testVisitMethodInsn() {
449         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()V", false);
450 
451         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
452     }
453 
454     @Test
455     void testVisitMethodInsnWithPrimitiveArgument() {
456         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "(I)V", false);
457 
458         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
459     }
460 
461     @Test
462     void testVisitMethodInsnWithPrimitiveArrayArgument() {
463         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "([I)V", false);
464 
465         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
466     }
467 
468     @Test
469     void testVisitMethodInsnWithObjectArgument() {
470         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "(Lx/y/z;)V", false);
471 
472         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
473     }
474 
475     @Test
476     void testVisitMethodInsnWithObjectArguments() {
477         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "(Lp/q/r;Lx/y/z;)V", false);
478 
479         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
480     }
481 
482     @Test
483     void testVisitMethodInsnWithObjectArrayArgument() {
484         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "([Lx/y/z;)V", false);
485 
486         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
487     }
488 
489     @Test
490     void testVisitMethodInsnWithPrimitiveReturnType() {
491         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()I", false);
492 
493         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
494     }
495 
496     @Test
497     void testVisitMethodInsnWithPrimitiveArrayReturnType() {
498         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()[I", false);
499 
500         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
501     }
502 
503     @Test
504     void testVisitMethodInsnWithObjectReturnType() {
505         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()Lx/y/z;", false);
506 
507         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
508     }
509 
510     @Test
511     void testVisitMethodInsnWithObjectArrayReturnType() {
512         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "a/b/c", "x", "()[Lx/y/z;", false);
513 
514         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
515     }
516 
517     // visitJumpInsn tests ----------------------------------------------------
518 
519     @Test
520     void testVisitJumpInsn() {
521         mv.visitJumpInsn(Opcodes.IFEQ, new Label());
522 
523         assertThat(resultCollector.getDependencies()).isEmpty();
524     }
525 
526     // visitLabel tests -------------------------------------------------------
527 
528     @Test
529     void testVisitLabel() {
530         mv.visitLabel(new Label());
531 
532         assertThat(resultCollector.getDependencies()).isEmpty();
533     }
534 
535     // visitLdcInsn tests -----------------------------------------------------
536 
537     @Test
538     void testVisitLdcInsnWithNonType() {
539         mv.visitLdcInsn("a");
540 
541         assertThat(resultCollector.getDependencies()).isEmpty();
542     }
543 
544     @Test
545     void testVisitLdcInsnWithPrimitiveType() {
546         mv.visitLdcInsn(Type.INT_TYPE);
547 
548         assertThat(resultCollector.getDependencies()).isEmpty();
549     }
550 
551     @Test
552     void testVisitLdcInsnWithObjectType() {
553         mv.visitLdcInsn(Type.getType("La/b/c;"));
554 
555         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
556     }
557 
558     // visitIincInsn tests ----------------------------------------------------
559 
560     @Test
561     void testVisitIincInsn() {
562         mv.visitIincInsn(0, 1);
563 
564         assertThat(resultCollector.getDependencies()).isEmpty();
565     }
566 
567     // visitTableSwitchInsn tests ---------------------------------------------
568 
569     @Test
570     void testVisitTableSwitchInsn() {
571         mv.visitTableSwitchInsn(0, 1, new Label(), new Label());
572 
573         assertThat(resultCollector.getDependencies()).isEmpty();
574     }
575 
576     // visitLookupSwitchInsn tests --------------------------------------------
577 
578     @Test
579     void testVisitLookupSwitchInsn() {
580         mv.visitLookupSwitchInsn(new Label(), new int[] {0}, new Label[] {new Label()});
581 
582         assertThat(resultCollector.getDependencies()).isEmpty();
583     }
584 
585     // visitMultiANewArrayInsn tests ------------------------------------------
586 
587     @Test
588     void testVisitMultiANewArrayInsnWithPrimitive() {
589         mv.visitMultiANewArrayInsn("I", 2);
590 
591         assertThat(resultCollector.getDependencies()).isEmpty();
592     }
593 
594     @Test
595     void testVisitMultiANewArrayInsnWithObject() {
596         mv.visitMultiANewArrayInsn("La/b/c;", 2);
597 
598         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
599     }
600 
601     // visitTryCatchBlock tests -----------------------------------------------
602 
603     @Test
604     void testVisitTryCatchBlock() {
605         mv.visitTryCatchBlock(new Label(), new Label(), new Label(), "a/b/c");
606 
607         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
608     }
609 
610     @Test
611     void testVisitTryCatchBlockForFinally() {
612         mv.visitTryCatchBlock(new Label(), new Label(), new Label(), null);
613 
614         assertThat(resultCollector.getDependencies()).isEmpty();
615     }
616 
617     // visitLocalVariable tests -----------------------------------------------
618 
619     @Test
620     void testVisitLocalVariableWithPrimitive() {
621         mv.visitLocalVariable("a", "I", null, new Label(), new Label(), 0);
622 
623         assertThat(resultCollector.getDependencies()).isEmpty();
624     }
625 
626     @Test
627     void testVisitLocalVariableWithPrimitiveArray() {
628         mv.visitLocalVariable("a", "[I", null, new Label(), new Label(), 0);
629 
630         assertThat(resultCollector.getDependencies()).isEmpty();
631     }
632 
633     @Test
634     void testVisitLocalVariableWithObject() {
635         mv.visitLocalVariable("a", "La/b/c;", null, new Label(), new Label(), 0);
636 
637         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
638     }
639 
640     @Test
641     void testVisitLocalVariableWithObjectArray() {
642         mv.visitLocalVariable("a", "[La/b/c;", null, new Label(), new Label(), 0);
643 
644         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c");
645     }
646 
647     @Test
648     void testVisitLocalVariableWithGenericObject() {
649         mv.visitLocalVariable("a", "La/b/c;", "La/b/c<Lx/y/z;>;", new Label(), new Label(), 0);
650 
651         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", "x.y.z");
652     }
653 
654     @Test
655     void testVisitLocalVariableWithGenericObjectArray() {
656         mv.visitLocalVariable("a", "La/b/c;", "[La/b/c<Lx/y/z;>;", new Label(), new Label(), 0);
657 
658         assertThat(resultCollector.getDependencies()).containsOnly("a.b.c", "x.y.z");
659     }
660 
661     // visitLineNumber tests --------------------------------------------------
662 
663     @Test
664     void testVisitLineNumber() {
665         mv.visitLineNumber(0, new Label());
666 
667         assertThat(resultCollector.getDependencies()).isEmpty();
668     }
669 
670     // visitMaxs tests --------------------------------------------------------
671 
672     @Test
673     void testVisitMaxs() {
674         mv.visitMaxs(0, 0);
675 
676         assertThat(resultCollector.getDependencies()).isEmpty();
677     }
678 
679     private void assertVisitor(Object actualVisitor) {
680         // assertEquals( visitor, actualVisitor );
681     }
682 
683     /**
684      * A simple ASM <code>Attribute</code> for use in tests.
685      *
686      * @author <a href="mailto:markhobson@gmail.com">Mark Hobson</a>
687      */
688     static class MockAttribute extends Attribute {
689         MockAttribute(String type) {
690             super(type);
691         }
692     }
693 }