Review: Add test that implicitly static nested interface behaves like…

… static nested class

Since we are already testing the case of an explicitly declared static member class, we might as well add a member interface as another test input, since it must behave exactly the same with respect to the class type.

Signed-off-by: Peter Gafert <[email protected]>

archunit/src/test/java/com/tngtech/archunit/core/importer/ClassFileImporterTest.java

@@ -275,8 +275,8 @@ public void imports_simple_class_details() throws Exception {
         assertThat(javaClass.isNestedClass()).as("is nested class").isFalse();
         assertThat(javaClass.isMemberClass()).as("is member class").isFalse();
         assertThat(javaClass.isInnerClass()).as("is inner class").isFalse();
-        assertThat(javaClass.isAnonymousClass()).as("is anonymous class").isFalse();
         assertThat(javaClass.isLocalClass()).as("is local class").isFalse();
+        assertThat(javaClass.isAnonymousClass()).as("is anonymous class").isFalse();
 
         assertThat(classes.get(ClassToImportTwo.class).getModifiers()).containsOnly(JavaModifier.PUBLIC, JavaModifier.FINAL);
     }
@@ -302,18 +302,24 @@ public void imports_simple_enum() throws Exception {
                 .containsOnly(EnumToImport.FIRST.name(), EnumToImport.SECOND.name());
     }
 
+    @DataProvider
+    public static Object[][] nested_static_classes() {
+        return testForEach(ClassWithInnerClass.NestedStatic.class, ClassWithInnerClass.ImplicitlyNestedStatic.class);
+    }
+
     @Test
-    public void imports_simple_static_nested_class() throws Exception {
+    @UseDataProvider("nested_static_classes")
+    public void imports_simple_static_nested_class(Class<?> nestedStaticClass) throws Exception {
         ImportedClasses classes = classesIn("testexamples/innerclassimport");
-        JavaClass staticNestedClass = classes.get(ClassWithInnerClass.Nested.class);
+        JavaClass staticNestedClass = classes.get(nestedStaticClass);
 
-        assertThat(staticNestedClass).matches(ClassWithInnerClass.Nested.class);
+        assertThat(staticNestedClass).matches(nestedStaticClass);
         assertThat(staticNestedClass.isTopLevelClass()).as("is top level class").isFalse();
         assertThat(staticNestedClass.isNestedClass()).as("is nested class").isTrue();
         assertThat(staticNestedClass.isMemberClass()).as("is member class").isTrue();
         assertThat(staticNestedClass.isInnerClass()).as("is inner class").isFalse();
-        assertThat(staticNestedClass.isAnonymousClass()).as("is anonymous class").isFalse();
         assertThat(staticNestedClass.isLocalClass()).as("is local class").isFalse();
+        assertThat(staticNestedClass.isAnonymousClass()).as("is anonymous class").isFalse();
     }
 
     @Test
@@ -326,8 +332,8 @@ public void imports_simple_inner_class() throws Exception {
         assertThat(innerClass.isNestedClass()).as("is nested class").isTrue();
         assertThat(innerClass.isMemberClass()).as("is member class").isTrue();
         assertThat(innerClass.isInnerClass()).as("is inner class").isTrue();
-        assertThat(innerClass.isAnonymousClass()).as("is anonymous class").isFalse();
         assertThat(innerClass.isLocalClass()).as("is local class").isFalse();
+        assertThat(innerClass.isAnonymousClass()).as("is anonymous class").isFalse();
     }
 
     @Test
@@ -340,8 +346,8 @@ public void imports_simple_anonymous_class() throws Exception {
         assertThat(anonymousClass.isNestedClass()).as("is nested class").isTrue();
         assertThat(anonymousClass.isMemberClass()).as("is member class").isFalse();
         assertThat(anonymousClass.isInnerClass()).as("is inner class").isTrue();
-        assertThat(anonymousClass.isAnonymousClass()).as("is anonymous class").isTrue();
         assertThat(anonymousClass.isLocalClass()).as("is local class").isFalse();
+        assertThat(anonymousClass.isAnonymousClass()).as("is anonymous class").isTrue();
     }
 
     @Test
@@ -354,8 +360,8 @@ public void imports_simple_local_class() throws Exception {
         assertThat(localClass.isNestedClass()).as("is nested class").isTrue();
         assertThat(localClass.isMemberClass()).as("is member class").isFalse();
         assertThat(localClass.isInnerClass()).as("is inner class").isTrue();
-        assertThat(localClass.isAnonymousClass()).as("is anonymous class").isFalse();
         assertThat(localClass.isLocalClass()).as("is local class").isTrue();
+        assertThat(localClass.isAnonymousClass()).as("is anonymous class").isFalse();
     }
 
     @Test

archunit/src/test/java/com/tngtech/archunit/core/importer/testexamples/innerclassimport/ClassWithInnerClass.java

@@ -36,7 +36,7 @@ void accessOuterClass() {
         }
     }
 
-    public static class Nested implements CanBeCalled {
+    public static class NestedStatic implements CanBeCalled {
         private CalledClass calledClass;
 
         @Override
@@ -45,6 +45,9 @@ public void call() {
         }
     }
 
+    public interface ImplicitlyNestedStatic {
+    }
+
     public interface CanBeCalled {
         void call();
     }