fixup! add support to traverse JavaType signature

Review: Make test ensure correct visitation method is called Signed-off-by: Peter Gafert <peter.gafert@archunit.org>
TNG · Apr 7, 2024 · 464b1dd · 464b1dd
1 parent f002cbb
commit 464b1dd
Showing 1 changed file with 78 additions and 24 deletions.
diff --git a/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaTypeTraversalTest.java b/archunit/src/test/java/com/tngtech/archunit/core/domain/JavaTypeTraversalTest.java
@@ -24,7 +24,13 @@ class SimpleClass {
         JavaClass clazz = new ClassFileImporter().importClass(SimpleClass.class);
 
         List<JavaType> traversedClasses = new ArrayList<>();
-        clazz.traverseSignature(newTrackingVisitor(traversedClasses));
+        clazz.traverseSignature(new AllRejectingSignatureVisitor() {
+            @Override
+            public Result visitClass(JavaClass type) {
+                traversedClasses.add(type);
+                return Result.STOP;
+            }
+        });
 
         assertThatTypes(traversedClasses).matchExactly(SimpleClass.class);
     }
@@ -39,13 +45,15 @@ class SimpleClass {
         JavaType arrayType = new ClassFileImporter().importClass(SimpleClass.class).getField("field").getType();
 
         List<JavaType> traversedClasses = new ArrayList<>();
-        arrayType.traverseSignature(newTrackingVisitor(traversedClasses));
+        arrayType.traverseSignature(new AllRejectingSignatureVisitor() {
+            @Override
+            public Result visitArrayType(JavaClass type) {
+                traversedClasses.add(type);
+                return Result.STOP;
+            }
+        });
 
-        assertThatTypes(traversedClasses).matchExactly(
-                SimpleClass[][].class,
-                SimpleClass[].class,
-                SimpleClass.class
-        );
+        assertThatTypes(traversedClasses).matchExactly(SimpleClass[][].class);
     }
 
     @Test
@@ -60,12 +68,15 @@ class SomeClass<T> {
                 .getType();
 
         List<JavaType> traversedTypes = new ArrayList<>();
-        typeVariable.traverseSignature(newTrackingVisitor(traversedTypes));
+        typeVariable.traverseSignature(new AllRejectingSignatureVisitor() {
+            @Override
+            public Result visitTypeVariable(JavaTypeVariable<?> type) {
+                traversedTypes.add(type);
+                return Result.STOP;
+            }
+        });
 
-        assertThat(traversedTypes).containsOnly(
-                typeVariable,
-                typeVariable.getBounds().get(0) // implicitly java.lang.Object
-        );
+        assertThat(traversedTypes).containsOnly(typeVariable);
     }
 
     @Test
@@ -80,12 +91,15 @@ class SomeClass {
                 .getType();
 
         List<JavaType> traversedTypes = new ArrayList<>();
-        parameterizedType.traverseSignature(newTrackingVisitor(traversedTypes));
+        parameterizedType.traverseSignature(new AllRejectingSignatureVisitor() {
+            @Override
+            public Result visitParameterizedType(JavaParameterizedType type) {
+                traversedTypes.add(type);
+                return Result.STOP;
+            }
+        });
 
-        assertThat(traversedTypes).containsOnly(
-                parameterizedType,
-                getOnlyElement(parameterizedType.getActualTypeArguments())
-        );
+        assertThat(traversedTypes).containsOnly(parameterizedType);
     }
 
     @Test
@@ -102,7 +116,13 @@ class SomeClass {
         JavaWildcardType wildcardType = (JavaWildcardType) getOnlyElement(parameterizedType.getActualTypeArguments());
 
         List<JavaType> traversedTypes = new ArrayList<>();
-        wildcardType.traverseSignature(newTrackingVisitor(traversedTypes));
+        wildcardType.traverseSignature(new AllRejectingSignatureVisitor() {
+            @Override
+            public Result visitWildcardType(JavaWildcardType type) {
+                traversedTypes.add(type);
+                return Result.STOP;
+            }
+        });
 
         assertThat(traversedTypes).containsOnly(wildcardType);
     }
@@ -119,13 +139,15 @@ class SomeClass<T> {
                 .getType();
 
         List<JavaType> traversedTypes = new ArrayList<>();
-        genericArrayType.traverseSignature(newTrackingVisitor(traversedTypes));
+        genericArrayType.traverseSignature(new AllRejectingSignatureVisitor() {
+            @Override
+            public Result visitGenericArrayType(JavaGenericArrayType type) {
+                traversedTypes.add(type);
+                return Result.STOP;
+            }
+        });
 
-        assertThat(traversedTypes).containsOnly(
-                genericArrayType,
-                genericArrayType.getComponentType(),
-                ((JavaTypeVariable<?>) genericArrayType.getComponentType()).getBounds().get(0) // implicitly java.lang.Object
-        );
+        assertThat(traversedTypes).containsOnly(genericArrayType);
     }
 
     @Test
@@ -383,4 +405,36 @@ <T extends JavaType> T expect(JavaType javaType) {
             return (T) javaType;
         }
     }
+
+    private static class AllRejectingSignatureVisitor implements JavaType.SignatureVisitor {
+        @Override
+        public Result visitClass(JavaClass type) {
+            throw new UnsupportedOperationException("should not be called");
+        }
+
+        @Override
+        public Result visitArrayType(JavaClass type) {
+            throw new UnsupportedOperationException("should not be called");
+        }
+
+        @Override
+        public Result visitParameterizedType(JavaParameterizedType type) {
+            throw new UnsupportedOperationException("should not be called");
+        }
+
+        @Override
+        public Result visitTypeVariable(JavaTypeVariable<?> type) {
+            throw new UnsupportedOperationException("should not be called");
+        }
+
+        @Override
+        public Result visitGenericArrayType(JavaGenericArrayType type) {
+            throw new UnsupportedOperationException("should not be called");
+        }
+
+        @Override
+        public Result visitWildcardType(JavaWildcardType type) {
+            throw new UnsupportedOperationException("should not be called");
+        }
+    }
 }