add doNotBelongToAnyOf(..) to syntax #422

TNG · Dec 14, 2020 · 23b462c · 23b462c
2 parents e5c6b75 + 64acfbf
commit 23b462c
Show file tree

Hide file tree

Showing 7 changed files with 68 additions and 2 deletions.
diff --git a/archunit/src/main/java/com/tngtech/archunit/lang/syntax/ClassesThatInternal.java b/archunit/src/main/java/com/tngtech/archunit/lang/syntax/ClassesThatInternal.java
@@ -358,6 +358,11 @@ public CONJUNCTION belongToAnyOf(Class<?>... classes) {
         return givenWith(JavaClass.Predicates.belongToAnyOf(classes));
     }
 
+    @Override
+    public CONJUNCTION doNotBelongToAnyOf(Class<?>... classes) {
+        return givenWith(doNot(JavaClass.Predicates.belongToAnyOf(classes)));
+    }
+
     @Override
     public CONJUNCTION arePublic() {
         return givenWith(SyntaxPredicates.arePublic());

diff --git a/archunit/src/main/java/com/tngtech/archunit/lang/syntax/MembersDeclaredInClassesThat.java b/archunit/src/main/java/com/tngtech/archunit/lang/syntax/MembersDeclaredInClassesThat.java
@@ -431,6 +431,11 @@ public CONJUNCTION belongToAnyOf(final Class<?>... classes) {
         return givenWith(JavaClass.Predicates.belongToAnyOf(classes));
     }
 
+    @Override
+    public CONJUNCTION doNotBelongToAnyOf(Class<?>... classes) {
+        return givenWith(doNot(JavaClass.Predicates.belongToAnyOf(classes)));
+    }
+
     private CONJUNCTION givenWith(DescribedPredicate<? super JavaClass> predicate) {
         return predicateAggregator.apply(predicate);
     }

diff --git a/archunit/src/main/java/com/tngtech/archunit/lang/syntax/elements/ClassesThat.java b/archunit/src/main/java/com/tngtech/archunit/lang/syntax/elements/ClassesThat.java
@@ -675,4 +675,12 @@ public interface ClassesThat<CONJUNCTION> {
     @PublicAPI(usage = ACCESS)
     CONJUNCTION belongToAnyOf(Class<?>... classes);
 
+    /**
+     * Inverted form of {@link #belongToAnyOf belongToAnyOf(Outer.class)}
+     *
+     * @param classes List of {@link Class} objects.
+     * @return A syntax conjunction element, which can be completed to form a full rule
+     */
+    @PublicAPI(usage = ACCESS)
+    CONJUNCTION doNotBelongToAnyOf(Class<?>... classes);
 }
diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java
@@ -758,6 +758,16 @@ public void belongToAnyOf() {
                 String.class);
     }
 
+    @Test
+    public void doNotBelongToAnyOf() {
+        List<JavaClass> classes = filterResultOf(classes().that().doNotBelongToAnyOf(ClassWithInnerClasses.class, String.class))
+                .on(ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class, ClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class,
+                        List.class, String.class, Iterable.class, StringBuilder.class);
+
+        assertThatTypes(classes).matchInAnyOrder(
+                List.class, Iterable.class, StringBuilder.class);
+    }
+
     @Test
     public void and_conjunction() {
         List<JavaClass> classes = filterResultOf(

diff --git a/...java/com/tngtech/archunit/lang/syntax/elements/GivenMembersDeclaredInClassesThatTest.java b/...java/com/tngtech/archunit/lang/syntax/elements/GivenMembersDeclaredInClassesThatTest.java
@@ -762,6 +762,19 @@ public void belongToAnyOf() {
         );
     }
 
+    @Test
+    public void doNotBelongToAnyOf() {
+        List<JavaMember> members =
+                filterResultOf(members().that().areDeclaredInClassesThat().doNotBelongToAnyOf(ClassWithInnerClasses.class, String.class))
+                        .on(ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class,
+                                ClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class,
+                                List.class, String.class, Iterable.class, StringBuilder.class);
+
+        assertThatMembers(members).matchInAnyOrderMembersOf(
+                List.class, Iterable.class, StringBuilder.class
+        );
+    }
+
     @Test
     public void and_conjunction() {
         List<JavaMember> members = filterResultOf(

diff --git a/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatTest.java b/archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldClassesThatTest.java
@@ -865,6 +865,17 @@ public void belongToAnyOf(ClassesThat<ClassesShouldConjunction> noClassesShouldT
                 ClassAccessingString.class);
     }
 
+    @Test
+    @UseDataProvider("no_classes_should_that_rule_starts")
+    public void doNotBelongToAnyOf(ClassesThat<ClassesShouldConjunction> noClassesShouldThatRuleStart) {
+        Set<JavaClass> classes = filterClassesAppearingInFailureReport(
+                noClassesShouldThatRuleStart.doNotBelongToAnyOf(ClassWithInnerClasses.class, String.class))
+                .on(ClassAccessingNestedInnerClass.class, ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class,
+                        ClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class, ClassAccessingString.class, ClassAccessingIterable.class);
+
+        assertThatTypes(classes).matchInAnyOrder(ClassAccessingIterable.class);
+    }
+
     @Test
     @UseDataProvider("classes_should_only_that_rule_starts")
     public void only_haveFullyQualifiedName(ClassesThat<ClassesShouldConjunction> classesShouldOnlyThatRuleStart) {

diff --git a/.../src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatTest.java b/.../src/test/java/com/tngtech/archunit/lang/syntax/elements/ShouldOnlyByClassesThatTest.java
@@ -987,6 +987,20 @@ public void belongToAnyOf(ClassesThat<ClassesShouldConjunction> classesShouldOnl
         assertThatTypes(classes).matchInAnyOrder(AnotherClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class);
     }
 
+    @Test
+    @UseDataProvider("should_only_be_by_rule_starts")
+    public void doNotBelongToAnyOf(ClassesThat<ClassesShouldConjunction> classesShouldOnlyBeBy) {
+        Set<JavaClass> classes = filterViolationCausesInFailureReport(
+                classesShouldOnlyBeBy.doNotBelongToAnyOf(ClassWithInnerClasses.class))
+                .on(ClassWithInnerClasses.class, ClassWithInnerClasses.InnerClass.class,
+                        ClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class,
+                        AnotherClassWithInnerClasses.class, AnotherClassWithInnerClasses.InnerClass.class,
+                        AnotherClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class,
+                        ClassBeingAccessedByInnerClass.class);
+
+        assertThatTypes(classes).matchInAnyOrder(ClassWithInnerClasses.InnerClass.EvenMoreInnerClass.class);
+    }
+
     @DataProvider
     public static Object[][] byClassesThat_predicate_rules() {
         return testForEach(
@@ -1183,7 +1197,7 @@ private static class ClassBeingAccessedByClassImplementingSomeInterface {
 
     @SuppressWarnings("unused")
     private static class ClassAccessingItself {
-        private String field;
+        private final String field;
 
         ClassAccessingItself(String field) {
             this.field = field;
@@ -1299,7 +1313,7 @@ void access() {
         }
     }
 
-    private static Runnable anonymousClassBeingAccessed = new Runnable() {
+    private static final Runnable anonymousClassBeingAccessed = new Runnable() {
         @Override
         public void run() {
             new ClassAccessingAnonymousClass();