NPE demonstration

archunit-example/src/main/java/com/bar/Allow.java

@@ -0,0 +1,4 @@
+package com.bar;
+
+public @interface Allow {
+}

archunit-example/src/main/java/com/bar/evil/Evil.java

@@ -0,0 +1,4 @@
+package com.bar.evil;
+
+public class Evil {
+}

archunit-example/src/main/java/com/bar/some/Bad.java

@@ -0,0 +1,9 @@
+package com.bar.some;
+
+import com.bar.evil.Evil;
+
+public class Bad {
+    public Bad() {
+        new Evil();
+    }
+}

archunit-example/src/main/java/com/bar/some/Okay.java

@@ -0,0 +1,11 @@
+package com.bar.some;
+
+import com.bar.Allow;
+import com.bar.evil.Evil;
+
+@Allow
+public class Okay {
+    public Okay() {
+        new Evil();
+    }
+}

archunit-example/src/test/java/com/bar/IgnoreByAnnotationWorksTest.java

@@ -0,0 +1,18 @@
+package com.bar;
+
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.junit.ArchUnitRunner;
+import com.tngtech.archunit.lang.ArchRule;
+import org.junit.runner.RunWith;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+@RunWith(ArchUnitRunner.class)
+@AnalyzeClasses(packages = "com.bar")
+public class IgnoreByAnnotationWorksTest {
+    @ArchTest
+    public static final ArchRule ignoring_classes_annotated_with_Allow =
+            noClasses().that().areNotAnnotatedWith(Allow.class)
+                    .should().accessClassesThat().resideInAPackage("com.bar.evil");
+}

archunit-example/src/test/resources/log4j2.xml

@@ -6,8 +6,8 @@
         </Console>
     </Appenders>
     <Loggers>
-        <Root level="info">
+        <Root level="debug">
             <AppenderRef ref="Console"/>
         </Root>
     </Loggers>
-</Configuration>
+</Configuration>

archunit/src/main/java/com/tngtech/archunit/core/importer/JavaClassProcessor.java

@@ -23,6 +23,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -250,6 +251,9 @@ public void visitEnd() {
             return;
         }
 
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("Found annotations {} on class '{}'", annotations.stream().map(a -> a.getJavaType().getName()).collect(Collectors.joining(", ", "[", "]")), this.className);
+        }
         declarationHandler.onDeclaredAnnotations(annotations);
         LOG.debug("Done analysing {}", className);
     }

archunit/src/test/java/com/tngtech/archunit/lang/syntax/elements/GivenClassesThatTest.java

@@ -27,6 +27,7 @@
 import static com.tngtech.archunit.core.domain.properties.HasType.Functions.GET_TYPE;
 import static com.tngtech.archunit.lang.conditions.ArchPredicates.have;
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
 import static com.tngtech.archunit.testutil.Assertions.assertThat;
 import static com.tngtech.archunit.testutil.Assertions.assertThatClasses;
 import static org.mockito.Matchers.any;
@@ -205,6 +206,14 @@ public void areAnnotatedWith_type() {
         assertThat(getOnlyElement(classes)).matches(AnnotatedClass.class);
     }
 
+    @Test
+    public void areAnnotatedWith_type_inverse() {
+        List<JavaClass> classes = filterResultOf(noClasses().that().areNotAnnotatedWith(SomeAnnotation.class))
+                .on(AnnotatedClass.class, SimpleClass.class);
+
+        assertThat(getOnlyElement(classes)).matches(AnnotatedClass.class);
+    }
+
     @Test
     public void areNotAnnotatedWith_type() {
         List<JavaClass> classes = filterResultOf(classes().that().areNotAnnotatedWith(SomeAnnotation.class))
@@ -213,6 +222,14 @@ public void areNotAnnotatedWith_type() {
         assertThat(getOnlyElement(classes)).matches(SimpleClass.class);
     }
 
+    @Test
+    public void areNotAnnotatedWith_type_usingNoClasses() {
+        List<JavaClass> classes = filterResultOf(noClasses().that().areAnnotatedWith(SomeAnnotation.class))
+                .on(AnnotatedClass.class, SimpleClass.class);
+
+        assertThat(getOnlyElement(classes)).matches(SimpleClass.class);
+    }
+
     @Test
     public void areAnnotatedWith_typeName() {
         List<JavaClass> classes = filterResultOf(classes().that().areAnnotatedWith(SomeAnnotation.class.getName()))

build.gradle

@@ -95,8 +95,8 @@ subprojects {
     def addModuleDescription = { "${it} - Module '${project.name}'" }
     description addModuleDescription(rootProject.description)
 
-    sourceCompatibility = '1.7'
-    targetCompatibility = '1.7'
+    sourceCompatibility = '1.8'
+    targetCompatibility = '1.8'
 
     tasks.withType(Jar) {
         manifest {
@@ -213,4 +213,4 @@ productionProjects*.with {
     }
 }
 
-apply from: 'build-utils/build-utils.gradle'
+apply from: 'build-utils/build-utils.gradle'