diff --git a/docs/pages/release_notes.md b/docs/pages/release_notes.md
index ed2ec7999b..99c45731f2 100644
--- a/docs/pages/release_notes.md
+++ b/docs/pages/release_notes.md
@@ -43,6 +43,8 @@ This is useful to find duplicated sections in XML files.
     *   [#2472](https://github.com/pmd/pmd/issues/2472): \[java] JavaCharStream throws an Error on invalid escape
 *   java-bestpractices
     *   [#2288](https://github.com/pmd/pmd/issues/2288): \[java] JUnitTestsShouldIncludeAssert: Add support for Hamcrest MatcherAssert.assertThat
+*   java-codestyle
+    *   [#2476](https://github.com/pmd/pmd/pull/2476): \[java] MethodNamingConventions - Add support for JUnit 5 method naming
 *   java-errorprone
     *   [#2477](https://github.com/pmd/pmd/issues/2477): \[java] JUnitSpelling false-positive for JUnit5/4 tests
 *   swift
@@ -75,6 +77,7 @@ definitive API.
 *   [#2465](https://github.com/pmd/pmd/pull/2465): \[dependencies] Upgrade hamcrest, mockito and JUnit - [Artem Krosheninnikov](https://github.com/KroArtem)
 *   [#2469](https://github.com/pmd/pmd/pull/2469): \[apex] fix false positive unused variable if only a method is called - [Gwilym Kuiper](https://github.com/gwilymatgearset)
 *   [#2475](https://github.com/pmd/pmd/pull/2475): \[swift] Swift 4.2-5.2 support - [kenji21](https://github.com/kenji21)
+*   [#2476](https://github.com/pmd/pmd/pull/2476): \[java] MethodNamingConventions - Add support for JUnit 5 method naming - [Bruno Ritz](https://github.com/birdflier)
 *   [#2478](https://github.com/pmd/pmd/pull/2478): \[java] New rule: LiteralsFirstInComparisons - [John-Teng](https://github.com/John-Teng)
 *   [#2479](https://github.com/pmd/pmd/pull/2479): \[java] False positive with Hamcrest's assertThat - [andreoss](https://github.com/andreoss)
 *   [#2481](https://github.com/pmd/pmd/pull/2481): \[java] Fix JUnitSpellingRule false positive - [Artem Krosheninnikov](https://github.com/KroArtem)
diff --git a/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/codestyle/MethodNamingConventionsRule.java b/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/codestyle/MethodNamingConventionsRule.java
index b805a0cabc..bf1117150d 100644
--- a/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/codestyle/MethodNamingConventionsRule.java
+++ b/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/codestyle/MethodNamingConventionsRule.java
@@ -35,6 +35,7 @@ public class MethodNamingConventionsRule extends AbstractNamingConventionRule<AS
     private final PropertyDescriptor<Pattern> nativeRegex = defaultProp("native").build();
     private final PropertyDescriptor<Pattern> junit3Regex = defaultProp("JUnit 3 test").defaultValue("test[A-Z0-9][a-zA-Z0-9]*").build();
     private final PropertyDescriptor<Pattern> junit4Regex = defaultProp("JUnit 4 test").build();
+    private final PropertyDescriptor<Pattern> junit5Regex = defaultProp("JUnit 5 test").build();
 
 
     public MethodNamingConventionsRule() {
@@ -45,6 +46,11 @@ public class MethodNamingConventionsRule extends AbstractNamingConventionRule<AS
         definePropertyDescriptor(nativeRegex);
         definePropertyDescriptor(junit3Regex);
         definePropertyDescriptor(junit4Regex);
+        definePropertyDescriptor(junit5Regex);
+    }
+
+    private boolean isJunit5Test(ASTMethodDeclaration node) {
+        return node.isAnnotationPresent("org.junit.jupiter.api.Test");
     }
 
     private boolean isJunit4Test(ASTMethodDeclaration node) {
@@ -85,6 +91,8 @@ public class MethodNamingConventionsRule extends AbstractNamingConventionRule<AS
             }
         } else if (node.isStatic()) {
             checkMatches(node, staticRegex, data);
+        } else if (isJunit5Test(node)) {
+            checkMatches(node, junit5Regex, data);
         } else if (isJunit4Test(node)) {
             checkMatches(node, junit4Regex, data);
         } else if (isJunit3Test(node)) {
diff --git a/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelper.java b/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelper.java
index 9114a2fe60..f591d6097c 100644
--- a/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelper.java
+++ b/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelper.java
@@ -6,6 +6,7 @@ package net.sourceforge.pmd.lang.java.typeresolution;
 
 import java.lang.reflect.Array;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import org.apache.commons.lang3.StringUtils;
@@ -16,6 +17,7 @@ import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceDeclaration;
 import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceType;
 import net.sourceforge.pmd.lang.java.ast.ASTEnumDeclaration;
 import net.sourceforge.pmd.lang.java.ast.ASTImplementsList;
+import net.sourceforge.pmd.lang.java.ast.ASTImportDeclaration;
 import net.sourceforge.pmd.lang.java.ast.TypeNode;
 import net.sourceforge.pmd.lang.java.symboltable.TypedNameDeclaration;
 import net.sourceforge.pmd.lang.java.typeresolution.internal.NullableClassLoader;
@@ -85,6 +87,18 @@ public final class TypeHelper {
     }
 
     private static boolean fallbackIsA(TypeNode n, String clazzName) {
+        if (n.getImage() != null && !n.getImage().contains(".") && clazzName.contains(".")) {
+            // simple name detected, check the imports to get the full name and use that for fallback
+            List<ASTImportDeclaration> imports = n.getRoot().findChildrenOfType(ASTImportDeclaration.class);
+            for (ASTImportDeclaration importDecl : imports) {
+                if (n.hasImageEqualTo(importDecl.getImportedSimpleName())) {
+                    // found the import, compare the full names
+                    return clazzName.equals(importDecl.getImportedName());
+                }
+            }
+        }
+
+        // fall back on using the simple name of the class only
         if (clazzName.equals(n.getImage()) || clazzName.endsWith("." + n.getImage())) {
             return true;
         }
diff --git a/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelperTest.java b/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelperTest.java
index e0a744135d..d70f3f806a 100644
--- a/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelperTest.java
+++ b/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/typeresolution/TypeHelperTest.java
@@ -18,6 +18,8 @@ import org.junit.rules.ExpectedException;
 import net.sourceforge.pmd.lang.java.ast.ASTAnnotationTypeDeclaration;
 import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceDeclaration;
 import net.sourceforge.pmd.lang.java.ast.ASTEnumDeclaration;
+import net.sourceforge.pmd.lang.java.ast.ASTMarkerAnnotation;
+import net.sourceforge.pmd.lang.java.ast.ASTName;
 import net.sourceforge.pmd.lang.java.ast.TypeNode;
 import net.sourceforge.pmd.lang.java.symboltable.BaseNonParserTest;
 import net.sourceforge.pmd.lang.java.typeresolution.internal.NullableClassLoader;
@@ -78,6 +80,24 @@ public class TypeHelperTest extends BaseNonParserTest {
         assertIsA(klass, Object.class);
     }
 
+    /**
+     * If we don't have the annotation on the classpath,
+     * we should resolve the full name via the import, if possible
+     * and compare then. Only after that, we should compare the
+     * simple names.
+     */
+    @Test
+    public void testIsAFallbackAnnotationSimpleNameImport() {
+        ASTName annotation = java.parse("package org; import foo.Stuff; @Stuff public class FooBar {}")
+                .getFirstDescendantOfType(ASTMarkerAnnotation.class).getFirstChildOfType(ASTName.class);
+
+        Assert.assertNull(annotation.getType());
+        Assert.assertTrue(TypeHelper.isA(annotation, "foo.Stuff"));
+        Assert.assertFalse(TypeHelper.isA(annotation, "other.Stuff"));
+        // if the searched class name is not fully qualified, then the search should still be successfull
+        Assert.assertTrue(TypeHelper.isA(annotation, "Stuff"));
+    }
+
     private void assertIsA(TypeNode node, Class<?> type) {
         Assert.assertTrue("TypeHelper::isA with class arg: " + type.getCanonicalName(),
                           TypeHelper.isA(node, type));
diff --git a/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/codestyle/xml/MethodNamingConventions.xml b/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/codestyle/xml/MethodNamingConventions.xml
index c494c196af..f5aa5bbd63 100644
--- a/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/codestyle/xml/MethodNamingConventions.xml
+++ b/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/codestyle/xml/MethodNamingConventions.xml
@@ -150,31 +150,83 @@ public class MethodNamingConventions implements SomeInterface {
             ]]>
         </code>
     </test-code>
+
     <test-code>
         <description>JUnit 4 test detection</description>
         <rule-property name="junit4TestPattern">[a-z][A-Za-z]*Test</rule-property>
         <expected-problems>2</expected-problems>
-        <expected-linenumbers>12,16</expected-linenumbers>
+        <expected-linenumbers>8,12</expected-linenumbers>
         <expected-messages>
             <message>The JUnit 4 test method name 'testGetBestTeam' doesn't match '[a-z][A-Za-z]*Test'</message>
             <message>The JUnit 4 test method name 'getBestTeam' doesn't match '[a-z][A-Za-z]*Test'</message>
         </expected-messages>
         <code><![CDATA[
-            import junit.framework.Assert;
-            import junit.framework.TestCase;
+import junit.framework.TestCase;
+import org.junit.Test;
 
-            import org.junit.Test;
+public class TournamentTest extends TestCase {
+    Tournament tournament;
 
+    @Test // note that this is also a junit 3 test, but the junit4 rule applies
+    public void testGetBestTeam() {
+    }
 
-            public class TournamentTest extends TestCase {
-                Tournament tournament;
+    @Test // this is just a junit 4 test
+    public void getBestTeam() {
+    }
 
+    // this is ok
+    @Test
+    public void getBestTeamTest() {
+    }
+}
+        ]]></code>
+    </test-code>
 
-                @Test // note that this is also a junit 3 test, but the junit4 rule applies
+    <test-code useAuxClasspath="false">
+        <description>JUnit 4 test detection without proper auxclasspath</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>8</expected-linenumbers>
+        <expected-messages>
+            <message>The JUnit 4 test method name 'get_best_team' doesn't match '[a-z][a-zA-Z0-9]*'</message>
+        </expected-messages>
+        <code><![CDATA[
+import org.junit.Test; // note: test case uses "useAuxClasspath=false"!!
+
+public class TournamentTest {
+    Tournament tournament;
+
+    // wrong test name pattern
+    @Test
+    public void get_best_team() {
+    }
+
+    // this is ok
+    @Test
+    public void getBestTeam() {
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>JUnit 5 test detection</description>
+        <rule-property name="junit5TestPattern">[a-z][A-Za-z]*Test</rule-property>
+        <expected-problems>2</expected-problems>
+        <expected-linenumbers>5,9</expected-linenumbers>
+        <expected-messages>
+            <message>The JUnit 5 test method name 'testGetBestTeam' doesn't match '[a-z][A-Za-z]*Test'</message>
+            <message>The JUnit 5 test method name 'getBestTeam' doesn't match '[a-z][A-Za-z]*Test'</message>
+        </expected-messages>
+        <code><![CDATA[
+            import org.junit.jupiter.api.Test;
+
+            public class TournamentTest {
+                @Test // note that this is also a junit 3 test, but the junit 5 rule applies
                 public void testGetBestTeam() {
                 }
 
-                @Test // this is just a junit 4 test
+                @Test // this is just a junit 5 test
                 public void getBestTeam() {
                 }
 
diff --git a/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/ProperLogger.xml b/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/ProperLogger.xml
index b7e0e77ed4..3a0b804f2a 100644
--- a/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/ProperLogger.xml
+++ b/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/ProperLogger.xml
@@ -233,6 +233,23 @@ public class Foo {
     public Foo() {
         this.log = new Log(Foo.class);
     }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>false negative with apache commons logging</description>
+        <expected-problems>1</expected-problems>
+        <code><![CDATA[
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class ProperLoggerSample {
+    private final Log log;
+
+    public PropperLoggerSample() {
+        log = LogFactory.getLog(ProperLoggerSample.class);
+    }
 }
         ]]></code>
     </test-code>
diff --git a/pmd-test/src/main/java/net/sourceforge/pmd/testframework/RuleTst.java b/pmd-test/src/main/java/net/sourceforge/pmd/testframework/RuleTst.java
index 512eff922d..1c9529b0e5 100644
--- a/pmd-test/src/main/java/net/sourceforge/pmd/testframework/RuleTst.java
+++ b/pmd-test/src/main/java/net/sourceforge/pmd/testframework/RuleTst.java
@@ -274,6 +274,20 @@ public abstract class RuleTst {
             if (isUseAuxClasspath) {
                 // configure the "auxclasspath" option for unit testing
                 p.getConfiguration().prependClasspath(".");
+            } else {
+                // simple class loader, that doesn't delegate to parent.
+                // this allows us in the tests to simulate PMD run without
+                // auxclasspath, not even the classes from the test dependencies
+                // will be found.
+                p.getConfiguration().setClassLoader(new ClassLoader() {
+                    @Override
+                    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+                        if (name.startsWith("java.") || name.startsWith("javax.")) {
+                            return super.loadClass(name, resolve);
+                        }
+                        throw new ClassNotFoundException(name);
+                    }
+                });
             }
             RuleContext ctx = new RuleContext();
             ctx.setReport(report);