build.gradle

@@ -11,8 +11,8 @@ buildscript {
 
         classpath "io.github.gradle-nexus:publish-plugin:2.0.0-rc-1"
         // TODO check if https://github.com/shipkit/shipkit-changelog/issues/103 is fixed, and remove workaround in shipkit.gradle.
-        classpath 'org.shipkit:shipkit-changelog:1.2.0'
-        classpath 'org.shipkit:shipkit-auto-version:1.2.2'
+        classpath 'org.shipkit:shipkit-changelog:2.0.1'
+        classpath 'org.shipkit:shipkit-auto-version:2.0.2'
 
         classpath 'com.google.googlejavaformat:google-java-format:1.19.2'
         classpath 'com.android.tools.build:gradle:7.4.2'
@@ -21,9 +21,9 @@ buildscript {
 }
 
 plugins {
-    id 'com.diffplug.spotless' version '6.23.3'
+    id 'com.diffplug.spotless' version '6.25.0'
     id 'eclipse'
-    id 'com.github.ben-manes.versions' version '0.50.0'
+    id 'com.github.ben-manes.versions' version '0.51.0'
     id 'biz.aQute.bnd.builder' version '7.0.0'
     id 'ru.vyarus.animalsniffer' version '1.7.1'
 }

gradle/dependencies.gradle

@@ -14,7 +14,7 @@ libraries.junitJupiterParams = "org.junit.jupiter:junit-jupiter-params:${version
 libraries.junitPlatformLauncher = 'org.junit.platform:junit-platform-launcher:1.10.1'
 libraries.junitJupiterEngine = "org.junit.jupiter:junit-jupiter-engine:${versions.junitJupiter}"
 libraries.junitVintageEngine = "org.junit.vintage:junit-vintage-engine:${versions.junitJupiter}"
-libraries.assertj = 'org.assertj:assertj-core:3.25.1'
+libraries.assertj = 'org.assertj:assertj-core:3.25.2'
 libraries.hamcrest = 'org.hamcrest:hamcrest-core:2.2'
 libraries.opentest4j = 'org.opentest4j:opentest4j:1.3.0'
 

src/main/java/org/mockito/internal/MockitoCore.java

@@ -26,10 +26,7 @@
 import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
 
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.function.Function;
 
 import org.mockito.InOrder;
@@ -59,7 +56,7 @@
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.MockMaker;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.LenientStubber;
@@ -70,9 +67,8 @@
 @SuppressWarnings("unchecked")
 public class MockitoCore {
 
-    private static final DoNotMockEnforcer DO_NOT_MOCK_ENFORCER = Plugins.getDoNotMockEnforcer();
-    private static final Set<Class<?>> MOCKABLE_CLASSES =
-            Collections.synchronizedSet(new HashSet<>());
+    private static final DoNotMockEnforcerWithType DO_NOT_MOCK_ENFORCER =
+            Plugins.getDoNotMockEnforcer();
 
     public <T> T mock(Class<T> typeToMock, MockSettings settings) {
         if (!(settings instanceof MockSettingsImpl)) {
@@ -84,43 +80,12 @@ public <T> T mock(Class<T> typeToMock, MockSettings settings) {
         }
         MockSettingsImpl impl = (MockSettingsImpl) settings;
         MockCreationSettings<T> creationSettings = impl.build(typeToMock);
-        checkDoNotMockAnnotation(creationSettings.getTypeToMock(), creationSettings);
+        checkDoNotMockAnnotation(creationSettings);
         T mock = createMock(creationSettings);
         mockingProgress().mockingStarted(mock, creationSettings);
         return mock;
     }
 
-    private void checkDoNotMockAnnotation(
-            Class<?> typeToMock, MockCreationSettings<?> creationSettings) {
-        checkDoNotMockAnnotationForType(typeToMock);
-        for (Class<?> aClass : creationSettings.getExtraInterfaces()) {
-            checkDoNotMockAnnotationForType(aClass);
-        }
-    }
-
-    private static void checkDoNotMockAnnotationForType(Class<?> type) {
-        // Object and interfaces do not have a super class
-        if (type == null) {
-            return;
-        }
-
-        if (MOCKABLE_CLASSES.contains(type)) {
-            return;
-        }
-
-        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(type);
-        if (warning != null) {
-            throw new DoNotMockException(warning);
-        }
-
-        checkDoNotMockAnnotationForType(type.getSuperclass());
-        for (Class<?> aClass : type.getInterfaces()) {
-            checkDoNotMockAnnotationForType(aClass);
-        }
-
-        MOCKABLE_CLASSES.add(type);
-    }
-
     public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings settings) {
         if (!MockSettingsImpl.class.isInstance(settings)) {
             throw new IllegalArgumentException(
@@ -131,12 +96,20 @@ public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings setting
         }
         MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
         MockCreationSettings<T> creationSettings = impl.buildStatic(classToMock);
+        checkDoNotMockAnnotation(creationSettings);
         MockMaker.StaticMockControl<T> control = createStaticMock(classToMock, creationSettings);
         control.enable();
         mockingProgress().mockingStarted(classToMock, creationSettings);
         return new MockedStaticImpl<>(control);
     }
 
+    private void checkDoNotMockAnnotation(MockCreationSettings<?> creationSettings) {
+        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(creationSettings);
+        if (warning != null) {
+            throw new DoNotMockException(warning);
+        }
+    }
+
     public <T> MockedConstruction<T> mockConstruction(
             Class<T> typeToMock,
             Function<MockedConstruction.Context, ? extends MockSettings> settingsFactory,

src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java

@@ -12,7 +12,7 @@
 import org.mockito.MockMakers;
 import org.mockito.internal.util.MockUtil;
 import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -62,7 +62,7 @@ public class DefaultMockitoPlugins implements MockitoPlugins {
         DEFAULT_PLUGINS.put(
                 REFLECTION_ALIAS, "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
         DEFAULT_PLUGINS.put(
-                DoNotMockEnforcer.class.getName(),
+                DoNotMockEnforcerWithType.class.getName(),
                 "org.mockito.internal.configuration.DefaultDoNotMockEnforcer");
 
         MOCK_MAKER_ALIASES.add(INLINE_ALIAS);

src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java

@@ -45,20 +45,20 @@ class PluginLoader {
     /**
      * Scans the classpath for given pluginType. If not found, default class is used.
      */
-    @SuppressWarnings("unchecked")
     <T> T loadPlugin(final Class<T> pluginType) {
-        return (T) loadPlugin(pluginType, null);
+        return loadPlugin(pluginType, null);
     }
 
     /**
      * Scans the classpath for given {@code preferredPluginType}. If not found scan for {@code
      * alternatePluginType}. If neither a preferred or alternate plugin is found, default to default
      * class of {@code preferredPluginType}.
      *
-     * @return An object of either {@code preferredPluginType} or {@code alternatePluginType}
+     * @return An object of either {@code preferredPluginType} or {@code alternatePluginType},
+     * cast to the lowest common denominator in the chain of inheritance
      */
     @SuppressWarnings("unchecked")
-    <PreferredT, AlternateType> Object loadPlugin(
+    <ReturnT, PreferredT extends ReturnT, AlternateType extends ReturnT> ReturnT loadPlugin(
             final Class<PreferredT> preferredPluginType,
             final Class<AlternateType> alternatePluginType) {
         try {
@@ -74,22 +74,23 @@ <PreferredT, AlternateType> Object loadPlugin(
 
             return plugins.getDefaultPlugin(preferredPluginType);
         } catch (final Throwable t) {
-            return Proxy.newProxyInstance(
-                    preferredPluginType.getClassLoader(),
-                    new Class<?>[] {preferredPluginType},
-                    new InvocationHandler() {
-                        @Override
-                        public Object invoke(Object proxy, Method method, Object[] args)
-                                throws Throwable {
-                            throw new IllegalStateException(
-                                    "Could not initialize plugin: "
-                                            + preferredPluginType
-                                            + " (alternate: "
-                                            + alternatePluginType
-                                            + ")",
-                                    t);
-                        }
-                    });
+            return (ReturnT)
+                    Proxy.newProxyInstance(
+                            preferredPluginType.getClassLoader(),
+                            new Class<?>[] {preferredPluginType},
+                            new InvocationHandler() {
+                                @Override
+                                public Object invoke(Object proxy, Method method, Object[] args)
+                                        throws Throwable {
+                                    throw new IllegalStateException(
+                                            "Could not initialize plugin: "
+                                                    + preferredPluginType
+                                                    + " (alternate: "
+                                                    + alternatePluginType
+                                                    + ")",
+                                            t);
+                                }
+                            });
         }
     }
 

src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java

@@ -5,8 +5,10 @@
 package org.mockito.internal.configuration.plugins;
 
 import java.util.List;
+
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -46,8 +48,9 @@ class PluginRegistry {
     private final List<MockResolver> mockResolvers =
             new PluginLoader(pluginSwitch).loadPlugins(MockResolver.class);
 
-    private final DoNotMockEnforcer doNotMockEnforcer =
-            new PluginLoader(pluginSwitch).loadPlugin(DoNotMockEnforcer.class);
+    private final DoNotMockEnforcerWithType doNotMockEnforcer =
+            new PluginLoader(pluginSwitch)
+                    .loadPlugin(DoNotMockEnforcerWithType.class, DoNotMockEnforcer.class);
 
     PluginRegistry() {
         instantiatorProvider =
@@ -119,7 +122,7 @@ MockitoLogger getMockitoLogger() {
      * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
      * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
      */
-    DoNotMockEnforcer getDoNotMockEnforcer() {
+    DoNotMockEnforcerWithType getDoNotMockEnforcer() {
         return doNotMockEnforcer;
     }
 

src/main/java/org/mockito/internal/configuration/plugins/Plugins.java

@@ -4,10 +4,12 @@
  */
 package org.mockito.internal.configuration.plugins;
 
-import org.mockito.DoNotMock;
 import java.util.List;
+
+import org.mockito.DoNotMock;
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -16,7 +18,9 @@
 import org.mockito.plugins.MockitoPlugins;
 import org.mockito.plugins.StackTraceCleanerProvider;
 
-/** Access to Mockito behavior that can be reconfigured by plugins */
+/**
+ * Access to Mockito behavior that can be reconfigured by plugins
+ */
 public final class Plugins {
 
     private static final PluginRegistry registry = new PluginRegistry();
@@ -99,9 +103,10 @@ public static MockitoPlugins getPlugins() {
      * Returns the {@link DoNotMock} enforcer available for the current runtime.
      *
      * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
-     * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
+     * {@link DoNotMockEnforcerWithType} or {@link DoNotMockEnforcer} extension exists or is visible
+     * in the current classpath.</p>
      */
-    public static DoNotMockEnforcer getDoNotMockEnforcer() {
+    public static DoNotMockEnforcerWithType getDoNotMockEnforcer() {
         return registry.getDoNotMockEnforcer();
     }
 

src/main/java/org/mockito/internal/creation/MockSettingsImpl.java

@@ -34,6 +34,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -283,9 +284,7 @@ private static <T> CreationSettings<T> validatedSettings(
         // TODO SF - I don't think we really need CreationSettings type
         // TODO do we really need to copy the entire settings every time we create mock object? it
         // does not seem necessary.
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), typeToMock, false));
-        settings.setTypeToMock(typeToMock);
+        CreationSettings<T> settings = buildCreationSettings(typeToMock, source, MockType.INSTANCE);
         settings.setExtraInterfaces(prepareExtraInterfaces(source));
         return settings;
     }
@@ -306,9 +305,15 @@ private static <T> CreationSettings<T> validatedStaticSettings(
                     "Cannot specify spied instance for static mock of " + classToMock);
         }
 
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), classToMock, true));
+        return buildCreationSettings(classToMock, source, MockType.STATIC);
+    }
+
+    private static <T> CreationSettings<T> buildCreationSettings(
+            Class<T> classToMock, CreationSettings<T> source, MockType mockType) {
+        CreationSettings<T> settings = new CreationSettings<>(source);
+        settings.setMockName(new MockNameImpl(source.getName(), classToMock, mockType));
         settings.setTypeToMock(classToMock);
+        settings.setMockType(mockType);
         return settings;
     }
 

src/main/java/org/mockito/internal/creation/settings/CreationSettings.java

@@ -18,6 +18,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -49,6 +50,7 @@ public class CreationSettings<T> implements MockCreationSettings<T>, Serializabl
     private Object[] constructorArgs;
     protected Strictness strictness = null;
     protected String mockMaker;
+    protected MockType mockType;
 
     public CreationSettings() {}
 
@@ -73,6 +75,7 @@ public CreationSettings(CreationSettings copy) {
         this.strictness = copy.strictness;
         this.stripAnnotations = copy.stripAnnotations;
         this.mockMaker = copy.mockMaker;
+        this.mockType = copy.mockType;
     }
 
     @Override
@@ -198,4 +201,13 @@ public String getMockMaker() {
     public Type getGenericTypeToMock() {
         return genericTypeToMock;
     }
+
+    @Override
+    public MockType getMockType() {
+        return mockType;
+    }
+
+    public void setMockType(MockType mockType) {
+        this.mockType = mockType;
+    }
 }

src/main/java/org/mockito/internal/util/MockNameImpl.java

@@ -7,6 +7,7 @@
 import java.io.Serializable;
 
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 
 public class MockNameImpl implements MockName, Serializable {
 
@@ -15,9 +16,9 @@ public class MockNameImpl implements MockName, Serializable {
     private boolean defaultName;
 
     @SuppressWarnings("unchecked")
-    public MockNameImpl(String mockName, Class<?> type, boolean mockedStatic) {
+    public MockNameImpl(String mockName, Class<?> type, MockType mockType) {
         if (mockName == null) {
-            this.mockName = mockedStatic ? toClassName(type) : toInstanceName(type);
+            this.mockName = mockType == MockType.STATIC ? toClassName(type) : toInstanceName(type);
             this.defaultName = true;
         } else {
             this.mockName = mockName;

src/main/java/org/mockito/mock/MockCreationSettings.java

@@ -151,4 +151,12 @@ public interface MockCreationSettings<T> {
      * @since 4.8.0
      */
     String getMockMaker();
+
+    /**
+     * Returns the {@link MockType} for the mock being created.
+     *
+     * @see MockType
+     * @since 5.9.0
+     */
+    MockType getMockType();
 }

src/main/java/org/mockito/mock/MockType.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.mock;
+
+/**
+ * The type of mock being created
+ */
+public enum MockType {
+
+    /**
+     * Mock created as an instance of the mocked type
+     */
+    INSTANCE,
+
+    /**
+     * Mock replaces the mocked type through static mocking
+     */
+    STATIC,
+}

src/main/java/org/mockito/plugins/DoNotMockEnforcer.java

@@ -4,20 +4,96 @@
  */
 package org.mockito.plugins;
 
+import org.mockito.NotExtensible;
+import org.mockito.mock.MockCreationSettings;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
 /**
  * Enforcer that is applied to every type in the type hierarchy of the class-to-be-mocked.
  */
-public interface DoNotMockEnforcer {
+public interface DoNotMockEnforcer extends DoNotMockEnforcerWithType {
 
     /**
-     * If this type is allowed to be mocked. Return an empty optional if the enforcer allows
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
      * this type to be mocked. Return a message if there is a reason this type can not be mocked.
-     *
-     * Note that Mockito performs traversal of the type hierarchy. Implementations of this class
-     * should therefore not perform type traversal themselves but rely on Mockito.
+     * <p>
+     * Note that traversal of the type hierarchy is performed externally to this method.
+     * Implementations of it should therefore not perform type traversal themselves.
      *
      * @param type The type to check
-     * @return Optional message if this type can not be mocked, or an empty optional if type can be mocked
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     * @see #checkTypeForDoNotMockViolation(MockCreationSettings)
      */
     String checkTypeForDoNotMockViolation(Class<?> type);
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     * <p>
+     * The default implementation traverses the class hierarchy of the type to be mocked and
+     * checks it against {@link #checkTypeForDoNotMockViolation(Class)}. If any types fails
+     * the validation, the traversal is interrupted and the error message is returned.
+     *
+     * @param creationSettings The mock creation settings
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     * @since 5.9.0
+     */
+    @Override
+    default String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings) {
+        String warning = recursiveCheckDoNotMockAnnotationForType(creationSettings.getTypeToMock());
+        if (warning != null) {
+            return warning;
+        }
+
+        for (Class<?> aClass : creationSettings.getExtraInterfaces()) {
+            warning = recursiveCheckDoNotMockAnnotationForType(aClass);
+            if (warning != null) {
+                return warning;
+            }
+        }
+
+        return null;
+    }
+
+    private String recursiveCheckDoNotMockAnnotationForType(Class<?> type) {
+        // Object and interfaces do not have a super class
+        if (type == null) {
+            return null;
+        }
+
+        if (Cache.MOCKABLE_TYPES.contains(type)) {
+            return null;
+        }
+
+        String warning = checkTypeForDoNotMockViolation(type);
+        if (warning != null) {
+            return warning;
+        }
+
+        warning = recursiveCheckDoNotMockAnnotationForType(type.getSuperclass());
+        if (warning != null) {
+            return warning;
+        }
+
+        for (Class<?> aClass : type.getInterfaces()) {
+            warning = recursiveCheckDoNotMockAnnotationForType(aClass);
+            if (warning != null) {
+                return warning;
+            }
+        }
+
+        Cache.MOCKABLE_TYPES.add(type);
+        return null;
+    }
+
+    /**
+     * Static cache for types that are known to be mockable and
+     * thus may be skipped while traversing the class hierarchy.
+     */
+    @NotExtensible
+    class Cache {
+        private static final Set<Class<?>> MOCKABLE_TYPES = ConcurrentHashMap.newKeySet();
+    }
 }

src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Enforcer that checks if a mock can be created given its type and other settings used in its creation.
+ *
+ * @since 5.9.0
+ */
+public interface DoNotMockEnforcerWithType {
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     *
+     * @param creationSettings The mock creation settings
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     */
+    String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings);
+}

src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java

@@ -4,9 +4,10 @@
  */
 package org.mockito.internal.configuration.plugins;
 
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import org.assertj.core.api.Assertions;
@@ -29,13 +30,27 @@ public class PluginLoaderTest {
 
     @Test
     public void loads_plugin() {
-        when(initializer.loadImpl(FooPlugin.class)).thenReturn(new FooPlugin());
+        FooPlugin expected = new FooPlugin();
+        when(initializer.loadImpl(FooPlugin.class)).thenReturn(expected);
 
         // when
         FooPlugin plugin = loader.loadPlugin(FooPlugin.class);
 
         // then
-        assertNotNull(plugin);
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_preferred_plugin() {
+        FooPlugin expected = new FooPlugin();
+        willReturn(expected).given(initializer).loadImpl(FooPlugin.class);
+
+        // when
+        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(BarPlugin.class);
     }
 
     @Test
@@ -48,7 +63,7 @@ public void loads_alternative_plugin() {
         Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
 
         // then
-        assertSame(plugin, expected);
+        assertSame(expected, plugin);
     }
 
     @Test
@@ -62,7 +77,7 @@ public void loads_default_plugin() {
         Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
 
         // then
-        assertSame(plugin, expected);
+        assertSame(expected, plugin);
     }
 
     @Test
@@ -87,9 +102,141 @@ public void call() throws Throwable {
                 .hasCause(cause);
     }
 
+    @Test
+    public void loads_preferred_plugin_inheritance() {
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(Foo.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(Foo.class, FooChildPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(FooChildPlugin.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin_inheritance() {
+        willReturn(null).given(initializer).loadImpl(Bar.class);
+        BarChildPlugin expected = new BarChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(BarChildPlugin.class);
+
+        // when
+        Bar plugin = loader.loadPlugin(Bar.class, BarChildPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin_inheritance() {
+        willReturn(null).given(initializer).loadImpl(Foo.class);
+        willReturn(null).given(initializer).loadImpl(FooChildPlugin.class);
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(plugins).getDefaultPlugin(Foo.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(Foo.class, FooChildPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_preferred_plugin_inheritance_reversed() {
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(FooChildPlugin.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(FooChildPlugin.class, Foo.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(Foo.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin_inheritance_reversed() {
+        willReturn(null).given(initializer).loadImpl(BarChildPlugin.class);
+        BarChildPlugin expected = new BarChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(Bar.class);
+
+        // when
+        Bar plugin = loader.loadPlugin(BarChildPlugin.class, Bar.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin_inheritance_reversed() {
+        willReturn(null).given(initializer).loadImpl(Foo.class);
+        willReturn(null).given(initializer).loadImpl(FooChildPlugin.class);
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(plugins).getDefaultPlugin(FooChildPlugin.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(FooChildPlugin.class, Foo.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_preferred_plugin_inheritance_lowest_common_denominator() {
+        FooBarChildPlugin1 expected = new FooBarChildPlugin1();
+        willReturn(expected).given(initializer).loadImpl(FooBarChildPlugin1.class);
+
+        // when
+        FooBar plugin = loader.loadPlugin(FooBarChildPlugin1.class, FooBarChildPlugin2.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(FooBarChildPlugin2.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin_inheritance_lowest_common_denominator() {
+        willReturn(null).given(initializer).loadImpl(FooBarChildPlugin1.class);
+        FooBarChildPlugin2 expected = new FooBarChildPlugin2();
+        willReturn(expected).given(initializer).loadImpl(FooBarChildPlugin2.class);
+
+        // when
+        FooBar plugin = loader.loadPlugin(FooBarChildPlugin1.class, FooBarChildPlugin2.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin_inheritance_lowest_common_denominator() {
+        willReturn(null).given(initializer).loadImpl(FooBarChildPlugin1.class);
+        willReturn(null).given(initializer).loadImpl(FooBarChildPlugin2.class);
+        FooBarChildPlugin1 expected = new FooBarChildPlugin1();
+        willReturn(expected).given(plugins).getDefaultPlugin(FooBarChildPlugin1.class);
+
+        // when
+        FooBar plugin = loader.loadPlugin(FooBarChildPlugin1.class, FooBarChildPlugin2.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
     static class FooPlugin {}
 
     static class BarPlugin {}
 
-    static interface Foo {}
+    interface Foo {}
+
+    interface Bar {}
+
+    static class BarChildPlugin implements Bar {}
+
+    static class FooChildPlugin implements Foo {}
+
+    interface FooBar {}
+
+    static class FooBarChildPlugin1 implements FooBar {}
+
+    static class FooBarChildPlugin2 implements FooBar {}
 }

src/test/java/org/mockito/internal/util/MockNameImplTest.java

@@ -7,22 +7,23 @@
 import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
+import org.mockito.mock.MockType;
 import org.mockitoutil.TestBase;
 
 public class MockNameImplTest extends TestBase {
 
     @Test
     public void shouldProvideTheNameForClass() throws Exception {
         // when
-        String name = new MockNameImpl(null, SomeClass.class, false).toString();
+        String name = new MockNameImpl(null, SomeClass.class, MockType.INSTANCE).toString();
         // then
         assertEquals("someClass", name);
     }
 
     @Test
     public void shouldProvideTheNameForClassOnStaticMock() throws Exception {
         // when
-        String name = new MockNameImpl(null, SomeClass.class, true).toString();
+        String name = new MockNameImpl(null, SomeClass.class, MockType.STATIC).toString();
         // then
         assertEquals("SomeClass.class", name);
     }
@@ -32,7 +33,8 @@ public void shouldProvideTheNameForAnonymousClass() throws Exception {
         // given
         SomeInterface anonymousInstance = new SomeInterface() {};
         // when
-        String name = new MockNameImpl(null, anonymousInstance.getClass(), false).toString();
+        String name =
+                new MockNameImpl(null, anonymousInstance.getClass(), MockType.INSTANCE).toString();
         // then
         assertEquals("someInterface", name);
     }
@@ -42,23 +44,24 @@ public void shouldProvideTheNameForAnonymousClassOnStatic() throws Exception {
         // given
         SomeInterface anonymousInstance = new SomeInterface() {};
         // when
-        String name = new MockNameImpl(null, anonymousInstance.getClass(), true).toString();
+        String name =
+                new MockNameImpl(null, anonymousInstance.getClass(), MockType.STATIC).toString();
         // then
         assertEquals("SomeInterface$.class", name);
     }
 
     @Test
     public void shouldProvideTheGivenName() throws Exception {
         // when
-        String name = new MockNameImpl("The Hulk", SomeClass.class, false).toString();
+        String name = new MockNameImpl("The Hulk", SomeClass.class, MockType.INSTANCE).toString();
         // then
         assertEquals("The Hulk", name);
     }
 
     @Test
     public void shouldProvideTheGivenNameOnStatic() throws Exception {
         // when
-        String name = new MockNameImpl("The Hulk", SomeClass.class, true).toString();
+        String name = new MockNameImpl("The Hulk", SomeClass.class, MockType.STATIC).toString();
         // then
         assertEquals("The Hulk", name);
     }

src/test/java/org/mockitousage/annotation/DoNotMockTest.java

@@ -6,10 +6,12 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
 
 import org.junit.Test;
 import org.mockito.DoNotMock;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.MockitoAnnotations;
 import org.mockito.exceptions.misusing.DoNotMockException;
 
@@ -24,6 +26,15 @@ public void can_not_mock_class_annotated_with_donotmock() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_class_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockable> notMockable = mockStatic(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void can_not_mock_class_via_mock_annotation() {
         assertThatThrownBy(
@@ -43,6 +54,16 @@ public void can_not_mock_class_with_interface_annotated_with_donotmock() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_class_with_interface_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfNotMockableInterface> notMockable =
+                                    mockStatic(SubclassOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void can_not_mock_subclass_with_unmockable_interface() {
         assertThatThrownBy(
@@ -53,6 +74,16 @@ public void can_not_mock_subclass_with_unmockable_interface() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_subclass_with_unmockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<DoubleSubclassOfInterface> notMockable =
+                                    mockStatic(DoubleSubclassOfInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void can_not_mock_subclass_with_unmockable_superclass() {
         assertThatThrownBy(
@@ -63,6 +94,16 @@ public void can_not_mock_subclass_with_unmockable_superclass() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_subclass_with_unmockable_superclass() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfNotMockableSuperclass> notMockable =
+                                    mockStatic(SubclassOfNotMockableSuperclass.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void
             can_not_mock_subclass_with_unmockable_interface_that_extends_non_mockable_interface() {
@@ -74,6 +115,17 @@ public void can_not_mock_subclass_with_unmockable_superclass() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void
+            can_not_statically_mock_subclass_with_unmockable_interface_that_extends_non_mockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfSubInterfaceOfNotMockableInterface> notMockable =
+                                    mockStatic(SubclassOfSubInterfaceOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void thrown_exception_includes_non_mockable_reason() {
         assertThatThrownBy(
@@ -94,6 +146,17 @@ public void thrown_exception_includes_special_non_mockable_reason() {
                 .hasMessageContaining("Special reason");
     }
 
+    @Test
+    public void thrown_exception_includes_special_non_mockable_reason_static() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockableWithReason> notMockable =
+                                    mockStatic(NotMockableWithReason.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("Special reason");
+    }
+
     @Test
     public void can_not_mock_class_with_custom_donotmock_annotation() {
         assertThatThrownBy(
@@ -104,6 +167,16 @@ public void can_not_mock_class_with_custom_donotmock_annotation() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_class_with_custom_donotmock_annotation() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockableWithDifferentAnnotation> notMockable =
+                                    mockStatic(NotMockableWithDifferentAnnotation.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @DoNotMock
     private static class NotMockable {}
 

subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java

@@ -6,9 +6,12 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
 
 import org.junit.Test;
 import org.mockito.DoNotMock;
+import org.mockito.MockedStatic;
+import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.misusing.DoNotMockException;
 
 public class DoNotmockEnforcerTest {
@@ -27,6 +30,50 @@ public void uses_custom_enforcer_allows_special_cased_class() {
         NotMockableButSpecialCased notMockable = mock(NotMockableButSpecialCased.class);
     }
 
+    @Test
+    public void uses_custom_enforcer_allows_statically_non_mockable() {
+        StaticallyNotMockable notMockable = mock(StaticallyNotMockable.class);
+    }
+
+    @Test
+    public void uses_custom_enforcer_disallows_static_mocks_of_type_with_specific_name() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyNotMockable> notMockable =
+                                    mockStatic(StaticallyNotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Cannot mockStatic!");
+    }
+
+    @Test
+    public void
+            uses_custom_enforcer_disallows_static_mocks_of_type_that_inherits_from_non_statically_mockable() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyNotMockableChild> notMockable =
+                                    mockStatic(StaticallyNotMockableChild.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Cannot mockStatic!");
+    }
+
+    @Test
+    public void uses_custom_enforcer_allows_static_mocks_of_type_with_specific_name() {
+        /*
+         Current MockMaker does not support static mocks, so asserting we get its exception rather than
+         a DoNotMockException is enough to assert the DoNotMockEnforcer let it through.
+        */
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyMockable> notMockable =
+                                    mockStatic(StaticallyMockable.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .isNotInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("does not support the creation of static mocks");
+    }
+
     @Test
     public void uses_custom_enforcer_has_custom_message() {
         assertThatThrownBy(
@@ -41,4 +88,10 @@ static class NotMockable {}
 
     @DoNotMock
     static class NotMockableButSpecialCased {}
+
+    static class StaticallyNotMockable {}
+
+    static class StaticallyNotMockableChild extends StaticallyNotMockable {}
+
+    static class StaticallyMockable {}
 }

subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java

@@ -4,6 +4,8 @@
  */
 package org.mockitousage.plugins.donotmockenforcer;
 
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockType;
 import org.mockito.plugins.DoNotMockEnforcer;
 
 public class MyDoNotMockEnforcer implements DoNotMockEnforcer {
@@ -14,9 +16,28 @@ public String checkTypeForDoNotMockViolation(Class<?> type) {
         if (type.getName().endsWith("NotMockableButSpecialCased")) {
             return null;
         }
+        // Special case for allowing StaticallyNotMockable to still be used for regular mocks
+        if (type.getName().endsWith("StaticallyNotMockable")) {
+            return null;
+        }
         if (type.getName().startsWith("org.mockitousage.plugins.donotmockenforcer")) {
             return "Custom message!";
         }
         return null;
     }
+
+    @Override
+    public String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings) {
+        if (creationSettings.getMockType() == MockType.STATIC) {
+            Class<?> type = creationSettings.getTypeToMock();
+            if (type.getName().endsWith("StaticallyMockable")) {
+                return null;
+            }
+            if (type.getName().startsWith("org.mockitousage.plugins.donotmockenforcer")) {
+                return "Cannot mockStatic!";
+            }
+            return null;
+        }
+        return DoNotMockEnforcer.super.checkTypeForDoNotMockViolation(creationSettings);
+    }
 }