From 25592524c31f7cb5434bba32a14dba73db8d4004 Mon Sep 17 00:00:00 2001
From: Martin Dietze <mdietze@gmail.com>
Date: Mon, 8 Apr 2019 15:01:56 +0200
Subject: [PATCH] Issue #734: New check 'Jsr305AnnotationsCheck'

---
 .../coding/checkstyle-metadata.properties     |    7 +
 .../checks/coding/checkstyle-metadata.xml     |   43 +
 sevntu-checks/pom.xml                         |   13 +
 sevntu-checks/sevntu-checks.xml               |    8 +
 .../checks/coding/Jsr305AnnotationsCheck.java | 1043 +++++++++++++++++
 .../checks/coding/messages.properties         |   25 +
 .../coding/Jsr305AnnotationsCheckTest.java    |  565 +++++++++
 .../coding/Jsr305AnnotionsTestUtil.java       |  267 +++++
 .../checks/coding/test/ArraysTestObject.java  |  140 +++
 .../checks/coding/test/ClassTestObject.java   |  195 +++
 .../coding/test/ConstructorTestObject.java    |  107 ++
 .../test/DefaultReturnValuesTestObject.java   |   42 +
 .../test/DefectConstructorTestObject.java     |   37 +
 .../checks/coding/test/EnumTestObject.java    |   96 ++
 .../coding/test/InheritanceTestObject.java    |  117 ++
 .../checks/coding/test/LambdaTestObject.java  |   49 +
 .../coding/test/ParameterTestObject.java      |  112 ++
 .../coding/test/PrimitivesTestObject.java     |  120 ++
 .../test/RedundantClassLevelTestObject.java   |   38 +
 .../coding/test/ReturnValueTestObject.java    |  129 ++
 .../main/resources/checkstyle_packages.xml    |    2 +-
 .../sonar/checkstyle-extensions.xml           |   25 +
 22 files changed, 3179 insertions(+), 1 deletion(-)
 create mode 100644 sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheck.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheckTest.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotionsTestUtil.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ArraysTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ClassTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ConstructorTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefaultReturnValuesTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefectConstructorTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/EnumTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/InheritanceTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/LambdaTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ParameterTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/PrimitivesTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/RedundantClassLevelTestObject.java
 create mode 100644 sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ReturnValueTestObject.java

diff --git a/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.properties b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.properties
index e7efd317dd..d6f785e827 100755
--- a/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.properties
+++ b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.properties
@@ -188,3 +188,10 @@ MoveVariableInsideIfCheck.desc = Checks if a variable is only used inside if sta
 
 RequireFailForTryCatchInJunitCheck.name = Require Fail For Try/Catch in JUnit Check
 RequireFailForTryCatchInJunitCheck.desc = Checks if a try/catch block has a junit fail assertion inside the try  for a junit method.
+
+Jsr305AnnotationsCheck.name=Jsr305AnnotationsCheck
+Jsr305AnnotationsCheck.desc=Checks method parameters and return values for the presence of @Nonnull, @Nullable, or @CheckForNull annotations.
+Jsr305AnnotationsCheck.packages=Packages to be checked.
+Jsr305AnnotationsCheck.excludePackages=Packages excluded from checking.
+Jsr305AnnotationsCheck.allowOverridingReturnValue=Allow Overriding return values, useful for upgrading.
+Jsr305AnnotationsCheck.allowOverridingParameter=Allow Overriding paramaters, useful for upgrading.
diff --git a/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.xml b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.xml
index 3392c3bec1..6fa4dda594 100644
--- a/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.xml
+++ b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/coding/checkstyle-metadata.xml
@@ -556,5 +556,48 @@
       <message-key key="require.fail"/>
     </rule-metadata>
 
+    <rule-metadata name="%Jsr305AnnotationsCheck.name" internal-name="Jsr305AnnotationsCheck" parent="TreeWalker">
+      <alternative-name internal-name="com.github.sevntu.checkstyle.checks.coding.Jsr305AnnotationsCheck"/>
+      <description>%Jsr305AnnotationsCheck.desc</description>
+      <property-metadata name="packages" datatype="String">
+        <description>%Jsr305AnnotationsCheck.packages</description>
+      </property-metadata>
+      <property-metadata name="excludePackages" datatype="String">
+        <description>%Jsr305AnnotationsCheck.excludePackages</description>
+      </property-metadata>
+      <property-metadata name="allowOverridingReturnValue" datatype="Boolean" default-value="false">
+        <description>%Jsr305AnnotationsCheck.allowOverridingReturnValue</description>
+      </property-metadata>
+      <property-metadata name="allowOverridingParameter" datatype="Boolean" default-value="false">
+        <description>%Jsr305AnnotationsCheck.allowOverridingParameter</description>
+      </property-metadata>
+
+      <message-key key="jsr305.illegal.class.level.annotation" />
+      <message-key key="jsr305.contradicting.class.level.annotations" />
+      <message-key key="jsr305.param.definitions.with.check.annotation" />
+      <message-key key="jsr305.param.definition.with.override.annotation" />
+      <message-key key="jsr305.param.definition.with.nonnull.by.default.annotation" />
+      <message-key key="jsr305.param.definition.with.nullable.by.default.annotation" />
+      <message-key key="jsr305.param.definition.with.return.values.default.annotation" />
+      <message-key key="jsr305.param.nonnull.and.nullable.annotation" />
+      <message-key key="jsr305.primitives.with.nullness.annotation" />
+      <message-key key="jsr305.overridden.definitions.with.increased.param.constraint" />
+      <message-key key="jsr305.redundant.nonnull.param.annotation" />
+      <message-key key="jsr305.redundant.nullable.param.annotation" />
+      <message-key key="jsr305.parameter.without.nullness.annotation" />
+      <message-key key="jsr305.return.value.with.nonnull.by.default.annotation" />
+      <message-key key="jsr305.return.value.with.nullable.annotation" />
+      <message-key key="jsr305.contradicting.return.value.annotations" />
+      <message-key key="jsr305.overridden.method.with.check.return.value.annotation" />
+      <message-key key="jsr305.redundant.nonnull.by.default.annotation" />
+      <message-key key="jsr305.redundant.nullable.by.default.annotation" />
+      <message-key key="jsr305.void.with.check.return.value.annotation" />
+      <message-key key="jsr305.redundant.nonnull.return.annotation" />
+      <message-key key="jsr305.return.without.nullness.annotation" />
+      <message-key key="jsr305.overridden.methods.allow.only.nonnull" />
+      <message-key key="jsr305.need.to.inherit.param.annotations" />
+      <message-key key="jsr305.constructor.with.return.annotation" />
+   </rule-metadata>
+
   </rule-group-metadata>
 </checkstyle-metadata>
diff --git a/sevntu-checks/pom.xml b/sevntu-checks/pom.xml
index 51520c4a20..7298767531 100644
--- a/sevntu-checks/pom.xml
+++ b/sevntu-checks/pom.xml
@@ -45,6 +45,17 @@
       <scope>test</scope>
       <version>${checkstyle.eclipse-cs.version}</version>
     </dependency>
+    <!-- required for package/jsr305  -->
+    <dependency>
+      <groupId>com.google.code.findbugs</groupId>
+      <artifactId>jsr305</artifactId>
+      <version>3.0.1</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.findbugs</groupId>
+      <artifactId>annotations</artifactId>
+      <version>3.0.1</version>
+    </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
@@ -283,6 +294,8 @@
               <regex><pattern>.*.checks.coding.MapIterationInForEachLoopCheck</pattern><branchRate>90</branchRate><lineRate>98</lineRate></regex>
               <regex><pattern>.*.checks.coding.NoNullForCollectionReturnCheck</pattern><branchRate>85</branchRate><lineRate>96</lineRate></regex>
               <regex><pattern>.*.checks.coding.OverridableMethodInConstructorCheck</pattern><branchRate>94</branchRate><lineRate>99</lineRate></regex>
+              <regex><pattern>.*.checks.coding.Jsr305AnnotationsCheck</pattern><branchRate>84</branchRate><lineRate>93</lineRate></regex>
+              <regex><pattern>.*.checks.coding.Jsr305AnnotationsCheck.AbstractJsr305Check</pattern><branchRate>95</branchRate><lineRate>98</lineRate></regex>
               <regex><pattern>.*.checks.design.HideUtilityClassConstructorCheck</pattern><branchRate>94</branchRate><lineRate>100</lineRate></regex>
             </regexes>
           </check>
diff --git a/sevntu-checks/sevntu-checks.xml b/sevntu-checks/sevntu-checks.xml
index d4c7612e18..dacefc8868 100644
--- a/sevntu-checks/sevntu-checks.xml
+++ b/sevntu-checks/sevntu-checks.xml
@@ -216,6 +216,14 @@
       <property name="ignoreMethod" value="false"/>
     </module>
 
+    <!-- Jsr305 -->
+    <module name="com.github.sevntu.checkstyle.checks.coding.Jsr305AnnotationsCheck">
+      <property name="packages" value="your.package.path.to.check,another.package.path.to.check"/>
+      <property name="excludePackages" value="your.package.path.not.to.check,another.package.path.not.to.check"/>
+      <property name="allowOverridingReturnValue" value="false"/>
+      <property name="allowOverridingParameter" value="false"/>
+    </module>
+
     <!-- moved to checkstyle project since 1.21.0 -->
     <!--
         <module name="com.github.sevntu.checkstyle.checks.whitespace.SingleSpaceSeparatorCheck">
diff --git a/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheck.java b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheck.java
new file mode 100644
index 0000000000..431b47101a
--- /dev/null
+++ b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheck.java
@@ -0,0 +1,1043 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import antlr.collections.AST;
+import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
+import com.puppycrawl.tools.checkstyle.api.DetailAST;
+import com.puppycrawl.tools.checkstyle.api.FullIdent;
+import com.puppycrawl.tools.checkstyle.api.TokenTypes;
+
+/**
+ * Jsr305AnnotationsCheck - a check to enforce use of nullness anotations.
+ * The standalone version of this plugin resides under
+ * <a href="https://github.com/bjrke/JSR305CheckstylePlugin">
+ * https://github.com/mbert/JSR305CheckstylePlugin</a>
+ * <p>
+ * Copyright (C) 2008 Marcus Thiesen (initial version) Copyright (C) 2008-2019 Jan Burkhardt
+ * (maintainer)
+ * <br>
+ * Thanks to Mattias Nissler, Thorsten Ehlers, Fabian Loewner, Ole Langbehn for contributions.
+ * </p>
+ * <p>
+ * This check is activated by setting the package(s) to check:
+ * <br>
+ * packages = org.package1,com.package2
+ * </p>
+ * <p>
+ * Finetuning can be performed using the following settings:
+ * <br>
+ * Exclude some packages from checking:
+ * <br>
+ * excludePackages = org.package1.generated,com.package2.external
+ * <br>
+ * Allow overriding return values and/or parameters (useful for upgrading):
+ * <br>
+ * allowOverridingReturnValue = true
+ * <br>
+ * allowOverridingParameters = true
+ * </p>
+ */
+public class Jsr305AnnotationsCheck extends AbstractCheck {
+
+    /** Key for error message. */
+    public static final String MSG_ILLEGAL_CLASS_LEVEL_ANNOTATION =
+            "jsr305.illegal.class.level.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_CONTRADICTING_CLASS_LEVEL_ANNOTATIONS =
+            "jsr305.contradicting.class.level.annotations";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITIONS_WITH_CHECK_ANNOTATION =
+            "jsr305.param.definitions.with.check.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_OVERRIDE_ANNOTATION =
+            "jsr305.param.definition.with.override.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_NONNULL_BY_DEFAULT_ANNOTATION =
+            "jsr305.param.definition.with.nonnull.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_NULLABLE_BY_DEFAULT_ANNOTATION =
+            "jsr305.param.definition.with.nullable.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_RETURN_VALUES_DEFAULT_ANNOTATION =
+            "jsr305.param.definition.with.return.values.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_NONNULL_AND_NULLABLE_ANNOTATION =
+            "jsr305.param.nonnull.and.nullable.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PRIMITIVES_WITH_NULLNESS_ANNOTATION =
+            "jsr305.primitives.with.nullness.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_OVERRIDDEN_DEFINITIONS_WITH_INCREASED_PARAM_CONSTRAINT =
+            "jsr305.overridden.definitions.with.increased.param.constraint";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NONNULL_PARAM_ANNOTATION =
+            "jsr305.redundant.nonnull.param.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NULLABLE_PARAM_ANNOTATION =
+            "jsr305.redundant.nullable.param.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAMETER_WITHOUT_NULLNESS_ANNOTATION =
+            "jsr305.parameter.without.nullness.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_RETURN_VALUE_WITH_NONNULL_BY_DEFAULT_ANNOTATION =
+            "jsr305.return.value.with.nonnull.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_RETURN_VALUE_WITH_NULLABLE_ANNOTATION =
+            "jsr305.return.value.with.nullable.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_CONTRADICTING_RETURN_VALUE_ANNOTATIONS =
+            "jsr305.contradicting.return.value.annotations";
+
+    /** Key for error message. */
+    public static final String MSG_OVERRIDDEN_METHOD_WITH_CHECK_RETURN_VALUE_ANNOTATION =
+            "jsr305.overridden.method.with.check.return.value.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NONNULL_BY_DEFAULT_ANNOTATION =
+            "jsr305.redundant.nonnull.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NULLABLE_BY_DEFAULT_ANNOTATION =
+            "jsr305.redundant.nullable.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_VOID_WITH_CHECK_RETURN_VALUE_ANNOTATION =
+            "jsr305.void.with.check.return.value.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NONNULL_RETURN_ANNOTATION =
+            "jsr305.redundant.nonnull.return.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_RETURN_WITHOUT_NULLNESS_ANNOTATION =
+            "jsr305.return.without.nullness.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_OVERRIDDEN_METHODS_ALLOW_ONLY_NONNULL =
+            "jsr305.overridden.methods.allow.only.nonnull";
+
+    /** Key for error message. */
+    public static final String MSG_NEED_TO_INHERIT_PARAM_ANNOTATIONS =
+            "jsr305.need.to.inherit.param.annotations";
+
+    /** Key for error message. */
+    public static final String MSG_CONSTRUCTOR_WITH_RETURN_ANNOTATION =
+            "jsr305.constructor.with.return.annotation";
+
+    /** Package name. */
+    private static final String PKG_JAVAX_ANNOTATION = "javax.annotation";
+
+    /**
+     * Class NullnessAnnotation. The annotations we consider as "nullness-relevant".
+     */
+    protected enum NullnessAnnotation {
+
+        /** Override. */
+        OVERRIDE("Override", "java.lang"),
+        /** CheckForNull. */
+        CHECK_FOR_NULL("CheckForNull", PKG_JAVAX_ANNOTATION),
+        /** Nullable. */
+        NULLABLE("Nullable", PKG_JAVAX_ANNOTATION),
+        /** Nonnull. */
+        NONNULL("Nonnull", PKG_JAVAX_ANNOTATION),
+        /** CheckReturnValue. */
+        CHECK_RETURN_VALUE("CheckReturnValue", PKG_JAVAX_ANNOTATION),
+        /** ParametersAreNonnullByDefault. */
+        PARAMETERS_ARE_NONNULL_BY_DEFAULT("ParametersAreNonnullByDefault", PKG_JAVAX_ANNOTATION),
+        /** ParametersAreNullableByDefault. */
+        PARAMETERS_ARE_NULLABLE_BY_DEFAULT("ParametersAreNullableByDefault", PKG_JAVAX_ANNOTATION),
+        /** ReturnValuesAreNonnullByDefault. */
+        RETURN_VALUES_ARE_NONNULL_BY_DEFAULT("ReturnValuesAreNonnullByDefault",
+                "edu.umd.cs.findbugs.annotations");
+
+        /** The annotation's name. */
+        private final String theAnnotationName;
+
+        /** The annotation's fully qualified class name. */
+        private final String theFqcn;
+
+        /**
+         * Constructor.
+         * @param annotationName
+         *        the annotation's name
+         * @param packageName
+         *        the package name
+         */
+        NullnessAnnotation(final String annotationName, final String packageName) {
+            this.theAnnotationName = annotationName;
+            this.theFqcn = packageName + "." + annotationName;
+        }
+
+    }
+
+    /** The map of annotations against their respective names. */
+    private static final Map<String, NullnessAnnotation> STRING2ANNOTATION =
+            createString2AnnotationMap();
+
+    /** The modifiers of interest. */
+    private static final int[] DEFAULT_MODIFIERS = {
+        TokenTypes.PARAMETER_DEF,
+        TokenTypes.METHOD_DEF,
+        TokenTypes.PACKAGE_DEF,
+        TokenTypes.CTOR_DEF,
+        TokenTypes.CLASS_DEF,
+        TokenTypes.INTERFACE_DEF,
+        TokenTypes.ENUM_DEF,
+    };
+
+    /** Parameter: packages to check. */
+    private String[] packages = new String[0];
+    /** Parameter: packages to exclude from checking. */
+    private String[] excludePackages = new String[0];
+    /** Parameter: overriding return value annotations allowed. */
+    private boolean allowOverridingReturnValue;
+    /** Parameter: overriding parameter annotations allowed. */
+    private boolean allowOverridingParameter;
+
+    /** State, is a package excluded. */
+    private boolean packageExcluded;
+
+    /**
+     * Sets the included packages parameter.
+     * @param packageNames
+     *        the package names, comma separated
+     */
+    public void setPackages(final String[] packageNames) {
+        packages = transformToUnique(packageNames);
+    }
+
+    /**
+     * Maps annotations to their respective names.
+     * @return the map
+     */
+    private static Map<String, NullnessAnnotation> createString2AnnotationMap() {
+        final Map<String, NullnessAnnotation> result = new HashMap<String, NullnessAnnotation>();
+
+        for (final NullnessAnnotation annotation : NullnessAnnotation.values()) {
+            result.put(annotation.theAnnotationName, annotation);
+            result.put(annotation.theFqcn, annotation);
+        }
+
+        return Collections.unmodifiableMap(result);
+    }
+
+    /**
+     * Sets the excluded packages parameter.
+     * @param packageNames
+     *        the package names, comma separated
+     */
+    public void setExcludePackages(final String[] packageNames) {
+        excludePackages = transformToUnique(packageNames);
+    }
+
+    /**
+     * Gets the current value of the excluded packages parameter.
+     *
+     * @return the excluded packages
+     */
+    String[] getExcludePackages() {
+        return excludePackages;
+    }
+
+    /**
+     * Removes duplicates from an array of strings.
+     * @param input
+     *        the array
+     * @return a new, duplicate-free array
+     */
+    private static String[] transformToUnique(final String[] input) {
+        final Set<String> inputSet = new HashSet<String>(Arrays.asList(input));
+        return inputSet.toArray(new String[inputSet.size()]);
+    }
+
+    @Override
+    public final int[] getDefaultTokens() {
+        return DEFAULT_MODIFIERS.clone();
+    }
+
+    @Override
+    public final int[] getRequiredTokens() {
+        return new int[0];
+    }
+
+    @Override
+    public final int[] getAcceptableTokens() {
+        return DEFAULT_MODIFIERS.clone();
+    }
+
+    @Override
+    public final void visitToken(final DetailAST ast) {
+        if (ast.getType() == TokenTypes.PACKAGE_DEF) {
+            final DetailAST nameAST = ast.getLastChild().getPreviousSibling();
+            packageExcluded = isPackageExcluded(FullIdent.createFullIdent(nameAST));
+        }
+        else if (!packageExcluded) {
+            handleDefinition(ast);
+        }
+    }
+
+    /**
+     * Checks whether a package is excluded.
+     * @param fullIdent
+     *        the identifier
+     * @return true if yes
+     */
+    protected boolean isPackageExcluded(final FullIdent fullIdent) {
+        Boolean result = null;
+        if (fullIdent == null) {
+            result = true;
+        }
+        else {
+            final String packageName = fullIdent.getText();
+            for (final String excludesPackageName : excludePackages) {
+                if (packageName.startsWith(excludesPackageName)) {
+                    result = true;
+                    break;
+                }
+            }
+            if (result == null) {
+                for (final String includePackageName : packages) {
+                    if (packageName.startsWith(includePackageName)) {
+                        result = false;
+                        break;
+                    }
+                }
+            }
+        }
+        if (result == null) {
+            result = true;
+        }
+        return result;
+    }
+
+    /**
+     * Returns the check to use for a given definition.
+     * @param ast
+     *        the ast
+     * @return the check.
+     */
+    protected AbstractJsr305Check handleDefinition(final DetailAST ast) {
+
+        // no definition in catch clause
+        final DetailAST parent = ast.getParent();
+        final AbstractJsr305Check result;
+        if (parent != null && parent.getType() == TokenTypes.LITERAL_CATCH) {
+            result = null;
+        }
+        else {
+            // search modifiers
+            final int type = ast.getType();
+            switch (type) {
+                case TokenTypes.METHOD_DEF:
+                    result = new MethodJsr305Check(ast);
+                    break;
+                case TokenTypes.CTOR_DEF:
+                    result = new ConstructorJsr305Check(ast);
+                    break;
+                case TokenTypes.PARAMETER_DEF:
+                    result = new ParameterJsr305Check(ast);
+                    break;
+                case TokenTypes.CLASS_DEF:
+                case TokenTypes.INTERFACE_DEF:
+                case TokenTypes.ENUM_DEF:
+                    result = new ClassJsr305Check(ast);
+                    break;
+                default:
+                    throw new UnsupportedOperationException("no implementation for " + type);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Sets the parameter for allowing overriding return values.
+     * @param newAllowOverridingReturnValue
+     *        true if yes
+     */
+    public void setAllowOverridingReturnValue(final boolean newAllowOverridingReturnValue) {
+        this.allowOverridingReturnValue = newAllowOverridingReturnValue;
+    }
+
+    /**
+     * Sets the parameter for allowing overriding parameters.
+     * @param newAllowOverridingParameter
+     *        true if yes
+     */
+    public void setAllowOverridingParameter(final boolean newAllowOverridingParameter) {
+        this.allowOverridingParameter = newAllowOverridingParameter;
+    }
+
+    /**
+     * Class ClassJsr305Check. Checks a class.
+     */
+    private final class ClassJsr305Check extends AbstractJsr305Check {
+
+        /**
+         * Constructor.
+         * @param ast
+         *        the ast
+         */
+        ClassJsr305Check(final DetailAST ast) {
+            super(ast);
+        }
+
+        /**
+         * Run the actual check.
+         */
+        @Override
+        protected void runcheck() {
+            checkContainsAny(MSG_ILLEGAL_CLASS_LEVEL_ANNOTATION,
+                    NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.CHECK_RETURN_VALUE,
+                    NullnessAnnotation.NONNULL, NullnessAnnotation.NULLABLE);
+            checkContainsAll(MSG_CONTRADICTING_CLASS_LEVEL_ANNOTATIONS,
+                    NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT,
+                    NullnessAnnotation.PARAMETERS_ARE_NULLABLE_BY_DEFAULT);
+        }
+
+    }
+
+    /**
+     * Class ParameterJsr305Check. Checks a parameter.
+     */
+    private final class ParameterJsr305Check extends AbstractJsr305Check {
+
+        /**
+         * Constructor.
+         * @param ast
+         *        the ast
+         */
+        ParameterJsr305Check(final DetailAST ast) {
+            super(ast);
+        }
+
+        /**
+         * Run the actual check.
+         */
+        @Override
+        protected void runcheck() {
+            checkContainsAny(MSG_PARAM_DEFINITIONS_WITH_CHECK_ANNOTATION,
+                    NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.CHECK_RETURN_VALUE);
+            checkContainsAny(MSG_PARAM_DEFINITION_WITH_OVERRIDE_ANNOTATION,
+                    NullnessAnnotation.OVERRIDE);
+            checkContainsAny(MSG_PARAM_DEFINITION_WITH_NONNULL_BY_DEFAULT_ANNOTATION,
+                    NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT);
+            checkContainsAny(MSG_PARAM_DEFINITION_WITH_NULLABLE_BY_DEFAULT_ANNOTATION,
+                    NullnessAnnotation.PARAMETERS_ARE_NULLABLE_BY_DEFAULT);
+            checkContainsAny(MSG_PARAM_DEFINITION_WITH_RETURN_VALUES_DEFAULT_ANNOTATION,
+                    NullnessAnnotation.RETURN_VALUES_ARE_NONNULL_BY_DEFAULT);
+            checkContainsAll(MSG_PARAM_NONNULL_AND_NULLABLE_ANNOTATION,
+                    NullnessAnnotation.NONNULL, NullnessAnnotation.NULLABLE);
+
+            final NullnessAnnotation firstAncestorAnnotation = getParentMethodOrClassAnnotation(
+                    NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT,
+                    NullnessAnnotation.PARAMETERS_ARE_NULLABLE_BY_DEFAULT);
+            final boolean parametersAreNonnullByDefault =
+                    firstAncestorAnnotation == NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT;
+            final boolean parametersAreNullableByDefault = firstAncestorAnnotation
+                    == NullnessAnnotation.PARAMETERS_ARE_NULLABLE_BY_DEFAULT;
+            final boolean isMethodOverridden = isMethodOverridden();
+
+            if (isPrimitiveType()) {
+                checkContainsAny(MSG_PRIMITIVES_WITH_NULLNESS_ANNOTATION,
+                        NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.NONNULL,
+                        NullnessAnnotation.NULLABLE);
+            }
+            else {
+                if (isMethodOverridden && !allowOverridingParameter) {
+                    checkContainsAny(MSG_OVERRIDDEN_DEFINITIONS_WITH_INCREASED_PARAM_CONSTRAINT,
+                            NullnessAnnotation.NONNULL);
+                }
+                if (parametersAreNonnullByDefault) {
+                    checkContainsAny(MSG_REDUNDANT_NONNULL_PARAM_ANNOTATION,
+                            NullnessAnnotation.NONNULL);
+                }
+                if (parametersAreNullableByDefault) {
+                    checkContainsAny(MSG_REDUNDANT_NULLABLE_PARAM_ANNOTATION,
+                            NullnessAnnotation.NULLABLE);
+                }
+
+                if (!isMethodOverridden && !parametersAreNonnullByDefault
+                        && !parametersAreNullableByDefault) {
+                    checkContainsNone(MSG_PARAMETER_WITHOUT_NULLNESS_ANNOTATION,
+                            NullnessAnnotation.NONNULL, NullnessAnnotation.NULLABLE);
+                }
+            }
+        }
+    }
+
+    /**
+     * Class AbstractMethodJsr305Check. A check on a method or constructor (special case).
+     */
+    private abstract class AbstractMethodJsr305Check extends AbstractJsr305Check {
+
+        /**
+         * Constructor.
+         * @param ast
+         *        the ast
+         */
+        AbstractMethodJsr305Check(final DetailAST ast) {
+            super(ast);
+        }
+
+        /**
+         * Run the actual check.
+         */
+        @Override
+        protected final void runcheck() {
+            checkContainsAll(MSG_CONTRADICTING_CLASS_LEVEL_ANNOTATIONS,
+                    NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT,
+                    NullnessAnnotation.PARAMETERS_ARE_NULLABLE_BY_DEFAULT);
+            runReturnAnnotationCheck();
+        }
+
+        /**
+         * Run annotation check for return.
+         */
+        protected abstract void runReturnAnnotationCheck();
+
+    }
+
+    /**
+     * Class MethodJsr305Check. A check for a method.
+     */
+    private final class MethodJsr305Check extends AbstractMethodJsr305Check {
+
+        /**
+         * Constructor.
+         * @param ast
+         *        the ast
+         */
+        MethodJsr305Check(final DetailAST ast) {
+            super(ast);
+        }
+
+        /**
+         * Run annotation check for return.
+         */
+        @Override
+        protected void runReturnAnnotationCheck() {
+            checkContainsAny(MSG_RETURN_VALUE_WITH_NONNULL_BY_DEFAULT_ANNOTATION,
+                    NullnessAnnotation.RETURN_VALUES_ARE_NONNULL_BY_DEFAULT);
+            checkContainsAny(MSG_RETURN_VALUE_WITH_NULLABLE_ANNOTATION,
+                    NullnessAnnotation.NULLABLE);
+            checkContainsAll(MSG_CONTRADICTING_RETURN_VALUE_ANNOTATIONS, NullnessAnnotation.NONNULL,
+                    NullnessAnnotation.CHECK_FOR_NULL);
+            checkContainsAll(MSG_OVERRIDDEN_METHOD_WITH_CHECK_RETURN_VALUE_ANNOTATION,
+                    NullnessAnnotation.CHECK_RETURN_VALUE, NullnessAnnotation.OVERRIDE);
+            checkRedundancyDueToClassLevelAnnotation(MSG_REDUNDANT_NONNULL_BY_DEFAULT_ANNOTATION,
+                    NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT);
+            checkRedundancyDueToClassLevelAnnotation(MSG_REDUNDANT_NULLABLE_BY_DEFAULT_ANNOTATION,
+                    NullnessAnnotation.PARAMETERS_ARE_NULLABLE_BY_DEFAULT);
+
+            if (isVoid()) {
+                checkContainsAny(MSG_VOID_WITH_CHECK_RETURN_VALUE_ANNOTATION,
+                        NullnessAnnotation.CHECK_RETURN_VALUE);
+            }
+            if (isPrimitiveType()) {
+                checkContainsAny(MSG_PRIMITIVES_WITH_NULLNESS_ANNOTATION,
+                        NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.NONNULL,
+                        NullnessAnnotation.NULLABLE);
+            }
+            else {
+                final NullnessAnnotation annotation = getParentMethodOrClassAnnotation(
+                        NullnessAnnotation.RETURN_VALUES_ARE_NONNULL_BY_DEFAULT);
+                final boolean returnValuesAreNonnullByDefault = annotation
+                        == NullnessAnnotation.RETURN_VALUES_ARE_NONNULL_BY_DEFAULT;
+                final boolean isMethodOverridden = isMethodOverridden();
+
+                if (returnValuesAreNonnullByDefault) {
+                    if (!isMethodOverridden) {
+                        checkContainsAny(MSG_REDUNDANT_NONNULL_RETURN_ANNOTATION,
+                                NullnessAnnotation.NONNULL);
+                    }
+                }
+                else {
+                    checkContainsNone(MSG_RETURN_WITHOUT_NULLNESS_ANNOTATION,
+                            NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.NONNULL,
+                            NullnessAnnotation.OVERRIDE);
+                }
+
+                if (isMethodOverridden && !allowOverridingReturnValue) {
+                    checkContainsAny(MSG_OVERRIDDEN_METHODS_ALLOW_ONLY_NONNULL,
+                            NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.NULLABLE);
+                }
+
+                if (isMethodOverridden) {
+                    checkContainsAny(MSG_NEED_TO_INHERIT_PARAM_ANNOTATIONS,
+                            NullnessAnnotation.PARAMETERS_ARE_NONNULL_BY_DEFAULT);
+                }
+            }
+        }
+
+    }
+
+    /**
+     * Class ConstructorJsr305Check. Check a constructor.
+     */
+    private final class ConstructorJsr305Check extends AbstractMethodJsr305Check {
+
+        /**
+         * Constructor.
+         * @param ast
+         *        the ast
+         */
+        ConstructorJsr305Check(final DetailAST ast) {
+            super(ast);
+        }
+
+        /**
+         * Check for return type nullness annotations (which are illegal).
+         */
+        @Override
+        protected void runReturnAnnotationCheck() {
+            checkContainsAny(MSG_CONSTRUCTOR_WITH_RETURN_ANNOTATION,
+                    NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.CHECK_RETURN_VALUE,
+                    NullnessAnnotation.NONNULL, NullnessAnnotation.NULLABLE,
+                    NullnessAnnotation.OVERRIDE);
+        }
+
+    }
+
+    /**
+     * An abstract check, the base for checks on parameters, methods, classes. Class
+     * AbstractJsr305Check.
+     */
+    public abstract class AbstractJsr305Check {
+
+        /** Has an error been found. */
+        private boolean errorFound;
+        /** The found annotations. */
+        private final Set<NullnessAnnotation> theAnnotations;
+        /** The ast. */
+        private final DetailAST theAst;
+
+        /**
+         * Construtor.
+         * @param ast
+         *        the ast
+         */
+        AbstractJsr305Check(final DetailAST ast) {
+            errorFound = false;
+            theAst = ast;
+            if (ast == null) {
+                theAnnotations = Collections.emptySet();
+            }
+            else {
+                theAnnotations = findAnnotation();
+                runcheck();
+            }
+        }
+
+        /**
+         * Run the actual check.
+         */
+        protected abstract void runcheck();
+
+        /**
+         * Emits an error if any of the given annotations are found.
+         * @param msg
+         *        the error message to emit
+         * @param annotations
+         *        the annotations to look for
+         */
+        protected void checkContainsAny(final String msg, final NullnessAnnotation... annotations) {
+            if (!errorFound && containsAny(annotations)) {
+                error(msg);
+            }
+        }
+
+        /**
+         * Check whether any of the given annotations are found.
+         * @param annotations
+         *        the annotations to look for
+         * @return true if yes
+         */
+        protected boolean containsAny(final NullnessAnnotation... annotations) {
+            Boolean result = null;
+            if (theAnnotations.isEmpty()) {
+                result = false;
+            }
+            else {
+                for (final NullnessAnnotation obj : annotations) {
+                    if (theAnnotations.contains(obj)) {
+                        result = true;
+                        break;
+                    }
+                }
+            }
+            if (result == null) {
+                result = false;
+            }
+            return result;
+        }
+
+        /**
+         * Emits an error if all given annotations are found.
+         * @param msg
+         *        the error message to emit
+         * @param annotations
+         *        the annotations to look for
+         */
+        protected void checkContainsAll(final String msg, final NullnessAnnotation... annotations) {
+            if (!errorFound && containsAll(annotations)) {
+                error(msg);
+            }
+        }
+
+        /**
+         * Emits an error if both this and the parent class have redundant nullness annotations.
+         * @param msg
+         *        the error message to emit
+         * @param annotations
+         *        the annotations to look for
+         */
+        protected void checkRedundancyDueToClassLevelAnnotation(final String msg,
+                final NullnessAnnotation... annotations) {
+            if (!errorFound) {
+                for (final NullnessAnnotation nullnessAnnotation : annotations) {
+                    final boolean thisIsAnnotated = theAnnotations.contains(nullnessAnnotation);
+                    final boolean parentIsAnnotated =
+                            getParentMethodOrClassAnnotation(nullnessAnnotation) != null;
+                    if (thisIsAnnotated && parentIsAnnotated) {
+                        error(msg);
+                        break;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Check whether all the given annotations are present.
+         * @param annotations
+         *        the annotations to look for
+         * @return true if yes
+         */
+        protected boolean containsAll(final NullnessAnnotation... annotations) {
+            Boolean result = null;
+            if (theAnnotations.isEmpty()) {
+                result = annotations.length == 0;
+            }
+            else {
+                for (final NullnessAnnotation obj : annotations) {
+                    if (!theAnnotations.contains(obj)) {
+                        result = false;
+                        break;
+                    }
+                }
+            }
+            if (result == null) {
+                result = true;
+            }
+            return result;
+        }
+
+        /**
+         * Make sure that none of the given annotations are present.
+         * @param msg
+         *        the error message to emit if one of the given annotations was found
+         * @param annotations
+         *        the annotations to look for
+         */
+        protected void checkContainsNone(final String msg,
+                final NullnessAnnotation... annotations) {
+            if (!errorFound && !containsAny(annotations)) {
+                error(msg);
+            }
+        }
+
+        /**
+         * Returns the current error state.
+         *
+         * @return the current error state
+         */
+        protected boolean isErrorFound() {
+            return errorFound;
+        }
+
+        /**
+         * Logs an error.
+         *
+         * @param msg
+         *        the message
+         */
+        protected void reportError(final String msg) {
+            log(theAst, msg);
+        }
+
+        /**
+         * Handle an error (log and set 'errorFound' to 'true').
+         *
+         * @param msg
+         *        the error message
+         */
+        protected void error(final String msg) {
+            if (!errorFound) {
+                reportError(msg);
+            }
+            errorFound = true;
+        }
+
+        /**
+         * Is the current symbol a primitive type.
+         * @return true if yes
+         */
+        protected boolean isPrimitiveType() {
+            final DetailAST parameterType = theAst.findFirstToken(TokenTypes.TYPE);
+            final boolean result;
+            if (parameterType == null) {
+                result = false;
+            }
+            else {
+                final DetailAST identToken = parameterType.getFirstChild();
+
+                if (identToken == null) {
+                    result = false;
+                }
+                else {
+                    switch (identToken.getType()) {
+                        case TokenTypes.LITERAL_BOOLEAN:
+                        case TokenTypes.LITERAL_INT:
+                        case TokenTypes.LITERAL_LONG:
+                        case TokenTypes.LITERAL_SHORT:
+                        case TokenTypes.LITERAL_BYTE:
+                        case TokenTypes.LITERAL_CHAR:
+                        case TokenTypes.LITERAL_VOID:
+                        case TokenTypes.LITERAL_DOUBLE:
+                        case TokenTypes.LITERAL_FLOAT:
+                            result = !isArrayOrElipsis(parameterType);
+                            break;
+                        default:
+                            result = false;
+                    }
+                }
+            }
+            return result;
+        }
+
+        /**
+         * Checks whether token is array or elipsis.
+         * @param identToken
+         *        the token
+         * @return true if yes
+         */
+        protected boolean isArrayOrElipsis(final DetailAST identToken) {
+            final DetailAST next = identToken.getNextSibling();
+            final boolean result;
+            if (next == null) {
+                result = false;
+            }
+            else {
+                switch (next.getType()) {
+                    case TokenTypes.ARRAY_DECLARATOR:
+                    case TokenTypes.ELLIPSIS:
+                        result = true;
+                        break;
+                    default:
+                        result = false;
+                }
+            }
+            return result;
+        }
+
+        /**
+         * Is the current symbol of void type.
+         * @return true if yes
+         */
+        protected boolean isVoid() {
+            final DetailAST parameterType = theAst.findFirstToken(TokenTypes.TYPE);
+            final boolean result;
+            if (parameterType == null) {
+                result = false;
+            }
+            else {
+                final DetailAST identToken = parameterType.getFirstChild();
+                result = identToken != null && identToken.getType() == TokenTypes.LITERAL_VOID;
+            }
+            return result;
+        }
+
+        /**
+         * Find the nullness annotations.
+         * @return the annotations.
+         */
+        private Set<NullnessAnnotation> findAnnotation() {
+            return findAnnotations(theAst);
+        }
+
+        /**
+         * Find the nullness annotations.
+         * @param ast
+         *        the ast
+         * @return the annotations.
+         */
+        private Set<NullnessAnnotation> findAnnotations(final DetailAST ast) {
+            final Set<NullnessAnnotation> result = new HashSet<NullnessAnnotation>();
+
+            final DetailAST modifiers = ast.findFirstToken(TokenTypes.MODIFIERS);
+            if (modifiers != null) {
+                for (AST child = modifiers.getFirstChild(); child != null; child =
+                        child.getNextSibling()) {
+                    if (child.getType() == TokenTypes.ANNOTATION) {
+                        addNextNullnessAnnotation(result, (DetailAST) child);
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /**
+         * Adds the nullness annotation from the argument's first token if any.
+         * @param result
+         *        the result
+         * @param ast
+         *        the ast
+         */
+        protected void addNextNullnessAnnotation(final Set<NullnessAnnotation> result,
+                DetailAST ast) {
+            final DetailAST identifier = ast.findFirstToken(TokenTypes.IDENT);
+            if (identifier != null) {
+                final String annotationName = identifier.getText();
+                if (annotationName != null) {
+                    final NullnessAnnotation annotation =
+                            STRING2ANNOTATION.get(annotationName);
+                    if (annotation != null) {
+                        result.add(annotation);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Gets the nullness annotation for the parent method or class.
+         * @param annotationsToLookFor
+         *        the annotations to look for.
+         * @return the annotation or null if none was found
+         */
+        protected NullnessAnnotation
+                getParentMethodOrClassAnnotation(final NullnessAnnotation... annotationsToLookFor) {
+
+            boolean finished = false;
+            NullnessAnnotation result = null;
+            for (DetailAST current = theAst.getParent(); current != null && !finished; current =
+                    current.getParent()) {
+                final int tokenType = current.getType();
+
+                if (isPossibleTokenTypeForNullnessAnnotations(tokenType)) {
+                    final Set<NullnessAnnotation> foundAndLookedFor =
+                            collectLookedForAnnotations(current, annotationsToLookFor);
+                    if (foundAndLookedFor.size() == 1) {
+                        result = foundAndLookedFor.iterator().next();
+                        finished = true;
+                    }
+                    else if (foundAndLookedFor.size() > 0) {
+                        finished = true;
+                    }
+                }
+                // break on inner and anonymous classes/interfaces, we can't
+                // handle inheritance correctly
+                if (tokenType == TokenTypes.LITERAL_NEW || tokenType == TokenTypes.CLASS_DEF
+                        || tokenType == TokenTypes.INTERFACE_DEF
+                        || tokenType == TokenTypes.ENUM_DEF) {
+                    finished = true;
+                }
+            }
+            return result;
+        }
+
+        /**
+         * Is the current tokenType a possible type for nullness annotations.
+         * @param tokenType the token type
+         * @return true if yes
+         */
+        private boolean isPossibleTokenTypeForNullnessAnnotations(final int tokenType) {
+            return tokenType == TokenTypes.CLASS_DEF || tokenType == TokenTypes.INTERFACE_DEF
+                    || tokenType == TokenTypes.METHOD_DEF || tokenType == TokenTypes.CTOR_DEF
+                    || tokenType == TokenTypes.ENUM_DEF;
+        }
+
+        /**
+         * Extracts all given annotations from the current ast.
+         * @param current the current ast
+         * @param annotationsToLookFor the annotations we are looking for
+         * @return the annotations
+         */
+        protected Set<NullnessAnnotation> collectLookedForAnnotations(DetailAST current,
+                final NullnessAnnotation... annotationsToLookFor) {
+            final Set<NullnessAnnotation> foundAnnotations = findAnnotations(current);
+            final Set<NullnessAnnotation> foundAndLookedFor = new HashSet<>();
+            for (final NullnessAnnotation nullnessAnnotation : annotationsToLookFor) {
+                if (foundAnnotations.contains(nullnessAnnotation)) {
+                    foundAndLookedFor.add(nullnessAnnotation);
+                }
+            }
+            return foundAndLookedFor;
+        }
+
+        /**
+         * Is the current method overridden.
+         * @return true if yes
+         */
+        protected boolean isMethodOverridden() {
+            DetailAST current = theAst;
+            Boolean result = null;
+            for (; current != null && result == null; current = current.getParent()) {
+                switch (current.getType()) {
+                    case TokenTypes.METHOD_DEF:
+                        result = findAnnotations(current).contains(NullnessAnnotation.OVERRIDE);
+                        break;
+                    case TokenTypes.LAMBDA:
+                        result = true;
+                        break;
+                    default:
+                }
+            }
+            if (result == null) {
+                result = false;
+            }
+            return result;
+        }
+
+    }
+
+}
diff --git a/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/coding/messages.properties b/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/coding/messages.properties
index 04ee0a0026..97d740296f 100644
--- a/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/coding/messages.properties
+++ b/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/coding/messages.properties
@@ -59,3 +59,28 @@ useless.super.ctor.call.without.args= Redundant super constructor call could be
 return.null.Boolean=Method declares to return Boolean and returns null.
 return.boolean.ternary=Returning explicit boolean from ternary operator.
 whitespace.before.array.initializer=Array initializer should have whitespace before.
+jsr305.illegal.class.level.annotation=@CheckForNull, @Nullable, @Nonnull and @CheckReturnValue are not allowed on class level. Use @ParametersAreNonnullByDefault, @ParametersAreNullableByDefault and @ReturnValuesAreNonnullByDefault.
+jsr305.contradicting.class.level.annotations=@ParametersAreNullableByDefault and @ParametersAreNonnullByDefault are not allowed together!
+jsr305.param.definitions.with.check.annotation=Parameter definitions don't need checking, use @Nullable or @Nonnull.
+jsr305.param.definition.with.override.annotation=@Override is not allowed on parameter definition!
+jsr305.param.definition.with.nonnull.by.default.annotation=@ParametersAreNonnullByDefault is not allowed on parameter definition!
+jsr305.param.definition.with.nullable.by.default.annotation=@ParametersAreNullableByDefault is not allowed on parameter definition!
+jsr305.param.definition.with.return.values.default.annotation=@ReturnValuesAreNonnullByDefault is not allowed on parameter definition!
+jsr305.param.nonnull.and.nullable.annotation=@Nonnull and @Nullable are not allowed together!
+jsr305.primitives.with.nullness.annotation=Primitives must not have any nullness annotations!
+jsr305.overridden.definitions.with.increased.param.constraint=It is not allowed to increase nullness constraint for overriden method parameter definitions!
+jsr305.redundant.nonnull.param.annotation=It is not necessary to annotate @Nonnull if you annotated the method or class with @ParametersAreNonnullByDefault.
+jsr305.redundant.nullable.param.annotation=It is not necessary to annotate @Nullable if you annoted the method or class with @ParametersAreNullableByDefault.
+jsr305.parameter.without.nullness.annotation=No nullness Annotation for parameter definition found!
+jsr305.return.value.with.nonnull.by.default.annotation=@ReturnValuesAreNonnullByDefault is not allowed on method return values!
+jsr305.return.value.with.nullable.annotation=@Nullable is not allowed on method return values!
+jsr305.contradicting.return.value.annotations=@Nonnull and @CheckForNull are not allowed together!
+jsr305.overridden.method.with.check.return.value.annotation=@CheckReturnValue is not allowed on overriden methods, annotate the interface or superclass!
+jsr305.redundant.nonnull.by.default.annotation=Redundant @ParametersAreNonnullByDefault, the class is annotated with the same annotation!
+jsr305.redundant.nullable.by.default.annotation=Redundant @ParametersAreNullableByDefault, the class is annotated with the same annotation!
+jsr305.void.with.check.return.value.annotation=There is nothing to check on void return methods, remove @CheckReturnValue!
+jsr305.redundant.nonnull.return.annotation=It is not necessary to annotate @Nonnull if you annoted the class with @ReturnValuesAreNonnullByDefault.
+jsr305.return.without.nullness.annotation=Return value must have nullness Annotation (@Nonnull or @CheckForNull)!
+jsr305.overridden.methods.allow.only.nonnull=Overriden methods allow only @Nonnull.
+jsr305.need.to.inherit.param.annotations=You have to inherit parameter annotations!
+jsr305.constructor.with.return.annotation=Constructors have no return value and must not be annotated!
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheckTest.java
new file mode 100644
index 0000000000..422d0de1e9
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotationsCheckTest.java
@@ -0,0 +1,565 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.github.sevntu.checkstyle.checks.coding.Jsr305AnnotationsCheck.NullnessAnnotation;
+import com.github.sevntu.checkstyle.checks.coding.Jsr305AnnotionsTestUtil.ExpectedWarning;
+import com.github.sevntu.checkstyle.checks.coding.test.ArraysTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.ClassTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.ConstructorTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.DefaultReturnValuesTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.DefectConstructorTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.EnumTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.InheritanceTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.LambdaTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.ParameterTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.PrimitivesTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.RedundantClassLevelTestObject;
+import com.github.sevntu.checkstyle.checks.coding.test.ReturnValueTestObject;
+import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
+import com.puppycrawl.tools.checkstyle.api.DetailAST;
+import com.puppycrawl.tools.checkstyle.api.FullIdent;
+import com.puppycrawl.tools.checkstyle.api.TokenTypes;
+
+public class Jsr305AnnotationsCheckTest {
+
+    private static final String[] EXCLUDED_PACKAGES = new String[] {
+        "com.foo", "org.bar",
+    };
+
+    private static final String[] INCLUDED_PACKAGES = new String[] {
+        "com.baz", "org.hmpf",
+    };
+
+    // -------------- Function tests (execute check on test sources) --------------
+
+    @Test
+    public void testParameters() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(ParameterTestObject.class, 37, 44),
+                new ExpectedWarning(ParameterTestObject.class, 42, 45),
+                new ExpectedWarning(ParameterTestObject.class, 42, 64),
+                new ExpectedWarning(ParameterTestObject.class, 75, 41),
+                new ExpectedWarning(ParameterTestObject.class, 81, 27),
+                new ExpectedWarning(ParameterTestObject.class, 99, 35)
+        );
+    }
+
+    @Test
+    public void testPrimitives() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(PrimitivesTestObject.class, 29, 37),
+                new ExpectedWarning(PrimitivesTestObject.class, 34, 38),
+                new ExpectedWarning(PrimitivesTestObject.class, 39, 42),
+                new ExpectedWarning(PrimitivesTestObject.class, 44, 5),
+                new ExpectedWarning(PrimitivesTestObject.class, 50, 5),
+                new ExpectedWarning(PrimitivesTestObject.class, 56, 5),
+                new ExpectedWarning(PrimitivesTestObject.class, 62, 5),
+                new ExpectedWarning(PrimitivesTestObject.class, 69, 5),
+                new ExpectedWarning(PrimitivesTestObject.class, 116, 34)
+        );
+    }
+
+    @Test
+    public void testReturnValues() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(ReturnValueTestObject.class, 49, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 55, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 76, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 83, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 103, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 106, 26),
+                new ExpectedWarning(ReturnValueTestObject.class, 106, 48),
+                new ExpectedWarning(ReturnValueTestObject.class, 111, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 118, 5),
+                new ExpectedWarning(ReturnValueTestObject.class, 124, 5)
+        );
+    }
+
+    @Test
+    public void testConstructors() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(ConstructorTestObject.class, 38, 34),
+                new ExpectedWarning(ConstructorTestObject.class, 44, 34),
+                new ExpectedWarning(ConstructorTestObject.class, 58, 34),
+                new ExpectedWarning(ConstructorTestObject.class, 72, 54),
+                new ExpectedWarning(DefectConstructorTestObject.class)
+        );
+    }
+
+    @Test
+    public void testArrays() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(ArraysTestObject.class, 43, 22),
+                new ExpectedWarning(ArraysTestObject.class, 58, 22),
+                new ExpectedWarning(ArraysTestObject.class, 73, 22),
+                new ExpectedWarning(ArraysTestObject.class, 88, 22),
+                new ExpectedWarning(ArraysTestObject.class, 102, 8),
+                new ExpectedWarning(ArraysTestObject.class, 117, 32),
+                new ExpectedWarning(ArraysTestObject.class, 132, 34)
+        );
+    }
+
+    @Test
+    public void testClasses() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(ClassTestObject.class, 33, 5),
+                new ExpectedWarning(ClassTestObject.class, 47, 26),
+                new ExpectedWarning(ClassTestObject.class, 57, 29),
+                new ExpectedWarning(ClassTestObject.class, 79, 32),
+                new ExpectedWarning(ClassTestObject.class, 87, 36),
+                new ExpectedWarning(ClassTestObject.class, 141, 43),
+                new ExpectedWarning(ClassTestObject.class, 148, 9),
+                new ExpectedWarning(ClassTestObject.class, 152, 9),
+                new ExpectedWarning(ClassTestObject.class, 163, 9),
+                new ExpectedWarning(ClassTestObject.class, 169, 9),
+                new ExpectedWarning(ClassTestObject.class, 187, 9)
+        );
+    }
+
+    @Test
+    public void testEnums() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(EnumTestObject.class, 45, 32),
+                new ExpectedWarning(EnumTestObject.class, 54, 36),
+                new ExpectedWarning(EnumTestObject.class, 71, 9),
+                new ExpectedWarning(EnumTestObject.class, 77, 9),
+                new ExpectedWarning(EnumTestObject.class, 90, 5)
+        );
+    }
+
+    @Test
+    public void testInheritance() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(InheritanceTestObject.class, 44, 47),
+                new ExpectedWarning(InheritanceTestObject.class, 81, 43)
+        );
+    }
+
+    @Test
+    public void testReturnValueDefaults() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(DefaultReturnValuesTestObject.class, 37, 5)
+        );
+    }
+
+    @Test
+    public void testRedudantClassLevelAnnotations() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(RedundantClassLevelTestObject.class, 28, 5)
+        );
+    }
+
+    @Test
+    public void testLambdas() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(LambdaTestObject.class, 35, 10),
+                new ExpectedWarning(LambdaTestObject.class, 45, 5)
+        );
+    }
+
+    @Test
+    public void testAllowOverriding() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.checkAllowingOverriding(
+                new ExpectedWarning(ParameterTestObject.class, 37, 44),
+                new ExpectedWarning(ParameterTestObject.class, 42, 45),
+                new ExpectedWarning(ParameterTestObject.class, 42, 64),
+                new ExpectedWarning(ParameterTestObject.class, 75, 41),
+                new ExpectedWarning(ParameterTestObject.class, 99, 35),
+                new ExpectedWarning(LambdaTestObject.class, 45, 5),
+                new ExpectedWarning(InheritanceTestObject.class, 44, 47),
+                new ExpectedWarning(InheritanceTestObject.class, 81, 43)
+        );
+    }
+
+    // ------------------ Unit tests (test particular functions) ------------------
+
+    @Test
+    public void testExcludePackage() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.checkExcludingPackage(
+                new ExpectedWarning(ParameterTestObject.class)
+        );
+    }
+
+    @Test
+    public void testIsPackageExcluded() {
+        // final String[] excludedPackages = new String[] {
+        final AbstractCheckAdapter check1 = new AbstractCheckAdapter() {
+            @Override
+            public void check() {
+                Assert.assertTrue(isPackageExcluded(null));
+
+                final DetailAST ast = new DetailAST();
+                ast.setText(EXCLUDED_PACKAGES[1]);
+                final FullIdent fullIdent1 = FullIdent.createFullIdent(ast);
+                Assert.assertEquals(EXCLUDED_PACKAGES[1], fullIdent1.getText());
+                Assert.assertTrue(isPackageExcluded(fullIdent1));
+            }
+        };
+        check1.setPackages(INCLUDED_PACKAGES);
+        check1.setExcludePackages(EXCLUDED_PACKAGES);
+        check1.check();
+
+        final AbstractCheckAdapter check2 = new AbstractCheckAdapter() {
+            @Override
+            public void check() {
+                final DetailAST ast = new DetailAST();
+                ast.setText(INCLUDED_PACKAGES[0]);
+                final FullIdent fullIdent2 = FullIdent.createFullIdent(ast);
+                Assert.assertEquals(INCLUDED_PACKAGES[0], fullIdent2.getText());
+                Assert.assertFalse(isPackageExcluded(fullIdent2));
+
+                ast.setText("xxx");
+                final FullIdent fullIdent3 = FullIdent.createFullIdent(ast);
+                Assert.assertEquals("xxx", fullIdent3.getText());
+                Assert.assertTrue(isPackageExcluded(fullIdent3));
+            }
+        };
+        check2.setPackages(INCLUDED_PACKAGES);
+        check2.setExcludePackages(EXCLUDED_PACKAGES);
+        check2.check();
+    }
+
+    @Test
+    public void testHandleDefinition() {
+        // final String[] excludedPackages = new String[] {
+        final AbstractCheckAdapter check = new AbstractCheckAdapter() {
+            @Override
+            public void check() {
+                final DetailAST ast = new DetailAST();
+                final DetailAST parent = new DetailAST();
+                parent.setType(TokenTypes.LITERAL_CATCH);
+                parent.addChild(ast);
+                Assert.assertNull(handleDefinition(ast));
+
+                try {
+                    handleDefinition(parent);
+                    Assert.fail("UnsupportedOperationException expected.");
+                }
+                catch (final UnsupportedOperationException exc) {
+                    // OK
+                }
+            }
+        };
+        check.check();
+    }
+
+    @Test
+    public void testGetAcceptableTokens() {
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        Assert.assertEquals(7, check.getAcceptableTokens().length);
+    }
+
+    @Test
+    public void testSetExcludePackages() {
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        Assert.assertEquals(0, check.getExcludePackages().length);
+        check.setExcludePackages(EXCLUDED_PACKAGES);
+        Assert.assertTrue(Arrays.equals(check.getExcludePackages(), EXCLUDED_PACKAGES));
+    }
+
+    @Test
+    public void testAbstractJsr305CheckConstructor() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        check.new AbstractJsr305Check(null) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+            }
+        };
+        Assert.assertFalse(executed.get());
+    }
+
+    @Test
+    public void testMethodOverridden() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final AtomicBoolean overridden = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final DetailAST ast = new DetailAST();
+        ast.setType(TokenTypes.ARRAY_INIT);
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                overridden.set(isMethodOverridden());
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(overridden.get());
+    }
+
+    @Test
+    public void testAddNextNullnessAnnotation() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final Set<NullnessAnnotation> nullnessAnnotations = new HashSet<>();
+        final DetailAST ast = new DetailAST();
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                addNextNullnessAnnotation(nullnessAnnotations, ast);
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertTrue(nullnessAnnotations.isEmpty());
+
+        executed.set(false);
+
+        final DetailAST identAst = new DetailAST();
+        identAst.setType(TokenTypes.IDENT);
+        ast.addChild(identAst);
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                addNextNullnessAnnotation(nullnessAnnotations, ast);
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertTrue(nullnessAnnotations.isEmpty());
+    }
+
+    @Test
+    public void testIsVoid() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final AtomicBoolean isVoid = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final DetailAST ast = new DetailAST();
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                isVoid.set(isVoid());
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(isVoid.get());
+
+        executed.set(false);
+
+        final DetailAST typeAst = new DetailAST();
+        typeAst.setType(TokenTypes.TYPE);
+        ast.addChild(typeAst);
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                isVoid.set(isVoid());
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(isVoid.get());
+    }
+
+    @Test
+    public void testIsArrayOrEllipsis() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final AtomicBoolean arrayOrEllipsis = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final DetailAST ast = new DetailAST();
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                arrayOrEllipsis.set(isArrayOrElipsis(ast));
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(arrayOrEllipsis.get());
+    }
+
+    @Test
+    public void testIsPrimitiveType() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final AtomicBoolean primitiveType = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final DetailAST ast = new DetailAST();
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                primitiveType.set(isPrimitiveType());
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(primitiveType.get());
+
+        executed.set(false);
+
+        final DetailAST parameterType = new DetailAST();
+        parameterType.setType(TokenTypes.TYPE);
+        ast.addChild(parameterType);
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                primitiveType.set(isPrimitiveType());
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(primitiveType.get());
+    }
+
+    @Test
+    public void testError() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final DetailAST ast = new DetailAST();
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                Assert.assertFalse(isErrorFound());
+                error("foo");
+                Assert.assertTrue(isErrorFound());
+                error("foo");
+                Assert.assertTrue(isErrorFound());
+            }
+
+            @Override
+            protected void reportError(final String msg) {
+                // empty
+            }
+        };
+        Assert.assertTrue(executed.get());
+    }
+
+    @Test
+    public void testContainsAll() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final AtomicBoolean containsAll = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final DetailAST ast = new DetailAST();
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                containsAll.set(containsAll());
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertTrue(containsAll.get());
+
+        executed.set(false);
+
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                containsAll.set(containsAll(NullnessAnnotation.CHECK_FOR_NULL));
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(containsAll.get());
+    }
+
+    @Test
+    public void testCollectLookedForAnnotations() {
+        final AtomicBoolean executed = new AtomicBoolean(false);
+        final Jsr305AnnotationsCheck check = new Jsr305AnnotationsCheck();
+        final Set<NullnessAnnotation> nullnessAnnotations = new HashSet<>();
+        final DetailAST ast = createAstWithTwoAnnotations();
+        final NullnessAnnotation[] annotationsToLookFor1 = new NullnessAnnotation[] {
+            NullnessAnnotation.CHECK_FOR_NULL, NullnessAnnotation.NONNULL,
+        };
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                nullnessAnnotations.addAll(collectLookedForAnnotations(ast, annotationsToLookFor1));
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(nullnessAnnotations.isEmpty());
+        Assert.assertTrue(nullnessAnnotations.contains(NullnessAnnotation.CHECK_FOR_NULL));
+        Assert.assertFalse(nullnessAnnotations.contains(NullnessAnnotation.NONNULL));
+        Assert.assertFalse(nullnessAnnotations.contains(NullnessAnnotation.NULLABLE));
+
+        nullnessAnnotations.clear();
+        executed.set(false);
+
+        final NullnessAnnotation[] annotationsToLookFor2 = new NullnessAnnotation[] {
+            NullnessAnnotation.CHECK_FOR_NULL,
+        };
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                nullnessAnnotations.addAll(collectLookedForAnnotations(ast, annotationsToLookFor2));
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertFalse(nullnessAnnotations.isEmpty());
+        Assert.assertTrue(nullnessAnnotations.contains(NullnessAnnotation.CHECK_FOR_NULL));
+        Assert.assertFalse(nullnessAnnotations.contains(NullnessAnnotation.NONNULL));
+        Assert.assertFalse(nullnessAnnotations.contains(NullnessAnnotation.NULLABLE));
+
+        nullnessAnnotations.clear();
+        executed.set(false);
+
+        final NullnessAnnotation[] annotationsToLookFor3 = new NullnessAnnotation[0];
+        check.new AbstractJsr305Check(ast) {
+            @Override
+            protected void runcheck() {
+                executed.set(true);
+                nullnessAnnotations.addAll(collectLookedForAnnotations(ast, annotationsToLookFor3));
+            }
+        };
+        Assert.assertTrue(executed.get());
+        Assert.assertTrue(nullnessAnnotations.isEmpty());
+    }
+
+    private DetailAST createAstWithTwoAnnotations() {
+        final DetailAST ast = new DetailAST();
+        final DetailAST modifiersAst = new DetailAST();
+        modifiersAst.setType(TokenTypes.MODIFIERS);
+        ast.addChild(modifiersAst);
+        final DetailAST checkForNullAst = new DetailAST();
+        checkForNullAst.setType(TokenTypes.ANNOTATION);
+        final DetailAST checkForNullIdent = new DetailAST();
+        checkForNullIdent.setType(TokenTypes.IDENT);
+        checkForNullIdent.setText("CheckForNull");
+        checkForNullAst.addChild(checkForNullIdent);
+        modifiersAst.addChild(checkForNullAst);
+        final DetailAST nullableAst = new DetailAST();
+        nullableAst.setType(TokenTypes.ANNOTATION);
+        final DetailAST nullableIdent = new DetailAST();
+        nullableIdent.setType(TokenTypes.IDENT);
+        nullableIdent.setText("Nullable");
+        checkForNullAst.addChild(checkForNullIdent);
+        checkForNullAst.addNextSibling(nullableAst);
+        return ast;
+    }
+
+    private abstract static class AbstractCheckAdapter extends Jsr305AnnotationsCheck {
+        public abstract void check();
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotionsTestUtil.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotionsTestUtil.java
new file mode 100644
index 0000000000..f85ec94ee0
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/Jsr305AnnotionsTestUtil.java
@@ -0,0 +1,267 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding;
+
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.Assert;
+
+import com.puppycrawl.tools.checkstyle.Checker;
+import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
+import com.puppycrawl.tools.checkstyle.DefaultLogger;
+import com.puppycrawl.tools.checkstyle.api.AuditEvent;
+import com.puppycrawl.tools.checkstyle.api.AuditListener;
+import com.puppycrawl.tools.checkstyle.api.AutomaticBean;
+import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
+
+public final class Jsr305AnnotionsTestUtil {
+
+    private static final String MAVEN_TEST_CLASSES_PATH = "/target/test-classes";
+    private static final String TEST_OBJECT_PACKAGE =
+            "com.github.sevntu.checkstyle.checks.coding.test";
+
+    /**
+     * Private utility class constructor.
+     */
+    private Jsr305AnnotionsTestUtil() {
+        // empty
+    }
+
+    public static void checkAllowingOverriding(final ExpectedWarning... warnings)
+            throws CheckstyleException {
+        final Map<String, String> additionalAttributes = new HashMap<>();
+        additionalAttributes.put("allowOverridingReturnValue", "true");
+        additionalAttributes.put("allowOverridingParameter", "true");
+        final Checker checker = createChecker(additionalAttributes);
+        check(checker, warnings);
+    }
+
+    public static void checkExcludingPackage(final ExpectedWarning... warnings)
+            throws CheckstyleException {
+        final Map<String, String> additionalAttributes = new HashMap<>();
+        additionalAttributes.put("excludePackages", TEST_OBJECT_PACKAGE);
+        additionalAttributes.put("allowOverridingParameter", "true");
+        final Checker checker = createChecker(additionalAttributes);
+        check(checker, warnings);
+    }
+
+    public static void check(final ExpectedWarning... warnings) throws CheckstyleException {
+        final Checker checker = createChecker(Collections.emptyMap());
+        check(checker, warnings);
+    }
+
+    private static void check(final Checker checker, final ExpectedWarning... warnings)
+            throws CheckstyleException {
+
+        checker.addListener(new DefaultLogger(System.out, AutomaticBean.OutputStreamOptions.NONE));
+
+        final Map<String, List<ExpectedWarning>> fileNameWarningMap = new HashMap<>();
+        final List<File> files = new ArrayList<>();
+
+        final Map<Class<?>, List<ExpectedWarning>> mappedWarnings = new HashMap<>();
+        for (final ExpectedWarning warning : warnings) {
+            final List<ExpectedWarning> existing = mappedWarnings.get(warning.clz);
+            final List<ExpectedWarning> warningsInMap;
+            if (existing != null) {
+                warningsInMap = existing;
+            }
+            else {
+                final File file = getFileFromClass(warning.clz);
+                files.add(file);
+                warningsInMap = new ArrayList<>();
+                mappedWarnings.put(warning.clz, warningsInMap);
+                fileNameWarningMap.put(file.getPath(), warningsInMap);
+            }
+            if (!warning.isNoWarning()) {
+                warningsInMap.add(warning);
+            }
+        }
+
+        checker.addListener(new AuditListenerImplementation(fileNameWarningMap));
+        checker.process(files);
+    }
+
+    private static File getFileFromClass(final Class<?> clz) {
+        try {
+            final String clzFilename = clz.getSimpleName() + ".class";
+            final URL url = clz.getResource(clzFilename);
+            final String filename = url.toString();
+
+            final String path = filename.replace(resolveName(clz, ".class"), "");
+            final int lastSlash = path.lastIndexOf("/", path.length() - 1);
+            final String lsPath = path.substring(0, lastSlash);
+            final String buildPath;
+            if (lsPath.endsWith(MAVEN_TEST_CLASSES_PATH)) {
+                buildPath = lsPath.substring(0, lsPath.length() - MAVEN_TEST_CLASSES_PATH.length());
+            }
+            else {
+                buildPath = lsPath;
+            }
+
+            final String newPath = buildPath + "/src/test/java/" + resolveName(clz, ".java");
+            return new File(new URI(newPath));
+        }
+        catch (final URISyntaxException exc) {
+            throw new RuntimeException(exc);
+        }
+    }
+
+    private static String resolveName(final Class<?> clz, final String extension) {
+        Class<?> clazz = clz;
+        while (clazz.isArray()) {
+            clazz = clazz.getComponentType();
+        }
+        final String baseName = clazz.getName();
+        final int index = baseName.lastIndexOf('.');
+
+        final String name = clazz.getSimpleName() + extension;
+        final String result;
+        if (index != -1) {
+            result = baseName.substring(0, index).replace('.', '/') + "/" + name;
+        }
+        else {
+            result = name;
+        }
+        return result;
+    }
+
+    private static Checker createChecker(final Map<String, String> additionalAttributes)
+            throws CheckstyleException {
+        final Checker checker = new Checker();
+        checker.setModuleClassLoader(Checker.class.getClassLoader());
+        checker.configure(createCheckerConfiguration(additionalAttributes));
+        return checker;
+    }
+
+    private static DefaultConfiguration
+            createCheckerConfiguration(final Map<String, String> additionalAttributes) {
+        final DefaultConfiguration checkerConfiguration = new DefaultConfiguration("Checker");
+        checkerConfiguration.addChild(createTreeWalkerConfiguration(additionalAttributes));
+        return checkerConfiguration;
+    }
+
+    private static DefaultConfiguration
+            createTreeWalkerConfiguration(final Map<String, String> additionalAttributes) {
+        final DefaultConfiguration treeWalkerConfiguration = new DefaultConfiguration("TreeWalker");
+        treeWalkerConfiguration
+                .addChild(createJsr305AnnotationsConfiguration(additionalAttributes));
+        return treeWalkerConfiguration;
+    }
+
+    private static DefaultConfiguration
+            createJsr305AnnotationsConfiguration(final Map<String, String> additionalAttributes) {
+        final DefaultConfiguration jsr305AnnotaionsConfiguration =
+                new DefaultConfiguration("Jsr305AnnotationsCheck");
+        jsr305AnnotaionsConfiguration.addAttribute("packages", TEST_OBJECT_PACKAGE);
+        for (Entry<String, String> entry : additionalAttributes.entrySet()) {
+            jsr305AnnotaionsConfiguration.addAttribute(entry.getKey(), entry.getValue());
+        }
+        return jsr305AnnotaionsConfiguration;
+    }
+
+    public static final class ExpectedWarning {
+
+        private final int column;
+        private final int line;
+        private final Class<?> clz;
+
+        ExpectedWarning(final Class<?> clz, final int line, final int column) {
+            this.clz = clz;
+            this.line = line;
+            this.column = column;
+        }
+
+        ExpectedWarning(final Class<?> clz) {
+            this(clz, -1, -1);
+        }
+
+        public boolean isNoWarning() {
+            return column < 0 || line < 0;
+        }
+
+        @Override
+        public String toString() {
+            return clz.getSimpleName() + " (" + line + ":" + column + ")";
+        }
+    }
+
+    private static final class AuditListenerImplementation implements AuditListener {
+
+        private final Map<String, List<ExpectedWarning>> fileNameWarningMap;
+        private Iterator<ExpectedWarning> warningIterator;
+
+        AuditListenerImplementation(final Map<String, List<ExpectedWarning>> fileNameWarningMap) {
+            this.fileNameWarningMap = fileNameWarningMap;
+        }
+
+        @Override
+        public void fileStarted(final AuditEvent event) {
+            final List<ExpectedWarning> list = fileNameWarningMap.remove(event.getFileName());
+            warningIterator = list.iterator();
+        }
+
+        @Override
+        public void fileFinished(final AuditEvent event) {
+            // can't use Assert.assertFalse because next can not be evaluated
+            if (warningIterator.hasNext()) {
+                Assert.fail("There is a warnings left: " + warningIterator.next());
+            }
+        }
+
+        @Override
+        public void auditStarted(final AuditEvent event) {
+        }
+
+        @Override
+        public void auditFinished(final AuditEvent event) {
+            Assert.assertTrue("There are Files left: " + fileNameWarningMap.keySet(),
+                    fileNameWarningMap.isEmpty());
+        }
+
+        @Override
+        public void addException(final AuditEvent event, final Throwable throwable) {
+            Assert.fail("Exception during check of file " + event.getFileName() + ": "
+                    + throwable.getMessage());
+        }
+
+        @Override
+        public void addError(final AuditEvent event) {
+            Assert.assertTrue("There should be an expeceted warning for file \""
+                    + event.getFileName() + "\", but none found", warningIterator.hasNext());
+            final ExpectedWarning warning = warningIterator.next();
+            final String error = "Position (" + event.getLine() + ":" + event.getColumn()
+                    + ") didn't match: " + warning;
+            Assert.assertEquals(error, warning.line, event.getLine());
+            Assert.assertEquals(error, warning.column, event.getColumn());
+        }
+
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ArraysTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ArraysTestObject.java
new file mode 100644
index 0000000000..c123c0a3ca
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ArraysTestObject.java
@@ -0,0 +1,140 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import java.io.Serializable;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class ArraysTestObject {
+
+    private final Object obj;
+
+    // ok
+    ArraysTestObject(@Nonnull final int[] nonnull) {
+        obj = nonnull;
+    }
+
+    // ok
+    ArraysTestObject(@Nullable final long[] nullable) {
+        obj = nullable;
+    }
+
+    // error
+    ArraysTestObject(final short[] array) {
+        obj = array;
+    }
+
+    // ok
+    ArraysTestObject(@Nonnull final byte... varargs) {
+        obj = varargs;
+    }
+
+    // ok
+    ArraysTestObject(@Nullable final float... varargs) {
+        obj = varargs;
+    }
+
+    // error
+    ArraysTestObject(final double... varargs) {
+        obj = varargs;
+    }
+
+    // ok
+    ArraysTestObject(@Nonnull final String... varargs) {
+        obj = varargs;
+    }
+
+    // ok
+    ArraysTestObject(@Nullable final Object... varargs) {
+        obj = varargs;
+    }
+
+    // error
+    ArraysTestObject(final Serializable... varargs) {
+        obj = varargs;
+    }
+
+    // ok
+    ArraysTestObject(@Nonnull final Class<?>[] clazz) {
+        obj = clazz;
+    }
+
+    // ok
+    ArraysTestObject(@Nullable final Iterable<?>[] iterable) {
+        obj = iterable;
+    }
+
+    // error
+    ArraysTestObject(final Comparable<?> comparable) {
+        obj = comparable;
+    }
+
+    @Nonnull
+    int[] retNonnul() {
+        return new int[] {};
+    }
+
+    @CheckForNull
+    int[] retCheckForNull() {
+        return null;
+    }
+
+    int[] retNoAnnotation() {
+        return new int[] {};
+    }
+
+    // ok
+    void testNonnullArray(@Nonnull final int[] array) {
+        array[1] = 0;
+    }
+
+    // ok
+    void testNullableArray(@Nullable final int[] array) {
+        array[1] = 0;
+    }
+
+    // error
+    void testNoAnnotationArray(final int[] array) {
+        array[1] = 0;
+    }
+
+    // ok
+    void testNonnullVarargs(@Nonnull final int... varargs) {
+        varargs[1] = 0;
+    }
+
+    // ok
+    void testNullableVarargs(@Nullable final int... varargs) {
+        varargs[1] = 0;
+    }
+
+    // error
+    void testNoAnnotationVarargs(final int... varargs) {
+        varargs[1] = 0;
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(obj);
+    }
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ClassTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ClassTestObject.java
new file mode 100644
index 0000000000..bbca82106d
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ClassTestObject.java
@@ -0,0 +1,195 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+import edu.umd.cs.findbugs.annotations.ReturnValuesAreNonnullByDefault;
+
+public class ClassTestObject {
+
+    // error, double annotation
+    @ParametersAreNonnullByDefault
+    @ParametersAreNullableByDefault
+    class BothParameterAnnotationsClass {
+
+    }
+
+    // no error
+    @ParametersAreNullableByDefault
+    interface ParameterAnnotationsInterface {
+
+        // no error
+        void setUnannotated(String unannotated);
+
+        // error, redundant
+        void setNullable(@Nullable String nullable);
+
+        // no error
+        void setNonnull(@Nonnull String nonnull);
+
+    }
+
+    interface NoParameterAnnotationsInterface {
+
+        // error, missing
+        void setUnannotated(String unannotated);
+
+        // no error
+        void setNullable(@Nonnull String nullable);
+
+        // no error
+        void setNonnull(@Nullable String nonnull);
+
+    }
+
+    @ParametersAreNonnullByDefault
+    class ParameterAnnotationsClass {
+
+        // no error
+        public void setUnannotated(final String unannotated) {
+        }
+
+        // no error
+        public void setNullable(@Nullable final String nullable) {
+        }
+
+        // error, redundant
+        public void setNonnull(@Nonnull final String nonnull) {
+        }
+
+    }
+
+    class NoParameterAnnotationsClass {
+
+        // error, missing
+        public void setUnannotated(final String unannotated) {
+        }
+
+        // no error
+        public void setNullable(@Nullable final String nullable) {
+        }
+
+        // no error
+        public void setNonnull(@Nonnull final String nonnull) {
+        }
+
+    }
+
+    @ParametersAreNonnullByDefault
+    static class DefaultNullableParameterInheritingClass implements ParameterAnnotationsInterface {
+
+        @Override
+        // no error
+        public void setUnannotated(final String unannotated) {
+        }
+
+        @Override
+        // no error
+        public void setNullable(final String nullable) {
+        }
+
+        @Override
+        // no error
+        public void setNonnull(final String nonnull) {
+        }
+
+        // no error
+        public void setAnotherUnannotated(final String unannotated) {
+        }
+    }
+
+    static class NullableParameterInheritingClass implements ParameterAnnotationsInterface {
+
+        @Override
+        // no error
+        public void setUnannotated(final String unannotated) {
+        }
+
+        @Override
+        // no error
+        public void setNullable(final String nullable) {
+        }
+
+        @Override
+        // no error
+        public void setNonnull(final String nonnull) {
+        }
+
+        // error
+        public void setAnotherUnannotated(final String unannotated) {
+        }
+    }
+
+    @ReturnValuesAreNonnullByDefault
+    interface ReturnValueAnnotationInterface {
+        // error, redundant
+        @Nonnull
+        String getNonnull();
+
+        // error, disallowed
+        @ReturnValuesAreNonnullByDefault
+        String getNonnullByDefault();
+
+        // no error
+        @CheckForNull
+        String getCheckForNull();
+    }
+
+    @ReturnValuesAreNonnullByDefault
+    static class ReturnValueAnnotationClass {
+        // error, redundant
+        @Nonnull
+        public String getNonnull() {
+            return "";
+        }
+
+        // error, disallowed
+        @ReturnValuesAreNonnullByDefault
+        public String getNonnullByDefault() {
+            return "";
+        }
+
+        // no error
+        @CheckForNull
+        public String getCheckForNull() {
+            return "";
+        }
+    }
+
+    interface NoReturnValueAnnotationInterface {
+        // no error
+        @Nonnull
+        String getNonnull();
+
+        // error, disallowed
+        @ReturnValuesAreNonnullByDefault
+        String getNonnullByDefault();
+
+        // no error
+        @CheckForNull
+        String getCheckForNull();
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ConstructorTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ConstructorTestObject.java
new file mode 100644
index 0000000000..78412eb81d
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ConstructorTestObject.java
@@ -0,0 +1,107 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+public class ConstructorTestObject {
+
+    @Nonnull
+    private final Object nonnull;
+
+    @Nullable
+    private final Object nullable;
+
+    // error
+    public ConstructorTestObject(@Nonnull @Nullable final Enum<?> value) {
+        nullable = value;
+        nonnull = new Object();
+    }
+
+    // error
+    public ConstructorTestObject(final Class<?> clz) {
+        nonnull = new Object();
+        nullable = clz;
+    }
+
+    // ok
+    @ParametersAreNonnullByDefault
+    public ConstructorTestObject(final String string1, @Nullable final String string2) {
+        nonnull = string1;
+        nullable = string2;
+    }
+
+    // error
+    @ParametersAreNonnullByDefault
+    public ConstructorTestObject(@Nonnull final String string1, final Integer string2) {
+        nonnull = string1;
+        nullable = string2;
+    }
+
+    // ok
+    @ParametersAreNullableByDefault
+    public ConstructorTestObject(@Nonnull final Integer int1, final Integer int2) {
+        nonnull = int1;
+        nullable = int2;
+    }
+
+    // error
+    @ParametersAreNullableByDefault
+    public ConstructorTestObject(final Integer int1, @Nullable final String int2) {
+        if (int1 != null) {
+            nonnull = int1;
+        }
+        else {
+            nonnull = Integer.valueOf(1);
+        }
+        nullable = int2;
+    }
+
+    // ok
+    public ConstructorTestObject(@Nullable final String obj) {
+        nonnull = new Object();
+        nullable = obj;
+    }
+
+    // ok
+    public ConstructorTestObject(@Nonnull final Integer obj) {
+        nonnull = obj;
+        nullable = null;
+    }
+
+    // ok
+    @CheckForNull
+    public Object getNullable() {
+        return nullable;
+    }
+
+    // ok
+    @CheckReturnValue
+    @Nonnull
+    public Object getNonnull() {
+        return nonnull;
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefaultReturnValuesTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefaultReturnValuesTestObject.java
new file mode 100644
index 0000000000..f0133e9cc8
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefaultReturnValuesTestObject.java
@@ -0,0 +1,42 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.Nonnull;
+
+import edu.umd.cs.findbugs.annotations.ReturnValuesAreNonnullByDefault;
+
+@ReturnValuesAreNonnullByDefault
+public class DefaultReturnValuesTestObject {
+
+    // ok
+    @Override
+    @Nonnull
+    public String toString() {
+        return super.toString();
+    }
+
+    // error
+    @Nonnull
+    public Object bar() {
+        return new Object();
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefectConstructorTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefectConstructorTestObject.java
new file mode 100644
index 0000000000..0486aa438d
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/DefectConstructorTestObject.java
@@ -0,0 +1,37 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.Nonnull;
+
+public class DefectConstructorTestObject {
+
+    private final String theString;
+
+    public DefectConstructorTestObject(@Nonnull final String string) {
+        this.theString = string;
+    }
+
+    @Override
+    public String toString() {
+        return theString;
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/EnumTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/EnumTestObject.java
new file mode 100644
index 0000000000..38e37d7d80
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/EnumTestObject.java
@@ -0,0 +1,96 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+import edu.umd.cs.findbugs.annotations.ReturnValuesAreNonnullByDefault;
+
+public class EnumTestObject {
+
+    @ParametersAreNonnullByDefault
+    enum ParameterAnnotationsEnum {
+        TEST;
+
+        // no error
+        public void setUnannotated(final String foo) {
+        }
+
+        // no error
+        public void setNullable(@Nullable final String foo) {
+        }
+
+        // error, redundant
+        public void setNonnull(@Nonnull final String foo) {
+        }
+
+    }
+
+    enum NoParameterAnnotationsEnum {
+        TEST;
+
+        // error, missing
+        public void setUnannotated(final String foo) {
+        }
+
+        // no error
+        public void setNullable(@Nullable final String foo) {
+        }
+
+        // no error
+        public void setNonnull(@Nonnull final String foo) {
+        }
+
+    }
+
+    @ReturnValuesAreNonnullByDefault
+    enum ReturnValueAnnotationEnum {
+        TEST;
+        // error, redundant
+        @Nonnull
+        public String getNonnull() {
+            return "";
+        }
+
+        // error, disallowed
+        @ReturnValuesAreNonnullByDefault
+        public String getNonnnullByDefault() {
+            return "";
+        }
+
+        // no error
+        @CheckForNull
+        public String getCheckForNull() {
+            return "";
+        }
+    }
+
+    // error
+    @ParametersAreNonnullByDefault
+    @ParametersAreNullableByDefault
+    enum BothAnnotations {
+        TEST;
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/InheritanceTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/InheritanceTestObject.java
new file mode 100644
index 0000000000..5e1a8b0dcd
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/InheritanceTestObject.java
@@ -0,0 +1,117 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+@ParametersAreNullableByDefault
+public class InheritanceTestObject {
+
+    // anonymous classes can't be annotated, but this should inherit the
+    // annotations from the superclass
+    public void testAnonClasses() {
+        final Inherited anonymousClassInstance = new Inherited() {
+
+            @Override
+            public void getUnannotated(final String unannotated) {
+            }
+
+            @Override
+            public void getNullable(final String nullable) {
+            }
+
+            // error
+            public void getAnotherUnannotated(final String getAnotherUnannotated) {
+            }
+
+            @Override
+            public Object nonnull() {
+                return "";
+            }
+        };
+    }
+
+    @ParametersAreNonnullByDefault
+    interface Inherited {
+
+        // no error
+        void getUnannotated(String unannotated);
+
+        // no error
+        void getNullable(@Nullable String nullable);
+
+        @Nonnull
+        Object nonnull();
+    }
+
+    // no error
+    static class UnannotatedInheritor implements Inherited {
+
+        // no error, since we're overriding @NonnullByDefault from the interface
+        @Override
+        public void getUnannotated(@Nullable final String unannotated) {
+        }
+
+        // no error
+        @Override
+        public void getNullable(final String nullable) {
+        }
+
+        // error
+        public void getAnotherUnannotated(final String unannotated) {
+        }
+
+        @Override
+        public Object nonnull() {
+            return "";
+        }
+
+    }
+
+    // no error
+    @ParametersAreNullableByDefault
+    static class AnnotatedInheritor implements Inherited {
+
+        // this should not be an error, we are inheriting via the @Override
+        // annotation
+        @Override
+        public void getUnannotated(final String unannotated) {
+        }
+
+        // no error
+        @Override
+        public void getNullable(final String nullable) {
+        }
+
+        // no error
+        public void getAnotherUnannotated(final String unannotated) {
+        }
+
+        @Override
+        @Nonnull
+        public Object nonnull() {
+            return "";
+        }
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/LambdaTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/LambdaTestObject.java
new file mode 100644
index 0000000000..632d6e03bd
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/LambdaTestObject.java
@@ -0,0 +1,49 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
+
+import javax.annotation.Nonnull;
+
+public final class LambdaTestObject {
+
+    // ok
+    public static final Function<Object, String> TO_STRING =
+        object -> object.toString();
+
+    // error
+    public static final ToIntFunction<Object> HASH_CODE =
+        (@Nonnull Object object) -> object.hashCode();
+
+    /**
+     * Private util class constructor.
+     */
+    private LambdaTestObject() {
+        // empty
+    }
+
+    // error
+    public String error() {
+        return "";
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ParameterTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ParameterTestObject.java
new file mode 100644
index 0000000000..d45b7357e5
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ParameterTestObject.java
@@ -0,0 +1,112 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class ParameterTestObject
+        implements Comparable<ParameterTestObject>, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    // error
+    @Nonnull
+    public String missingNullnessParameter(final Object obj) {
+        return obj.toString();
+    }
+
+    // 2x error
+    public boolean missingNullnessParameter(final Object obj1, final Object obj2) {
+        return obj1.equals(obj2);
+    }
+
+    // ok
+    @Nonnull
+    public String nonnullParameter(@Nonnull final Object obj) {
+        return obj.toString();
+    }
+
+    // ok
+    public boolean nonnullParameter(@Nonnull final Object obj1,
+            @Nonnull final Object obj2) {
+        return obj1.equals(obj2);
+    }
+
+    // ok
+    @Nonnull
+    public String nullableParameter(@Nullable final Object obj) {
+        return String.valueOf(obj);
+    }
+
+    // ok
+    public boolean nullableParameter(@Nullable final Object obj1,
+            @Nullable final Object obj2) {
+        if (obj1 != null) {
+            System.out.println("bonk");
+        }
+        return obj2 == null;
+    }
+
+    // error
+    @Nonnull
+    public String checkForNullParameter(@CheckForNull final Object obj) {
+        return String.valueOf(obj);
+    }
+
+    // error
+    @Override
+    public boolean equals(@Nonnull final Object obj) {
+        return super.equals(obj);
+    }
+
+    // ok
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    // ok
+    @Override
+    public int compareTo(@Nullable final ParameterTestObject obj) {
+        return 0;
+    }
+
+    // error
+    @Nonnull
+    public String nonnullNullable(@Nonnull @Nullable final Object obj) {
+        return String.valueOf(obj);
+    }
+
+    // ok
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public List<String> typeCast() {
+        final Object list = new ArrayList<>();
+        final List<String> result = (List<String>) list;
+        return result;
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/PrimitivesTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/PrimitivesTestObject.java
new file mode 100644
index 0000000000..f6e611be14
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/PrimitivesTestObject.java
@@ -0,0 +1,120 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class PrimitivesTestObject {
+
+    // error
+    public boolean nonnullParameter(@Nonnull final int param) {
+        return param == 0;
+    }
+
+    // error
+    public boolean nullableParameter(@Nullable final int param) {
+        return param == 0;
+    }
+
+    // error
+    public boolean checkForNullParameter(@CheckForNull final int param) {
+        return param == 0;
+    }
+
+    // error
+    @Nonnull
+    public int returnNonnull() {
+        return 0;
+    }
+
+    // error
+    @CheckForNull
+    public int returnCheckForNull() {
+        return 0;
+    }
+
+    // error
+    @Nullable
+    public int returnNullable() {
+        return 0;
+    }
+
+    // error
+    @Override
+    @Nonnull
+    public boolean equals(Object object) {
+        return super.equals(object);
+    }
+
+    // error
+    @Override
+    @Nonnull
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    // ok
+    public int primitivesInt(final int primitive) {
+        return primitive + 1;
+    }
+
+    // ok
+    public byte primitivesByte(final byte primitive) {
+        return primitive;
+    }
+
+    // ok
+    public boolean primitivesBoolean(final boolean primitive) {
+        return !primitive;
+    }
+
+    // ok
+    public float primitivesFloat(final float primitive) {
+        return primitive + 1.0F;
+    }
+
+    // ok
+    public double primitivesDouble(final double primitive) {
+        return primitive + 1.0D;
+    }
+
+    // ok
+    public long primitivesLong(final long primitive) {
+        return primitive + 1L;
+    }
+
+    // ok
+    public short primitivesShort(final short primitive) {
+        return primitive;
+    }
+
+    // ok
+    public char primitivesChar(final char primitive) {
+        return primitive;
+    }
+
+    // error
+    public int primitivesNonnull(@Nonnull final int primitive) {
+        return primitive + 1;
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/RedundantClassLevelTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/RedundantClassLevelTestObject.java
new file mode 100644
index 0000000000..bfac5f22d3
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/RedundantClassLevelTestObject.java
@@ -0,0 +1,38 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+@ParametersAreNullableByDefault
+public class RedundantClassLevelTestObject {
+
+    @ParametersAreNullableByDefault
+    public void redundant1() {
+    }
+
+    public void redundant2() {
+    }
+
+    @ParametersAreNonnullByDefault
+    public void redundant3() {
+    }
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ReturnValueTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ReturnValueTestObject.java
new file mode 100644
index 0000000000..fb6b43b293
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/test/ReturnValueTestObject.java
@@ -0,0 +1,129 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2019 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.github.sevntu.checkstyle.checks.coding.test;
+
+import java.io.Serializable;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+public class ReturnValueTestObject
+        implements Comparable<ReturnValueTestObject>, Serializable, Runnable {
+
+    private static final long serialVersionUID = 1L;
+
+    // ok
+    @Nonnull
+    Object returnNonnull() {
+        return new Object();
+    }
+
+    // ok
+    @CheckForNull
+    Object returnCheckForNull() {
+        return null;
+    }
+
+    // error
+    @Nullable
+    Object returnNullable() {
+        return null;
+    }
+
+    // error
+    @Nonnull
+    @CheckForNull
+    Object returnNonnullCheckForNull() {
+        return new Object();
+    }
+
+    // ok
+    @CheckReturnValue
+    @CheckForNull
+    Object returnCheckReturnValueCheckForNull() {
+        return new Object();
+    }
+
+    // ok
+    @CheckReturnValue
+    @Nonnull
+    Object returnCheckReturnValueNonnull() {
+        return new Object();
+    }
+
+    // error
+    @Override
+    @Nonnull
+    public boolean equals(final Object obj) {
+        return super.equals(obj);
+    }
+
+    // error
+    @Override
+    @CheckForNull
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    // ok
+    @Override
+    public void run() {
+        hashCode();
+    }
+
+    // ok
+    @Override
+    @Nonnull
+    public String toString() {
+        return super.toString();
+    }
+
+    // error + 2x parameter error
+    @ParametersAreNonnullByDefault
+    @ParametersAreNullableByDefault
+    @Nonnull
+    public String concat(final String string1, final String string2) {
+        return string1 + string2;
+    }
+
+    // error
+    @Override
+    @CheckReturnValue
+    public int compareTo(@Nullable final ReturnValueTestObject obj) {
+        return 0;
+    }
+
+    // error
+    @CheckReturnValue
+    public void voidNoCheckReturnValue() {
+        hashCode();
+    }
+
+    // error
+    @Nonnull
+    public void voidNoNonnull() {
+        hashCode();
+    }
+
+}
diff --git a/sevntu-checkstyle-maven-plugin/src/main/resources/checkstyle_packages.xml b/sevntu-checkstyle-maven-plugin/src/main/resources/checkstyle_packages.xml
index 649dabc258..86130ae36a 100644
--- a/sevntu-checkstyle-maven-plugin/src/main/resources/checkstyle_packages.xml
+++ b/sevntu-checkstyle-maven-plugin/src/main/resources/checkstyle_packages.xml
@@ -34,4 +34,4 @@
     <package name="filters"/>
   </package>
 
-</checkstyle-packages>
\ No newline at end of file
+</checkstyle-packages>
diff --git a/sevntu-checkstyle-sonar-plugin/src/main/resources/com/github/sevntu/checkstyle/sonar/checkstyle-extensions.xml b/sevntu-checkstyle-sonar-plugin/src/main/resources/com/github/sevntu/checkstyle/sonar/checkstyle-extensions.xml
index 083323a6c7..0b8b6e4ad4 100644
--- a/sevntu-checkstyle-sonar-plugin/src/main/resources/com/github/sevntu/checkstyle/sonar/checkstyle-extensions.xml
+++ b/sevntu-checkstyle-sonar-plugin/src/main/resources/com/github/sevntu/checkstyle/sonar/checkstyle-extensions.xml
@@ -921,6 +921,31 @@
     <configKey>Checker/TreeWalker/com.github.sevntu.checkstyle.checks.coding.RequireFailForTryCatchInJunitCheck</configKey>
   </rule>
 
+  <rule>
+    <key>com.github.sevntu.checkstyle.checks.coding.Jsr305AnnotationsCheck</key>
+    <name>Line Length Extended</name>
+    <category name="coding"/>
+    <description>Checks for long lines.</description>
+    <configKey>Checker/TreeWalker/com.github.sevntu.checkstyle.checks.coding.Jsr305AnnotationsCheck</configKey>
+
+    <param key="packages" type="STRING">
+      <defaultValue></defaultValue>
+      <description>Packages to be checked.</description>
+    </param>
+    <param key="excludePackages" type="STRING">
+      <defaultValue></defaultValue>
+      <description>Packages excluded from checking.</description>
+    </param>
+    <param key="allowOverridingReturnValue" type="BOOLEAN">
+      <defaultValue>false</defaultValue>
+      <description>Allow Overriding return values, useful for upgrading.</description>
+    </param>
+    <param key="allowOverridingParameter" type="BOOLEAN">
+      <defaultValue>false</defaultValue>
+      <description>Allow Overriding paramaters, useful for upgrading.</description>
+    </param>
+  </rule>
+
   <rule>
     <key>com.github.sevntu.checkstyle.checks.design.CheckstyleTestMakeupCheck</key>
     <name>Custom check to ensure Checkstyle tests are designed correctly.</name>