diff --git a/eclipsecs-sevntu-plugin/src/checkstyle_packages.xml b/eclipsecs-sevntu-plugin/src/checkstyle_packages.xml
index 548ff7ec08..e0dcf7c99d 100644
--- a/eclipsecs-sevntu-plugin/src/checkstyle_packages.xml
+++ b/eclipsecs-sevntu-plugin/src/checkstyle_packages.xml
@@ -15,6 +15,7 @@
       <package name="annotation"/>
       <package name="coding"/>
       <package name="design"/>
+      <package name="jsr305"/>
       <package name="naming"/>
       <package name="sizes"/>
     </package>
diff --git a/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/jsr305/checkstyle-metadata.properties b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/jsr305/checkstyle-metadata.properties
new file mode 100755
index 0000000000..ed52855a1f
--- /dev/null
+++ b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/jsr305/checkstyle-metadata.properties
@@ -0,0 +1,6 @@
+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/jsr305/checkstyle-metadata.xml b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/jsr305/checkstyle-metadata.xml
new file mode 100644
index 0000000000..b8687b4ff6
--- /dev/null
+++ b/eclipsecs-sevntu-plugin/src/com/github/sevntu/checkstyle/checks/jsr305/checkstyle-metadata.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE checkstyle-metadata PUBLIC
+"-//eclipse-cs//DTD Check Metadata 1.1//EN"
+"http://checkstyle.org/eclipse-cs/dtds/checkstyle-metadata_1_1.dtd">
+<checkstyle-metadata>
+    <rule-group-metadata name="SevNTU checks" priority="1450">
+
+        <rule-metadata name="%Jsr305AnnotationsCheck.name" internal-name="Jsr305AnnotationsCheck" parent="TreeWalker">
+            <alternative-name internal-name="com.github.sevntu.checkstyle.checks.jsr305.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="illegal.class.level.annotation" />
+            <message-key key="contradicting.class.level.annotations" />
+            <message-key key="param.definitions.with.check.annotation" />
+            <message-key key="param.definition.with.override.annotation" />
+            <message-key key="param.definition.with.nonnull.by.default.annotation" />
+            <message-key key="param.definition.with.nullable.by.default.annotation" />
+            <message-key key="param.definition.with.return.values.default.annotation" />
+            <message-key key="param.nonnull.and.nullable.annotation" />
+            <message-key key="primitives.with.nullness.annotation" />
+            <message-key key="overridden.definitions.with.increased.param.constraint" />
+            <message-key key="redundant.nonnull.param.annotation" />
+            <message-key key="redundant.nullable.param.annotation" />
+            <message-key key="parameter.without.nullness.annotation" />
+            <message-key key="return.value.with.nonnull.by.default.annotation" />
+            <message-key key="return.value.with.nullable.annotation" />
+            <message-key key="contradicting.return.value.annotations" />
+            <message-key key="overridden.method.with.check.return.value.annotation" />
+            <message-key key="redundant.nonnull.by.default.annotation" />
+            <message-key key="redundant.nullable.by.default.annotation" />
+            <message-key key="void.with.check.return.value.annotation" />
+            <message-key key="redundant.nonnull.return.annotation" />
+            <message-key key="return.without.nullness.annotation" />
+            <message-key key="overridden.methods.allow.only.nonnull" />
+            <message-key key="need.to.inherit.param.annotations" />
+            <message-key key="constructor.with.return.annotation" />
+       </rule-metadata>
+
+    </rule-group-metadata>
+</checkstyle-metadata>
diff --git a/sevntu-checks/pom.xml b/sevntu-checks/pom.xml
index 971587eadc..0629f68a1e 100644
--- a/sevntu-checks/pom.xml
+++ b/sevntu-checks/pom.xml
@@ -42,6 +42,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>
diff --git a/sevntu-checks/sevntu-checks.xml b/sevntu-checks/sevntu-checks.xml
index d4c7612e18..f327bee93b 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.jsr305.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/jsr305/Jsr305AnnotationsCheck.java b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotationsCheck.java
new file mode 100644
index 0000000000..38ce9eaaba
--- /dev/null
+++ b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotationsCheck.java
@@ -0,0 +1,990 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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.jsr305;
+
+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;
+
+/**
+ * JSR305CheckstylePlugin - a checkstyle plugin 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>
+ */
+public class Jsr305AnnotationsCheck extends AbstractCheck {
+
+    /** Key for error message. */
+    public static final String MSG_ILLEGAL_CLASS_LEVEL_ANNOTATION =
+            "illegal.class.level.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_CONTRADICTING_CLASS_LEVEL_ANNOTATIONS =
+            "contradicting.class.level.annotations";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITIONS_WITH_CHECK_ANNOTATION =
+            "param.definitions.with.check.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_OVERRIDE_ANNOTATION =
+            "param.definition.with.override.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_NONNULL_BY_DEFAULT_ANNOTATION =
+            "param.definition.with.nonnull.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_NULLABLE_BY_DEFAULT_ANNOTATION =
+            "param.definition.with.nullable.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_DEFINITION_WITH_RETURN_VALUES_DEFAULT_ANNOTATION =
+            "param.definition.with.return.values.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAM_NONNULL_AND_NULLABLE_ANNOTATION =
+            "param.nonnull.and.nullable.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PRIMITIVES_WITH_NULLNESS_ANNOTATION =
+            "primitives.with.nullness.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_OVERRIDDEN_DEFINITIONS_WITH_INCREASED_PARAM_CONSTRAINT =
+            "overridden.definitions.with.increased.param.constraint";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NONNULL_PARAM_ANNOTATION =
+            "redundant.nonnull.param.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NULLABLE_PARAM_ANNOTATION =
+            "redundant.nullable.param.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_PARAMETER_WITHOUT_NULLNESS_ANNOTATION =
+            "parameter.without.nullness.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_RETURN_VALUE_WITH_NONNULL_BY_DEFAULT_ANNOTATION =
+            "return.value.with.nonnull.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_RETURN_VALUE_WITH_NULLABLE_ANNOTATION =
+            "return.value.with.nullable.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_CONTRADICTING_RETURN_VALUE_ANNOTATIONS =
+            "contradicting.return.value.annotations";
+
+    /** Key for error message. */
+    public static final String MSG_OVERRIDDEN_METHOD_WITH_CHECK_RETURN_VALUE_ANNOTATION =
+            "overridden.method.with.check.return.value.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NONNULL_BY_DEFAULT_ANNOTATION =
+            "redundant.nonnull.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NULLABLE_BY_DEFAULT_ANNOTATION =
+            "redundant.nullable.by.default.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_VOID_WITH_CHECK_RETURN_VALUE_ANNOTATION =
+            "void.with.check.return.value.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_REDUNDANT_NONNULL_RETURN_ANNOTATION =
+            "redundant.nonnull.return.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_RETURN_WITHOUT_NULLNESS_ANNOTATION =
+            "return.without.nullness.annotation";
+
+    /** Key for error message. */
+    public static final String MSG_OVERRIDDEN_METHODS_ALLOW_ONLY_NONNULL =
+            "overridden.methods.allow.only.nonnull";
+
+    /** Key for error message. */
+    public static final String MSG_NEED_TO_INHERIT_PARAM_ANNOTATIONS =
+            "need.to.inherit.param.annotations";
+
+    /** Key for error message. */
+    public static final String MSG_CONSTRUCTOR_WITH_RETURN_ANNOTATION =
+            "constructor.with.return.annotation";
+
+    /** Package name. */
+    private static final String PKG_JAVAX_ANNOTATION = "javax.annotation";
+
+    /**
+     * Class NullnessAnnotation. The annotations we consider as "nullness-relevant".
+     */
+    private 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);
+    }
+
+    /**
+     * 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
+     */
+    private boolean isPackageExcluded(final FullIdent fullIdent) {
+        Boolean result = null;
+        if (fullIdent == null) {
+            result = true;
+        }
+        else {
+            final String packageName = fullIdent.getText();
+            if (packageName == null) {
+                result = true;
+            }
+            else {
+                for (final String excludesPackageName : excludePackages) {
+                    if (packageName.startsWith(excludesPackageName)) {
+                        result = true;
+                    }
+                }
+                if (result == null) {
+                    for (final String includePackageName : packages) {
+                        if (packageName.startsWith(includePackageName)) {
+                            result = false;
+                        }
+                    }
+                }
+            }
+        }
+        if (result == null) {
+            result = true;
+        }
+        return result;
+    }
+
+    /**
+     * Returns the check to use for a given definition.
+     * @param ast
+     *        the ast
+     * @return the check.
+     */
+    private 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);
+            }
+        }
+
+        /**
+         * Handle an error (log and set 'errorFound' to 'true').
+         * @param msg
+         *        the error message
+         */
+        private void error(final String msg) {
+            if (!errorFound) {
+                log(theAst, 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
+         */
+        private 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) {
+                        continue;
+                    }
+                    final DetailAST identifier =
+                            ((DetailAST) child).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)) {
+                                error("Double Annotation (" + annotation.theAnnotationName
+                                        + ") found!");
+                            }
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /**
+         * 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
+         */
+        private 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/java/com/github/sevntu/checkstyle/checks/jsr305/package-info.java b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/jsr305/package-info.java
new file mode 100644
index 0000000000..8d108a3ae0
--- /dev/null
+++ b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/jsr305/package-info.java
@@ -0,0 +1,24 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Contains the <span class="xdocspagetitle">Jsr305</span> checks that
+ * are bundled with the main distribution.
+ */
+package com.github.sevntu.checkstyle.checks.jsr305;
diff --git a/sevntu-checks/src/main/resources/checkstyle_packages.xml b/sevntu-checks/src/main/resources/checkstyle_packages.xml
index 0551de71df..f36530676d 100644
--- a/sevntu-checks/src/main/resources/checkstyle_packages.xml
+++ b/sevntu-checks/src/main/resources/checkstyle_packages.xml
@@ -10,6 +10,7 @@
       <package name="annotation"/>
       <package name="coding"/>
       <package name="design"/>
+      <package name="jsr305"/>
       <package name="naming"/>
       <package name="sizes"/>
     </package>
diff --git a/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/jsr305/messages.properties b/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/jsr305/messages.properties
new file mode 100644
index 0000000000..c3b4c6b8c9
--- /dev/null
+++ b/sevntu-checks/src/main/resources/com/github/sevntu/checkstyle/checks/jsr305/messages.properties
@@ -0,0 +1,25 @@
+illegal.class.level.annotation=@CheckForNull, @Nullable, @Nonnull and @CheckReturnValue are not allowed on class level. Use @ParametersAreNonnullByDefault, @ParametersAreNullableByDefault and @ReturnValuesAreNonnullByDefault.
+contradicting.class.level.annotations=@ParametersAreNullableByDefault and @ParametersAreNonnullByDefault are not allowed together!
+param.definitions.with.check.annotation=Parameter definitions don't need checking, use @Nullable or @Nonnull.
+param.definition.with.override.annotation=@Override is not allowed on parameter definition!
+param.definition.with.nonnull.by.default.annotation=@ParametersAreNonnullByDefault is not allowed on parameter definition!
+param.definition.with.nullable.by.default.annotation=@ParametersAreNullableByDefault is not allowed on parameter definition!
+param.definition.with.return.values.default.annotation=@ReturnValuesAreNonnullByDefault is not allowed on parameter definition!
+param.nonnull.and.nullable.annotation=@Nonnull and @Nullable are not allowed together!
+primitives.with.nullness.annotation=Primitives must not have any nullness annotations!
+overridden.definitions.with.increased.param.constraint=It is not allowed to increase nullness constraint for overriden method parameter definitions!
+redundant.nonnull.param.annotation=It is not necessary to annotate @Nonnull if you annotated the method or class with @ParametersAreNonnullByDefault.
+redundant.nullable.param.annotation=It is not necessary to annotate @Nullable if you annoted the method or class with @ParametersAreNullableByDefault.
+parameter.without.nullness.annotation=No nullness Annotation for parameter definition found!
+return.value.with.nonnull.by.default.annotation=@ReturnValuesAreNonnullByDefault is not allowed on method return values!
+return.value.with.nullable.annotation=@Nullable is not allowed on method return values!
+contradicting.return.value.annotations=@Nonnull and @CheckForNull are not allowed together!
+overridden.method.with.check.return.value.annotation=@CheckReturnValue is not allowed on overriden methods, annotate the interface or superclass!
+redundant.nonnull.by.default.annotation=Redundant @ParametersAreNonnullByDefault, the class is annotated with the same annotation!
+redundant.nullable.by.default.annotation=Redundant @ParametersAreNullableByDefault, the class is annotated with the same annotation!
+void.with.check.return.value.annotation=There is nothing to check on void return methods, remove @CheckReturnValue!
+redundant.nonnull.return.annotation=It is not necessary to annotate @Nonnull if you annoted the class with @ReturnValuesAreNonnullByDefault.
+return.without.nullness.annotation=Return value must have nullness Annotation (@Nonnull or @CheckForNull)!
+overridden.methods.allow.only.nonnull=Overriden methods allow only @Nonnull.
+need.to.inherit.param.annotations=You have to inherit parameter annotations!
+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/jsr305/Jsr305AnnotationsCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotationsCheckTest.java
new file mode 100644
index 0000000000..78dd07fcfe
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotationsCheckTest.java
@@ -0,0 +1,83 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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.jsr305;
+
+import org.junit.Test;
+
+import com.github.sevntu.checkstyle.checks.jsr305.Jsr305AnnotionsTestUtil.ExpectedWarning;
+import com.github.sevntu.checkstyle.checks.jsr305.test.ClassTestObject;
+import com.github.sevntu.checkstyle.checks.jsr305.test.DefaultParameterTestObject;
+import com.github.sevntu.checkstyle.checks.jsr305.test.EnumTestObject;
+import com.github.sevntu.checkstyle.checks.jsr305.test.InheritanceTestObject;
+import com.github.sevntu.checkstyle.checks.jsr305.test.LambdaTestObject;
+import com.github.sevntu.checkstyle.checks.jsr305.test.ParameterTestObject;
+import com.github.sevntu.checkstyle.checks.jsr305.test.PrimitivesTestObject;
+import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
+
+public class Jsr305AnnotationsCheckTest {
+
+    @Test
+    public void test() throws CheckstyleException {
+        Jsr305AnnotionsTestUtil.check(
+                new ExpectedWarning(ParameterTestObject.class, 35, 44),
+                new ExpectedWarning(ParameterTestObject.class, 40, 45),
+                new ExpectedWarning(ParameterTestObject.class, 40, 64),
+                new ExpectedWarning(ParameterTestObject.class, 73, 41),
+                new ExpectedWarning(ParameterTestObject.class, 79, 27),
+                new ExpectedWarning(ParameterTestObject.class, 97, 35),
+
+                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),
+
+                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),
+
+                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),
+
+                new ExpectedWarning(InheritanceTestObject.class, 47, 47),
+                new ExpectedWarning(InheritanceTestObject.class, 76, 43),
+
+                new ExpectedWarning(DefaultParameterTestObject.class, 37, 5),
+
+                new ExpectedWarning(LambdaTestObject.class, 35, 10)
+
+        );
+    }
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotionsTestUtil.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotionsTestUtil.java
new file mode 100644
index 0000000000..47fc205f09
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/Jsr305AnnotionsTestUtil.java
@@ -0,0 +1,232 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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.jsr305;
+
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+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.CheckstyleException;
+
+public final class Jsr305AnnotionsTestUtil {
+
+    private static final String MAVEN_TEST_CLASSES_PATH = "/target/test-classes";
+
+    /**
+     * Private utility class constructor.
+     */
+    private Jsr305AnnotionsTestUtil() {
+        // empty
+    }
+
+    public static void check(final ExpectedWarning... warnings) throws CheckstyleException {
+        final Checker checker = createChecker();
+
+        checker.addListener(new DefaultLogger(System.out, false));
+
+        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() throws CheckstyleException {
+        final Checker checker = new Checker();
+        checker.setModuleClassLoader(Checker.class.getClassLoader());
+        checker.configure(createCheckerConfiguration());
+        return checker;
+    }
+
+    private static DefaultConfiguration createCheckerConfiguration() {
+        final DefaultConfiguration checkerConfiguration = new DefaultConfiguration("Checker");
+        checkerConfiguration.addChild(createTreeWalkerConfiguration());
+        return checkerConfiguration;
+    }
+
+    private static DefaultConfiguration createTreeWalkerConfiguration() {
+        final DefaultConfiguration treeWalkerConfiguration = new DefaultConfiguration("TreeWalker");
+        treeWalkerConfiguration.addChild(createJsr305AnnotationsConfiguration());
+        return treeWalkerConfiguration;
+    }
+
+    private static DefaultConfiguration createJsr305AnnotationsConfiguration() {
+        final DefaultConfiguration jsr305AnnotaionsConfiguration =
+                new DefaultConfiguration("Jsr305AnnotationsCheck");
+        jsr305AnnotaionsConfiguration.addAttribute("packages",
+                "com.github.sevntu.checkstyle.checks.jsr305.test");
+        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/jsr305/test/ArraysTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ArraysTestObject.java
new file mode 100644
index 0000000000..e1f89719d0
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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/jsr305/test/ClassTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ClassTestObject.java
new file mode 100644
index 0000000000..46307680d6
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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/jsr305/test/ConstructorTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ConstructorTestObject.java
new file mode 100644
index 0000000000..a3e85d1151
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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/jsr305/test/DefaultParameterTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/DefaultParameterTestObject.java
new file mode 100644
index 0000000000..e2fc54268f
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/DefaultParameterTestObject.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.jsr305.test;
+
+import javax.annotation.Nonnull;
+
+import edu.umd.cs.findbugs.annotations.ReturnValuesAreNonnullByDefault;
+
+@ReturnValuesAreNonnullByDefault
+public class DefaultParameterTestObject {
+
+    // 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/jsr305/test/DefectConstructorTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/DefectConstructorTestObject.java
new file mode 100644
index 0000000000..73fe34461b
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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/jsr305/test/EnumTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/EnumTestObject.java
new file mode 100644
index 0000000000..5c7b419c53
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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/jsr305/test/InheritanceTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/InheritanceTestObject.java
new file mode 100644
index 0000000000..627e9a4f97
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/InheritanceTestObject.java
@@ -0,0 +1,102 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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.jsr305.test;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+import javax.annotation.ParametersAreNullableByDefault;
+
+import com.github.sevntu.checkstyle.checks.jsr305.test.InheritanceTestObject.Inherited;
+
+@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() {
+
+            // no error
+            @Override
+            public void getUnannotated(final String unannotated) {
+            }
+
+            // no error
+            @Override
+            public void getNullable(final String nullable) {
+            }
+
+            // error
+            public void getAnotherUnannotated(final String getAnotherUnannotated) {
+            }
+        };
+    }
+
+    @ParametersAreNonnullByDefault
+    interface Inherited {
+
+        // no error
+        void getUnannotated(String unannotated);
+
+        // no error
+        void getNullable(@Nullable String nullable);
+    }
+
+    // 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) {
+        }
+
+    }
+
+    // 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) {
+        }
+
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/LambdaTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/LambdaTestObject.java
new file mode 100644
index 0000000000..a419955681
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/LambdaTestObject.java
@@ -0,0 +1,44 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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.jsr305.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
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ParameterTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ParameterTestObject.java
new file mode 100644
index 0000000000..1ede9f47ab
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ParameterTestObject.java
@@ -0,0 +1,101 @@
+////////////////////////////////////////////////////////////////////////////////
+// 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.jsr305.test;
+
+import java.io.Serializable;
+
+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);
+    }
+
+}
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/PrimitivesTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/PrimitivesTestObject.java
new file mode 100644
index 0000000000..14ea0899e8
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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/jsr305/test/ReturnValueTestObject.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/test/ReturnValueTestObject.java
new file mode 100644
index 0000000000..2d34ce5e99
--- /dev/null
+++ b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/jsr305/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.jsr305.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..e2ceab6aa2 100644
--- a/sevntu-checkstyle-maven-plugin/src/main/resources/checkstyle_packages.xml
+++ b/sevntu-checkstyle-maven-plugin/src/main/resources/checkstyle_packages.xml
@@ -8,6 +8,7 @@
       <package name="annotation"/>
       <package name="coding"/>
       <package name="design"/>
+      <package name="jsr305"/>
       <package name="naming"/>
       <package name="sizes"/>
       <package name="whitespace"/>
@@ -25,6 +26,7 @@
       <package name="indentation"/>
       <package name="j2ee"/>
       <package name="javadoc"/>
+      <package name="jsr305"/>
       <package name="metrics"/>
       <package name="modifier"/>
       <package name="naming"/>
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..8afeaa27a3 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
@@ -1,4 +1,30 @@
 <rules>
+  <!-- 'jsr305' checks -->
+  <rule>
+    <key>com.github.sevntu.checkstyle.checks.jsr305.Jsr305AnnotationsCheck</key>
+    <name>Line Length Extended</name>
+    <category name="jsr305"/>
+    <description>Checks for long lines.</description>
+    <configKey>Checker/TreeWalker/com.github.sevntu.checkstyle.checks.jsr305.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>
+
   <!-- 'sizes' checks -->
   <rule>
     <key>com.github.sevntu.checkstyle.checks.sizes.LineLengthExtendedCheck</key>