diff --git a/Android.bp b/Android.bp
index 03d57ee..22e8cbf 100644
--- a/Android.bp
+++ b/Android.bp
@@ -35,11 +35,7 @@
             // dexmaker instead and including it causes conflicts.
             exclude_srcs: [
                 "src/main/java/org/mockito/internal/creation/bytebuddy/**/*.java",
-                "src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java",
             ],
-            srcs: [
-                "stub/java/org/mockito/internal/invocation/DefaultInvocationFactory.java",
-            ]
         },
         host: {
             static_libs: [
diff --git a/README.version b/README.version
index 64b0bed..bbabbe6 100644
--- a/README.version
+++ b/README.version
@@ -1,5 +1,5 @@
 URL: https://github.com/mockito/mockito
-Version: v2.12.0
+Version: v2.16.0
 License: Apache 2.0
 Description: Mockito is a mocking framework with a clean and simple API.
 
@@ -9,4 +9,4 @@
 The source can be updated using the update_source.sh script.
 
 Local Modifications:
-	- Added dummy DefaultInvocationFactory to fix build
+        None
diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java
index 415df01..b25dae5 100644
--- a/src/main/java/org/mockito/Mockito.java
+++ b/src/main/java/org/mockito/Mockito.java
@@ -25,6 +25,7 @@
 import org.mockito.quality.MockitoHint;
 import org.mockito.quality.Strictness;
 import org.mockito.session.MockitoSessionBuilder;
+import org.mockito.session.MockitoSessionLogger;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.Answer1;
 import org.mockito.stubbing.OngoingStubbing;
@@ -96,6 +97,8 @@
  *      <a href="#40">40. (*new*) Improved productivity and cleaner tests with "stricter" Mockito (Since 2.+)</a><br/>
  *      <a href="#41">41. (**new**) Advanced public API for framework integrations (Since 2.10.+)</a><br/>
  *      <a href="#42">42. (**new**) New API for integrations: listening on verification start events (Since 2.11.+)</a><br/>
+ *      <a href="#43">43. (**new**) New API for integrations: <code>MockitoSession</code> is usable by testing frameworks (Since 2.15.+)</a><br/>
+ *      <a href="#44">44. Deprecated <code>org.mockito.plugins.InstantiatorProvider</code> as it was leaking internal API. it was replaced by <code>org.mockito.plugins.InstantiatorProvider2 (Since 2.15.4)</code></a><br/>
  * </b>
  *
  * <h3 id="0">0. <a class="meaningful_link" href="#mockito2" name="mockito2">Migrating to Mockito 2</a></h3>
@@ -1396,7 +1399,7 @@
  * <a href="https://github.com/mockito/mockito/issues/769">issue 769</a>.
  *
  * <h3 id="41">41. <a class="meaningful_link" href="#framework_integrations_api" name="framework_integrations_api">
- *      (**new**) Advanced public API for framework integrations (Since 2.10.+)</h3>
+ *      (**new**) Advanced public API for framework integrations (Since 2.10.+)</a></h3>
  *
  * In Summer 2017 we decided that Mockito
  * <a href="https://www.linkedin.com/pulse/mockito-vs-powermock-opinionated-dogmatic-static-mocking-faber">
@@ -1449,7 +1452,7 @@
  * Do you have feedback? Please leave comment in <a href="https://github.com/mockito/mockito/issues/1110">issue 1110</a>.
  *
  * <h3 id="42">42. <a class="meaningful_link" href="#verifiation_started_listener" name="verifiation_started_listener">
- *       (**new**) New API for integrations: listening on verification start events (Since 2.11.+)</h3>
+ *       (**new**) New API for integrations: listening on verification start events (Since 2.11.+)</a></h3>
  *
  * Framework integrations such as <a href="https://projects.spring.io/spring-boot">Spring Boot</a> needs public API to tackle double-proxy use case
  * (<a href="https://github.com/mockito/mockito/issues/1191">issue 1191</a>).
@@ -1467,6 +1470,42 @@
  *     We found this method useful during the implementation.
  *     </li>
  * </ul>
+ *
+ * <h3 id="43">43. <a class="meaningful_link" href="#mockito_session_testing_frameworks" name="mockito_session_testing_frameworks">
+ *       (**new**) New API for integrations: <code>MockitoSession</code> is usable by testing frameworks (Since 2.15.+)</a></h3>
+ *
+ * <p>{@link MockitoSessionBuilder} and {@link MockitoSession} were enhanced to enable reuse by testing framework
+ * integrations (e.g. {@link MockitoRule} for JUnit):</p>
+ * <ul>
+ *     <li>{@link MockitoSessionBuilder#initMocks(Object...)} allows to pass in multiple test class instances for
+ *      initialization of fields annotated with Mockito annotations like {@link org.mockito.Mock}.
+ *      This method is useful for advanced framework integrations (e.g. JUnit Jupiter), when a test uses multiple,
+ *      e.g. nested, test class instances.
+ *     </li>
+ *     <li>{@link MockitoSessionBuilder#name(String)} allows to pass a name from the testing framework to the
+ *      {@link MockitoSession} that will be used for printing warnings when {@link Strictness#WARN} is used.
+ *     </li>
+ *     <li>{@link MockitoSessionBuilder#logger(MockitoSessionLogger)} makes it possible to customize the logger used
+ *      for hints/warnings produced when finishing mocking (useful for testing and to connect reporting capabilities
+ *      provided by testing frameworks such as JUnit Jupiter).
+ *     </li>
+ *     <li>{@link MockitoSession#setStrictness(Strictness)} allows to change the strictness of a {@link MockitoSession}
+ *      for one-off scenarios, e.g. it enables configuring a default strictness for all tests in a class but makes it
+ *      possible to change the strictness for a single or a few tests.
+ *     </li>
+ *     <li>{@link MockitoSession#finishMocking(Throwable)} was added to avoid confusion that may arise because
+ *      there are multiple competing failures. It will disable certain checks when the supplied <em>failure</em>
+ *      is not {@code null}.
+ *     </li>
+ * </ul>
+ *
+ * <h3 id="44">44. <a class="meaningful_link" href="#mockito_instantiator_provider_deprecation" name="mockito_instantiator_provider_deprecation">
+ *       Deprecated <code>org.mockito.plugins.InstantiatorProvider</code> as it was leaking internal API. it was
+ *       replaced by <code>org.mockito.plugins.InstantiatorProvider2 (Since 2.15.4)</a></h3>
+ *
+ * <p>{@link org.mockito.plugins.InstantiatorProvider} returned an internal API. Hence it was deprecated and replaced
+ * by {@link org.mockito.plugins.InstantiatorProvider2}. Old {@link org.mockito.plugins.InstantiatorProvider
+ * instantiator providers} will continue to work, but it is recommended to switch to the new API.</p>
  */
 @SuppressWarnings("unchecked")
 public class Mockito extends ArgumentMatchers {
@@ -1643,11 +1682,15 @@
      * // this calls the real implementation of Foo.getSomething()
      * value = mock.getSomething();
      *
-     * when(mock.getSomething()).thenReturn(fakeValue);
+     * doReturn(fakeValue).when(mock).getSomething();
      *
      * // now fakeValue is returned
      * value = mock.getSomething();
      * </code></pre>
+     *
+     * <p>
+     * <u>Note:</u> Stubbing partial mocks using <code>when(mock.getSomething()).thenReturn(fakeValue)</code>
+     * syntax will call the real method. For partial mock it's recommended to use <code>doReturn</code> syntax.
      */
     public static final Answer<Object> CALLS_REAL_METHODS = Answers.CALLS_REAL_METHODS;
 
@@ -2119,6 +2162,9 @@
      * See also {@link Mockito#never()} - it is more explicit and communicates the intent well.
      * <p>
      * Stubbed invocations (if called) are also treated as interactions.
+     * If you want stubbed invocations automatically verified, check out {@link Strictness#STRICT_STUBS} feature
+     * introduced in Mockito 2.3.0.
+     * If you want to ignore stubs for verification, see {@link #ignoreStubs(Object...)}.
      * <p>
      * A word of <b>warning</b>:
      * Some users who did a lot of classic, expect-run-verify mocking tend to use <code>verifyNoMoreInteractions()</code> very often, even in every test method.
diff --git a/src/main/java/org/mockito/MockitoSession.java b/src/main/java/org/mockito/MockitoSession.java
index 997a4fa..9e820f2 100644
--- a/src/main/java/org/mockito/MockitoSession.java
+++ b/src/main/java/org/mockito/MockitoSession.java
@@ -4,6 +4,7 @@
  */
 package org.mockito;
 
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
 import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
 import org.mockito.junit.MockitoJUnitRunner;
@@ -90,6 +91,20 @@
 public interface MockitoSession {
 
     /**
+     * Changes the strictness of this {@code MockitoSession}.
+     * The new strictness will be applied to operations on mocks and checks performed by {@link #finishMocking()}.
+     * This method is used behind the hood by {@link MockitoRule#strictness(Strictness)} method.
+     * In most healthy tests, this method is not needed.
+     * We keep it for edge cases and when you really need to change strictness in given test method.
+     * For use cases see Javadoc for {@link PotentialStubbingProblem} class.
+     *
+     * @param strictness new strictness for this session.
+     * @since 2.15.0
+     */
+    @Incubating
+    void setStrictness(Strictness strictness);
+
+    /**
      * Must be invoked when the user is done with mocking for given session (test method).
      * It detects unused stubbings and may throw {@link UnnecessaryStubbingException}
      * or emit warnings ({@link MockitoHint}) depending on the {@link Strictness} level.
@@ -105,8 +120,26 @@
      * <p>
      * For example, see javadoc for {@link MockitoSession}.
      *
+     * @see #finishMocking(Throwable)
      * @since 2.7.0
      */
     @Incubating
     void finishMocking();
+
+    /**
+     * Must be invoked when the user is done with mocking for given session (test method).
+     * When a {@linkplain Throwable failure} is specified, certain checks are disabled to avoid
+     * confusion that may arise because there are multiple competing failures. Other than that,
+     * this method behaves exactly like {@link #finishMocking()}.
+     * <p>
+     * This method is intended to be used by framework integrations. When using MockitoSession
+     * directly, most users should rather use {@link #finishMocking()}.
+     * {@link MockitoRule} uses this method behind the hood.
+     *
+     * @param failure the exception that caused the test to fail; passing {@code null} is permitted
+     * @see #finishMocking()
+     * @since 2.15.0
+     */
+    @Incubating
+    void finishMocking(Throwable failure);
 }
diff --git a/src/main/java/org/mockito/creation/instance/InstantiationException.java b/src/main/java/org/mockito/creation/instance/InstantiationException.java
new file mode 100644
index 0000000..1cfbaba
--- /dev/null
+++ b/src/main/java/org/mockito/creation/instance/InstantiationException.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.creation.instance;
+
+import org.mockito.exceptions.base.MockitoException;
+
+/**
+ * Exception generated when {@link Instantiator#newInstance(Class)} failed.
+ *
+ * @since 2.15.4
+ */
+public class InstantiationException extends MockitoException {
+
+    /**
+     * @since 2.15.4
+     */
+    public InstantiationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/src/main/java/org/mockito/creation/instance/Instantiator.java b/src/main/java/org/mockito/creation/instance/Instantiator.java
new file mode 100644
index 0000000..9ce37b5
--- /dev/null
+++ b/src/main/java/org/mockito/creation/instance/Instantiator.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.creation.instance;
+
+/**
+ * Provides instances of classes.
+ * See more information about Mockito plugin {@link org.mockito.plugins.InstantiatorProvider2}
+ *
+ * @since 2.15.4
+ */
+public interface Instantiator {
+
+    /**
+     * Creates instance of given class
+     *
+     * @since 2.15.4
+     */
+    <T> T newInstance(Class<T> cls) throws InstantiationException;
+
+}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
index 983e066..f80e7c4 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
@@ -4,8 +4,10 @@
  */
 package org.mockito.internal.configuration.plugins;
 
+import org.mockito.internal.creation.instance.InstantiatorProvider2Adapter;
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MockMaker;
 import org.mockito.plugins.MockitoPlugins;
 import org.mockito.plugins.PluginSwitch;
@@ -24,15 +26,22 @@
         DEFAULT_PLUGINS.put(PluginSwitch.class.getName(), DefaultPluginSwitch.class.getName());
         DEFAULT_PLUGINS.put(MockMaker.class.getName(), "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker");
         DEFAULT_PLUGINS.put(StackTraceCleanerProvider.class.getName(), "org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleanerProvider");
-        DEFAULT_PLUGINS.put(InstantiatorProvider.class.getName(), "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
+        DEFAULT_PLUGINS.put(InstantiatorProvider2.class.getName(), "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
         DEFAULT_PLUGINS.put(AnnotationEngine.class.getName(), "org.mockito.internal.configuration.InjectingAnnotationEngine");
         DEFAULT_PLUGINS.put(INLINE_ALIAS, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
     }
 
     @Override
     public <T> T getDefaultPlugin(Class<T> pluginType) {
-        String className = DEFAULT_PLUGINS.get(pluginType.getName());
-        return create(pluginType, className);
+        if (pluginType == InstantiatorProvider.class) {
+            //the implementation class is not configured via map so that we can reduce duplication
+            //(ensure that we are adapting the currently configured default implementation for InstantiatorProvider2)
+            String className = DEFAULT_PLUGINS.get(InstantiatorProvider2.class.getName());
+            return pluginType.cast(new InstantiatorProvider2Adapter(create(InstantiatorProvider2.class, className)));
+        } else {
+            String className = DEFAULT_PLUGINS.get(pluginType.getName());
+            return create(pluginType, className);
+        }
     }
 
     String getDefaultPluginClass(String classOrAlias) {
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
new file mode 100644
index 0000000..0e28d91
--- /dev/null
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import org.mockito.internal.util.collections.Iterables;
+import org.mockito.plugins.PluginSwitch;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Enumeration;
+
+class PluginInitializer {
+
+    private final PluginSwitch pluginSwitch;
+    private final String alias;
+    private final DefaultMockitoPlugins plugins;
+
+    PluginInitializer(PluginSwitch pluginSwitch, String alias, DefaultMockitoPlugins plugins) {
+        this.pluginSwitch = pluginSwitch;
+        this.alias = alias;
+        this.plugins = plugins;
+    }
+
+    /**
+     * Equivalent to {@link java.util.ServiceLoader#load} but without requiring
+     * Java 6 / Android 2.3 (Gingerbread).
+     */
+    public <T> T loadImpl(Class<T> service) {
+        ClassLoader loader = Thread.currentThread().getContextClassLoader();
+        if (loader == null) {
+            loader = ClassLoader.getSystemClassLoader();
+        }
+        Enumeration<URL> resources;
+        try {
+            resources = loader.getResources("mockito-extensions/" + service.getName());
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to load " + service, e);
+        }
+
+        try {
+            String classOrAlias = new PluginFinder(pluginSwitch).findPluginClass(Iterables.toIterable(resources));
+            if (classOrAlias != null) {
+                if (classOrAlias.equals(alias)) {
+                    classOrAlias = plugins.getDefaultPluginClass(alias);
+                }
+                Class<?> pluginClass = loader.loadClass(classOrAlias);
+                Object plugin = pluginClass.newInstance();
+                return service.cast(plugin);
+            }
+            return null;
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                "Failed to load " + service + " implementation declared in " + resources, e);
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
index 0132dca..a230d0c 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
@@ -4,26 +4,24 @@
  */
 package org.mockito.internal.configuration.plugins;
 
-import org.mockito.internal.util.collections.Iterables;
 import org.mockito.plugins.PluginSwitch;
 
-import java.io.IOException;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
-import java.net.URL;
-import java.util.Enumeration;
 
 class PluginLoader {
 
-    private final DefaultMockitoPlugins plugins = new DefaultMockitoPlugins();
+    private final DefaultMockitoPlugins plugins;
+    private final PluginInitializer initializer;
 
-    private final PluginSwitch pluginSwitch;
+    PluginLoader(DefaultMockitoPlugins plugins, PluginInitializer initializer) {
+        this.plugins = plugins;
+        this.initializer = initializer;
+    }
 
-    private String alias;
-
-    public PluginLoader(PluginSwitch pluginSwitch) {
-        this.pluginSwitch = pluginSwitch;
+    PluginLoader(PluginSwitch pluginSwitch) {
+        this(new DefaultMockitoPlugins(), new PluginInitializer(pluginSwitch, null, new DefaultMockitoPlugins()));
     }
 
     /**
@@ -34,9 +32,8 @@
      * the alias can be used as a convenience name for a known plugin.
      */
     @Deprecated
-    PluginLoader withAlias(String name) {
-        alias = name;
-        return this;
+    PluginLoader(PluginSwitch pluginSwitch, String alias) {
+        this(new DefaultMockitoPlugins(), new PluginInitializer(pluginSwitch, alias, new DefaultMockitoPlugins()));
     }
 
     /**
@@ -44,55 +41,39 @@
      */
     @SuppressWarnings("unchecked")
     <T> T loadPlugin(final Class<T> pluginType) {
-        try {
-            T plugin = loadImpl(pluginType);
-            if (plugin != null) {
-                return plugin;
-            }
-
-            return plugins.getDefaultPlugin(pluginType);
-        } catch (final Throwable t) {
-            return (T) Proxy.newProxyInstance(pluginType.getClassLoader(),
-                    new Class<?>[]{pluginType},
-                    new InvocationHandler() {
-                        @Override
-                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-                            throw new IllegalStateException("Could not initialize plugin: " + pluginType, t);
-                        }
-                    });
-        }
+        return (T) loadPlugin(pluginType, null);
     }
 
     /**
-     * Equivalent to {@link java.util.ServiceLoader#load} but without requiring
-     * Java 6 / Android 2.3 (Gingerbread).
+     * 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}
      */
-    private <T> T loadImpl(Class<T> service) {
-        ClassLoader loader = Thread.currentThread().getContextClassLoader();
-        if (loader == null) {
-            loader = ClassLoader.getSystemClassLoader();
-        }
-        Enumeration<URL> resources;
+    @SuppressWarnings("unchecked")
+    <PreferredType, AlternateType> Object loadPlugin(final Class<PreferredType> preferredPluginType, final Class<AlternateType> alternatePluginType) {
         try {
-            resources = loader.getResources("mockito-extensions/" + service.getName());
-        } catch (IOException e) {
-            throw new IllegalStateException("Failed to load " + service, e);
-        }
-
-        try {
-            String classOrAlias = new PluginFinder(pluginSwitch).findPluginClass(Iterables.toIterable(resources));
-            if (classOrAlias != null) {
-                if (classOrAlias.equals(alias)) {
-                    classOrAlias = plugins.getDefaultPluginClass(alias);
+            PreferredType preferredPlugin = initializer.loadImpl(preferredPluginType);
+            if (preferredPlugin != null) {
+                return preferredPlugin;
+            } else if (alternatePluginType != null) {
+                AlternateType alternatePlugin = initializer.loadImpl(alternatePluginType);
+                if (alternatePlugin != null) {
+                    return alternatePlugin;
                 }
-                Class<?> pluginClass = loader.loadClass(classOrAlias);
-                Object plugin = pluginClass.newInstance();
-                return service.cast(plugin);
             }
-            return null;
-        } catch (Exception e) {
-            throw new IllegalStateException(
-                    "Failed to load " + service + " implementation declared in " + resources, e);
+
+            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);
+                    }
+                });
         }
     }
 }
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
index d75242c..02e5d66 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
@@ -4,8 +4,10 @@
  */
 package org.mockito.internal.configuration.plugins;
 
+import org.mockito.internal.creation.instance.InstantiatorProviderAdapter;
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MockMaker;
 import org.mockito.plugins.PluginSwitch;
 import org.mockito.plugins.StackTraceCleanerProvider;
@@ -15,19 +17,26 @@
     private final PluginSwitch pluginSwitch = new PluginLoader(new DefaultPluginSwitch())
             .loadPlugin(PluginSwitch.class);
 
-    private final MockMaker mockMaker = new PluginLoader(pluginSwitch)
-            .withAlias(DefaultMockitoPlugins.INLINE_ALIAS)
+    private final MockMaker mockMaker = new PluginLoader(pluginSwitch, DefaultMockitoPlugins.INLINE_ALIAS)
             .loadPlugin(MockMaker.class);
 
     private final StackTraceCleanerProvider stackTraceCleanerProvider = new PluginLoader(pluginSwitch)
             .loadPlugin(StackTraceCleanerProvider.class);
 
-    private final InstantiatorProvider instantiatorProvider = new PluginLoader(pluginSwitch)
-            .loadPlugin(InstantiatorProvider.class);
+    private final InstantiatorProvider2 instantiatorProvider;
 
     private AnnotationEngine annotationEngine = new PluginLoader(pluginSwitch)
             .loadPlugin(AnnotationEngine.class);
 
+    PluginRegistry() {
+        Object impl = new PluginLoader(pluginSwitch).loadPlugin(InstantiatorProvider2.class, InstantiatorProvider.class);
+        if (impl instanceof InstantiatorProvider) {
+            instantiatorProvider = new InstantiatorProviderAdapter((InstantiatorProvider) impl);
+        } else {
+            instantiatorProvider = (InstantiatorProvider2) impl;
+        }
+    }
+
     /**
      * The implementation of the stack trace cleaner
      */
@@ -50,10 +59,11 @@
      * Returns the instantiator provider available for the current runtime.
      *
      * <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
-     * {@link org.mockito.plugins.InstantiatorProvider} extension exists or is visible in the current classpath.</p>
+     * {@link org.mockito.plugins.InstantiatorProvider2} extension exists or is visible in the
+     * current classpath.</p>
      */
-    InstantiatorProvider getInstantiatorProvider() {
-      return instantiatorProvider;
+    InstantiatorProvider2 getInstantiatorProvider() {
+        return instantiatorProvider;
     }
 
     /**
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
index 2c214c2..f65fe89 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
@@ -5,7 +5,7 @@
 package org.mockito.internal.configuration.plugins;
 
 import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MockMaker;
 import org.mockito.plugins.MockitoPlugins;
 import org.mockito.plugins.StackTraceCleanerProvider;
@@ -38,9 +38,10 @@
      * Returns the instantiator provider available for the current runtime.
      *
      * <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
-     * {@link org.mockito.plugins.InstantiatorProvider} extension exists or is visible in the current classpath.</p>
+     * {@link org.mockito.plugins.InstantiatorProvider2} extension exists or is visible in the
+     * current classpath.</p>
      */
-    public static InstantiatorProvider getInstantiatorProvider() {
+    public static InstantiatorProvider2 getInstantiatorProvider() {
       return registry.getInstantiatorProvider();
     }
 
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
index 50d7851..42f10ce 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
@@ -9,7 +9,7 @@
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.base.MockitoInitializationException;
 import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.instance.Instantiator;
+import org.mockito.creation.instance.Instantiator;
 import org.mockito.internal.util.Platform;
 import org.mockito.internal.util.concurrent.WeakConcurrentMap;
 import org.mockito.invocation.MockHandler;
@@ -189,7 +189,7 @@
                 ((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);
             }
             return instance;
-        } catch (org.mockito.internal.creation.instance.InstantiationException e) {
+        } catch (org.mockito.creation.instance.InstantiationException e) {
             throw new MockitoException("Unable to create mock instance of type '" + type.getSimpleName() + "'", e);
         }
     }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
index 7d9f347..f39a1a2 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
@@ -16,6 +16,8 @@
 import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
 import org.mockito.internal.invocation.RealMethod;
 import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.invocation.mockref.MockReference;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
 import org.mockito.internal.util.concurrent.WeakConcurrentMap;
 
 import java.io.IOException;
@@ -107,18 +109,20 @@
         return new ReturnValueWrapper(interceptor.doIntercept(instance,
                 origin,
                 arguments,
-            realMethod,
+                realMethod,
                 new LocationImpl(t)));
     }
 
     @Override
     public boolean isMock(Object instance) {
-        return interceptors.containsKey(instance);
+        // We need to exclude 'interceptors.target' explicitly to avoid a recursive check on whether
+        // the map is a mock object what requires reading from the map.
+        return instance != interceptors.target && interceptors.containsKey(instance);
     }
 
     @Override
     public boolean isMocked(Object instance) {
-        return !selfCallInfo.isSelfInvocation(instance) && isMock(instance);
+        return selfCallInfo.checkSuperCall(instance) && isMock(instance);
     }
 
     @Override
@@ -139,14 +143,14 @@
 
         private final Method origin;
 
-        private final Object instance;
+        private final MockWeakReference<Object> instanceRef;
 
         private final Object[] arguments;
 
         private RealMethodCall(SelfCallInfo selfCallInfo, Method origin, Object instance, Object[] arguments) {
             this.selfCallInfo = selfCallInfo;
             this.origin = origin;
-            this.instance = instance;
+            this.instanceRef = new MockWeakReference<Object>(instance);
             this.arguments = arguments;
         }
 
@@ -160,12 +164,8 @@
             if (!Modifier.isPublic(origin.getDeclaringClass().getModifiers() & origin.getModifiers())) {
                 origin.setAccessible(true);
             }
-            Object previous = selfCallInfo.replace(instance);
-            try {
-                return tryInvoke(origin, instance, arguments);
-            } finally {
-                selfCallInfo.set(previous);
-            }
+            selfCallInfo.set(instanceRef.get());
+            return tryInvoke(origin, instanceRef.get(), arguments);
         }
 
     }
@@ -176,14 +176,14 @@
 
         private final SerializableMethod origin;
 
-        private final Object instance;
+        private final MockReference<Object> instanceRef;
 
         private final Object[] arguments;
 
         private SerializableRealMethodCall(String identifier, Method origin, Object instance, Object[] arguments) {
             this.origin = new SerializableMethod(origin);
             this.identifier = identifier;
-            this.instance = instance;
+            this.instanceRef = new MockWeakReference<Object>(instance);
             this.arguments = arguments;
         }
 
@@ -198,13 +198,13 @@
             if (!Modifier.isPublic(method.getDeclaringClass().getModifiers() & method.getModifiers())) {
                 method.setAccessible(true);
             }
-            MockMethodDispatcher mockMethodDispatcher = MockMethodDispatcher.get(identifier, instance);
+            MockMethodDispatcher mockMethodDispatcher = MockMethodDispatcher.get(identifier, instanceRef.get());
             if (!(mockMethodDispatcher instanceof MockMethodAdvice)) {
                 throw new MockitoException("Unexpected dispatcher for advice-based super call");
             }
-            Object previous = ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.replace(instance);
+            Object previous = ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.replace(instanceRef.get());
             try {
-                return tryInvoke(method, instance, arguments);
+                return tryInvoke(method, instanceRef.get(), arguments);
             } finally {
                 ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.set(previous);
             }
@@ -252,14 +252,19 @@
 
     private static class SelfCallInfo extends ThreadLocal<Object> {
 
-        Object replace(Object instance) {
+        Object replace(Object value) {
             Object current = get();
-            set(instance);
+            set(value);
             return current;
         }
 
-        boolean isSelfInvocation(Object instance) {
-            return get() == instance;
+        boolean checkSuperCall(Object value) {
+            if (value == get()) {
+                set(null);
+                return false;
+            } else {
+                return true;
+            }
         }
     }
 
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
index 7c2dec8..9066927 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
@@ -13,12 +13,8 @@
 import net.bytebuddy.implementation.bind.annotation.StubValue;
 import net.bytebuddy.implementation.bind.annotation.SuperCall;
 import net.bytebuddy.implementation.bind.annotation.This;
-import org.mockito.internal.creation.DelegatingMethod;
 import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.invocation.MockitoMethod;
 import org.mockito.internal.invocation.RealMethod;
-import org.mockito.internal.invocation.SerializableMethod;
-import org.mockito.internal.progress.SequenceNumber;
 import org.mockito.invocation.Location;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
@@ -28,6 +24,8 @@
 import java.lang.reflect.Method;
 import java.util.concurrent.Callable;
 
+import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
+
 public class MockMethodInterceptor implements Serializable {
 
     private static final long serialVersionUID = 7152947254057253027L;
@@ -65,29 +63,6 @@
         return handler.handle(createInvocation(mock, invokedMethod, arguments, realMethod, mockCreationSettings, location));
     }
 
-    public static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod, MockCreationSettings settings, Location location) {
-        return new InterceptedInvocation(
-            mock,
-            createMockitoMethod(invokedMethod, settings),
-            arguments,
-            realMethod,
-            location,
-            SequenceNumber.next()
-        );
-    }
-
-    public static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod, MockCreationSettings settings) {
-        return createInvocation(mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
-    }
-
-    private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
-        if (settings.isSerializable()) {
-            return new SerializableMethod(method);
-        } else {
-            return new DelegatingMethod(method);
-        }
-    }
-
     public MockHandler getMockHandler() {
         return handler;
     }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
index e9a3ddf..79e89f2 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
@@ -6,7 +6,7 @@
 
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.instance.Instantiator;
+import org.mockito.creation.instance.Instantiator;
 import org.mockito.internal.util.Platform;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
@@ -60,7 +60,7 @@
                     "You might experience classloading issues, please ask the mockito mailing-list.",
                     ""
             ), cce);
-        } catch (org.mockito.internal.creation.instance.InstantiationException e) {
+        } catch (org.mockito.creation.instance.InstantiationException e) {
             throw new MockitoException("Unable to create mock instance of type '" + mockedProxyType.getSuperclass().getSimpleName() + "'", e);
         }
     }
diff --git a/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java b/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
index edf47c9..688526b 100644
--- a/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
+++ b/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
@@ -10,6 +10,8 @@
 import java.util.LinkedList;
 import java.util.List;
 
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.creation.instance.InstantiationException;
 import org.mockito.internal.util.Primitives;
 import org.mockito.internal.util.reflection.AccessibilityChanger;
 
diff --git a/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java b/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
index 22d06d1..9c414f3 100644
--- a/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
+++ b/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
@@ -4,10 +4,11 @@
  */
 package org.mockito.internal.creation.instance;
 
+import org.mockito.creation.instance.Instantiator;
 import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
 
-public class DefaultInstantiatorProvider implements InstantiatorProvider {
+public class DefaultInstantiatorProvider implements InstantiatorProvider2 {
 
     private final static Instantiator INSTANCE = new ObjenesisInstantiator();
 
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java b/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java
index c0151f1..86b5463 100644
--- a/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java
+++ b/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java
@@ -6,6 +6,14 @@
 
 import org.mockito.exceptions.base.MockitoException;
 
+/**
+ * @deprecated since 2.15.4 because this internal class was leaking from the public API.
+ * For information why deprecated, see {@link org.mockito.plugins.InstantiatorProvider2}.
+ * Use {@link org.mockito.creation.instance.Instantiator} and {@link org.mockito.creation.instance.InstantiationException} types instead.
+ * <p>
+ * Exception generated when {@link Instantiator#newInstance(Class)} failed.
+ */
+@Deprecated
 public class InstantiationException extends MockitoException {
 
     public InstantiationException(String message, Throwable cause) {
diff --git a/src/main/java/org/mockito/internal/creation/instance/Instantiator.java b/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
index b1ee67d..85b6b3d 100644
--- a/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
+++ b/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
@@ -5,8 +5,13 @@
 package org.mockito.internal.creation.instance;
 
 /**
+ * @deprecated since 2.15.4 because this internal class was leaking from the public API.
+ * For more information why deprecated, see {@link org.mockito.plugins.InstantiatorProvider2}.
+ * Use {@link org.mockito.creation.instance.Instantiator} instead.
+ * <p>
  * Provides instances of classes.
  */
+@Deprecated
 public interface Instantiator {
 
     /**
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
new file mode 100644
index 0000000..a1ab5d5
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.instance;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
+
+/**
+ * Adapts new public API {@link InstantiatorProvider2} onto old, deprecated API {@link InstantiatorProvider}
+ */
+public class InstantiatorProvider2Adapter implements InstantiatorProvider {
+    private final InstantiatorProvider2 provider;
+
+    public InstantiatorProvider2Adapter(InstantiatorProvider2 provider) {
+        this.provider = provider;
+    }
+
+    @Override
+    public Instantiator getInstantiator(final MockCreationSettings<?> settings) {
+        return new Instantiator() {
+            @Override
+            public <T> T newInstance(Class<T> cls) throws InstantiationException {
+                try {
+                    return provider.getInstantiator(settings).newInstance(cls);
+                } catch (org.mockito.creation.instance.InstantiationException e) {
+                    throw new InstantiationException(e.getMessage(), e.getCause());
+                }
+            }
+        };
+    }
+}
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
new file mode 100644
index 0000000..c807925
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.instance;
+
+import org.mockito.creation.instance.InstantiationException;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
+
+/**
+ * Adapts old, deprecated {@link InstantiatorProvider} onto a new public {@link InstantiatorProvider2} API.
+ */
+public class InstantiatorProviderAdapter implements InstantiatorProvider2 {
+    private final InstantiatorProvider provider;
+
+    public InstantiatorProviderAdapter(InstantiatorProvider provider) {
+        this.provider = provider;
+    }
+
+    @Override
+    public Instantiator getInstantiator(final MockCreationSettings<?> settings) {
+        return new Instantiator() {
+            @Override
+            public <T> T newInstance(Class<T> cls) throws InstantiationException {
+                try {
+                    return provider.getInstantiator(settings).newInstance(cls);
+                } catch (org.mockito.internal.creation.instance.InstantiationException e) {
+                    throw new InstantiationException(e.getMessage(), e.getCause());
+                }
+            }
+        };
+    }
+}
diff --git a/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java b/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
index a0f0980..7e41f68 100644
--- a/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
+++ b/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
@@ -4,6 +4,7 @@
  */
 package org.mockito.internal.creation.instance;
 
+import org.mockito.creation.instance.Instantiator;
 import org.mockito.internal.configuration.GlobalConfiguration;
 import org.objenesis.ObjenesisStd;
 
diff --git a/src/main/java/org/mockito/internal/debugging/LocationImpl.java b/src/main/java/org/mockito/internal/debugging/LocationImpl.java
index ce3de04..8561b62 100644
--- a/src/main/java/org/mockito/internal/debugging/LocationImpl.java
+++ b/src/main/java/org/mockito/internal/debugging/LocationImpl.java
@@ -11,11 +11,14 @@
 public class LocationImpl implements Location, Serializable {
 
     private static final long serialVersionUID = -9054861157390980624L;
+    //Limit the amount of objects being created, as this class is heavily instantiated:
+    private static final StackTraceFilter defaultStackTraceFilter = new StackTraceFilter();
+
     private final Throwable stackTraceHolder;
     private final StackTraceFilter stackTraceFilter;
 
     public LocationImpl() {
-        this(new StackTraceFilter());
+        this(defaultStackTraceFilter);
     }
 
     public LocationImpl(StackTraceFilter stackTraceFilter) {
@@ -23,7 +26,7 @@
     }
 
     public LocationImpl(Throwable stackTraceHolder) {
-        this(new StackTraceFilter(), stackTraceHolder);
+        this(defaultStackTraceFilter, stackTraceHolder);
     }
 
     private LocationImpl(StackTraceFilter stackTraceFilter, Throwable stackTraceHolder) {
diff --git a/src/main/java/org/mockito/internal/exceptions/MockitoLimitations.java b/src/main/java/org/mockito/internal/exceptions/MockitoLimitations.java
deleted file mode 100644
index c8edc79..0000000
--- a/src/main/java/org/mockito/internal/exceptions/MockitoLimitations.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.exceptions;
-
-public class MockitoLimitations {
-
-    public final static String NON_PUBLIC_PARENT = "Mocking methods declared on non-public parent classes is not supported.";
-
-}
diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java
index cee97fd..57094c0 100644
--- a/src/main/java/org/mockito/internal/exceptions/Reporter.java
+++ b/src/main/java/org/mockito/internal/exceptions/Reporter.java
@@ -51,6 +51,8 @@
  */
 public class Reporter {
 
+    private final static String NON_PUBLIC_PARENT = "Mocking methods declared on non-public parent classes is not supported.";
+
     private Reporter() {
     }
 
@@ -108,7 +110,7 @@
                 "Also, this error might show up because:",
                 "1. you stub either of: final/private/equals()/hashCode() methods.",
                 "   Those methods *cannot* be stubbed/verified.",
-                "   " + MockitoLimitations.NON_PUBLIC_PARENT,
+                "   " + NON_PUBLIC_PARENT,
                 "2. inside when() you don't call method on mock but on some other object.",
                 ""
         ));
@@ -124,7 +126,7 @@
                 "",
                 "Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.",
                 "Those methods *cannot* be stubbed/verified.",
-                MockitoLimitations.NON_PUBLIC_PARENT,
+                NON_PUBLIC_PARENT,
                 ""
         ));
     }
@@ -464,7 +466,7 @@
                 "2. Somewhere in your test you are stubbing *final methods*. Sorry, Mockito does not verify/stub final methods.",
                 "3. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
                 "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
-                "4. " + MockitoLimitations.NON_PUBLIC_PARENT,
+                "4. " + NON_PUBLIC_PARENT,
                 ""
         ));
     }
@@ -531,7 +533,7 @@
                 "",
                 "Also, this error might show up because you use argument matchers with methods that cannot be mocked.",
                 "Following methods *cannot* be stubbed/verified: final/private/equals()/hashCode().",
-                MockitoLimitations.NON_PUBLIC_PARENT,
+                NON_PUBLIC_PARENT,
                 ""
         ));
     }
@@ -857,7 +859,7 @@
                 heading,
                 "Clean & maintainable test code requires zero unnecessary code.",
                 "Following stubbings are unnecessary (click to navigate to relevant line of code):" + stubbings,
-                "Please remove unnecessary stubbings or use 'silent' option. More info: javadoc for UnnecessaryStubbingException class."
+                "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."
         ));
     }
 
@@ -888,7 +890,7 @@
                 "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API",
                 "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.",
                 "  - stubbed method is intentionally invoked with different arguments by code under test",
-                "    Please use 'default' or 'silent' JUnit Rule.",
+                "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).",
                 "For more information see javadoc for PotentialStubbingProblem class."));
     }
 
diff --git a/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java b/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
index 40b24bb..c900bf7 100644
--- a/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
+++ b/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.framework;
@@ -14,13 +14,17 @@
 import org.mockito.internal.util.MockitoLogger;
 import org.mockito.quality.Strictness;
 
+import java.util.List;
+
 public class DefaultMockitoSession implements MockitoSession {
 
-    private final Object testClassInstance;
+    private final List<Object> testClassInstances;
+    private final String name;
     private final UniversalTestListener listener;
 
-    public DefaultMockitoSession(Object testClassInstance, Strictness strictness, MockitoLogger logger) {
-        this.testClassInstance = testClassInstance;
+    public DefaultMockitoSession(List<Object> testClassInstances, String name, Strictness strictness, MockitoLogger logger) {
+        this.testClassInstances = testClassInstances;
+        this.name = name;
         listener = new UniversalTestListener(strictness, logger);
         try {
             //So that the listener can capture mock creation events
@@ -28,10 +32,23 @@
         } catch (RedundantListenerException e) {
             Reporter.unfinishedMockingSession();
         }
-        MockitoAnnotations.initMocks(testClassInstance);
+        for (Object testClassInstance : testClassInstances) {
+            MockitoAnnotations.initMocks(testClassInstance);
+        }
     }
 
+    @Override
+    public void setStrictness(Strictness strictness) {
+        listener.setStrictness(strictness);
+    }
+
+    @Override
     public void finishMocking() {
+        finishMocking(null);
+    }
+
+    @Override
+    public void finishMocking(final Throwable failure) {
         //Cleaning up the state, we no longer need the listener hooked up
         //The listener implements MockCreationListener and at this point
         //we no longer need to listen on mock creation events. We are wrapping up the session
@@ -39,18 +56,20 @@
 
         //Emit test finished event so that validation such as strict stubbing can take place
         listener.testFinished(new TestFinishedEvent() {
+            @Override
             public Throwable getFailure() {
-                return null;
+                return failure;
             }
-            public Object getTestClassInstance() {
-                return testClassInstance;
-            }
-            public String getTestMethodName() {
-                return null;
+            @Override
+            public String getTestName() {
+                return name;
             }
         });
 
-        //Finally, validate user's misuse of Mockito framework.
-        Mockito.validateMockitoUsage();
+        //Validate only when there is no test failure to avoid reporting multiple problems
+        if (failure == null) {
+            //Finally, validate user's misuse of Mockito framework.
+            Mockito.validateMockitoUsage();
+        }
     }
 }
diff --git a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java b/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
index 38f18e9..57a9d43 100644
--- a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
+++ b/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
@@ -8,7 +8,6 @@
 import org.mockito.internal.invocation.InvocationMatcher;
 import org.mockito.internal.invocation.MatchersBinder;
 import org.mockito.internal.listeners.StubbingLookupListener;
-import org.mockito.invocation.InvocationContainer;
 import org.mockito.internal.stubbing.InvocationContainerImpl;
 import org.mockito.internal.stubbing.OngoingStubbingImpl;
 import org.mockito.internal.stubbing.StubbedInvocationMatcher;
@@ -16,6 +15,7 @@
 import org.mockito.internal.verification.MockAwareVerificationMode;
 import org.mockito.internal.verification.VerificationDataImpl;
 import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.verification.VerificationMode;
@@ -92,7 +92,14 @@
 
         if (stubbing != null) {
             stubbing.captureArgumentsFrom(invocation);
-            return stubbing.answer(invocation);
+
+            try {
+                return stubbing.answer(invocation);
+            } finally {
+                //Needed so that we correctly isolate stubbings in some scenarios
+                //see MockitoStubbedCallInAnswerTest or issue #1279
+                mockingProgress().reportOngoingStubbing(ongoingStubbing);
+            }
         } else {
             Object ret = mockSettings.getDefaultAnswer().answer(invocation);
             DefaultAnswerValidator.validateReturnValueFor(invocation, ret);
diff --git a/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java b/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
index af8fd3d..d08f6b1 100644
--- a/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
+++ b/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
@@ -4,9 +4,13 @@
  */
 package org.mockito.internal.invocation;
 
-import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor;
+import org.mockito.internal.creation.DelegatingMethod;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.progress.SequenceNumber;
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.InvocationFactory;
+import org.mockito.invocation.Location;
 import org.mockito.mock.MockCreationSettings;
 
 import java.lang.reflect.Method;
@@ -14,8 +18,41 @@
 
 public class DefaultInvocationFactory implements InvocationFactory {
 
-    public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, Callable realMethod, Object... args) {
-        RealMethod.FromCallable superMethod = new RealMethod.FromCallable(realMethod);
-        return MockMethodInterceptor.createInvocation(target, method, args, superMethod, settings);
+    public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, final Callable realMethod, Object... args) {
+        RealMethod superMethod = new RealMethod.FromCallable(realMethod);
+        return createInvocation(target, settings, method, superMethod, args);
+    }
+
+    public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethodBehavior realMethod, Object... args) {
+        RealMethod superMethod = new RealMethod.FromBehavior(realMethod);
+        return createInvocation(target, settings, method, superMethod, args);
+    }
+
+    private Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethod superMethod, Object[] args) {
+        return createInvocation(target, method, args, superMethod, settings);
+    }
+
+    public static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod, MockCreationSettings settings, Location location) {
+        return new InterceptedInvocation(
+            new MockWeakReference<Object>(mock),
+            createMockitoMethod(invokedMethod, settings),
+            arguments,
+            realMethod,
+            location,
+            SequenceNumber.next()
+        );
+    }
+
+    private static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[]
+        arguments, RealMethod realMethod, MockCreationSettings settings) {
+        return createInvocation(mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
+    }
+
+    private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
+        if (settings.isSerializable()) {
+            return new SerializableMethod(method);
+        } else {
+            return new DelegatingMethod(method);
+        }
     }
 }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java b/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
similarity index 91%
rename from src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java
rename to src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
index 9c7b49e..b9cf072 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java
+++ b/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
@@ -2,12 +2,10 @@
  * Copyright (c) 2016 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
-package org.mockito.internal.creation.bytebuddy;
+package org.mockito.internal.invocation;
 
+import org.mockito.internal.invocation.mockref.MockReference;
 import org.mockito.internal.exceptions.VerificationAwareInvocation;
-import org.mockito.internal.invocation.ArgumentsProcessor;
-import org.mockito.internal.invocation.MockitoMethod;
-import org.mockito.internal.invocation.RealMethod;
 import org.mockito.internal.reporting.PrintSettings;
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.Location;
@@ -22,7 +20,7 @@
 
     private static final long serialVersionUID = 475027563923510472L;
 
-    private final Object mock;
+    private final MockReference<Object> mockRef;
     private final MockitoMethod mockitoMethod;
     private final Object[] arguments, rawArguments;
     private final RealMethod realMethod;
@@ -35,13 +33,13 @@
     private boolean isIgnoredForVerification;
     private StubInfo stubInfo;
 
-    public InterceptedInvocation(Object mock,
+    public InterceptedInvocation(MockReference<Object> mockRef,
                                  MockitoMethod mockitoMethod,
                                  Object[] arguments,
                                  RealMethod realMethod,
                                  Location location,
                                  int sequenceNumber) {
-        this.mock = mock;
+        this.mockRef = mockRef;
         this.mockitoMethod = mockitoMethod;
         this.arguments = ArgumentsProcessor.expandArgs(mockitoMethod, arguments);
         this.rawArguments = arguments;
@@ -102,7 +100,7 @@
 
     @Override
     public Object getMock() {
-        return mock;
+        return mockRef.get();
     }
 
     @Override
@@ -141,7 +139,7 @@
             return false;
         }
         InterceptedInvocation other = (InterceptedInvocation) o;
-        return this.mock.equals(other.mock)
+        return this.mockRef.get().equals(other.mockRef.get())
                 && this.mockitoMethod.equals(other.mockitoMethod)
                 && this.equalArguments(other.arguments);
     }
diff --git a/src/main/java/org/mockito/internal/invocation/RealMethod.java b/src/main/java/org/mockito/internal/invocation/RealMethod.java
index cd74d3c..b7c8c17 100644
--- a/src/main/java/org/mockito/internal/invocation/RealMethod.java
+++ b/src/main/java/org/mockito/internal/invocation/RealMethod.java
@@ -5,6 +5,7 @@
 package org.mockito.internal.invocation;
 
 import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.mockito.invocation.InvocationFactory;
 import org.mockito.invocation.InvocationOnMock;
 
 import java.io.Serializable;
@@ -31,14 +32,23 @@
         }
     }
 
-    class FromCallable implements RealMethod {
+    class FromCallable extends FromBehavior implements RealMethod {
+        public FromCallable(final Callable<?> callable) {
+            super(new InvocationFactory.RealMethodBehavior() {
+                @Override
+                public Object call() throws Throwable {
+                    return callable.call();
+                }
+            });
+        }
+    }
 
-        private static final long serialVersionUID = 47957363950483625L;
+    class FromBehavior implements RealMethod {
 
-        private final Callable<?> callable;
+        private final InvocationFactory.RealMethodBehavior<?> behavior;
 
-        public FromCallable(Callable<?> callable) {
-            this.callable = callable;
+        FromBehavior(InvocationFactory.RealMethodBehavior<?> behavior) {
+            this.behavior = behavior;
         }
 
         @Override
@@ -49,7 +59,7 @@
         @Override
         public Object invoke() throws Throwable {
             try {
-                return callable.call();
+                return behavior.call();
             } catch (Throwable t) {
                 new ConditionalStackTraceFilter().filter(t);
                 throw t;
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
new file mode 100644
index 0000000..0dac2ea
--- /dev/null
+++ b/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockito.internal.invocation.mockref;
+
+import java.io.Serializable;
+
+/**
+ * To avoid memory leaks for certain implementations of MockMaker,
+ * we need to use weak mock references internally. See #1313
+ */
+public interface MockReference<T> extends Serializable {
+    T get();
+}
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
new file mode 100644
index 0000000..3b20ee5
--- /dev/null
+++ b/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockito.internal.invocation.mockref;
+
+import java.io.ObjectStreamException;
+
+public class MockStrongReference<T> implements MockReference<T> {
+
+    private final T ref;
+    private final boolean deserializeAsWeakRef;
+
+    public MockStrongReference(T ref, boolean deserializeAsWeakRef) {
+        this.ref = ref;
+        this.deserializeAsWeakRef = deserializeAsWeakRef;
+    }
+
+    @Override
+    public T get() {
+        return ref;
+    }
+
+    private Object readResolve() throws ObjectStreamException {
+        if (deserializeAsWeakRef) {
+            return new MockWeakReference<T>(ref);
+        } else {
+            return this;
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
new file mode 100644
index 0000000..256745b
--- /dev/null
+++ b/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockito.internal.invocation.mockref;
+
+import java.io.ObjectStreamException;
+import java.lang.ref.WeakReference;
+
+/**
+ * A weak reference that is converted into a strong reference when serialized.
+ * See {@link MockReference}.
+ */
+public class MockWeakReference<T> implements MockReference<T> {
+
+    private final WeakReference<T> ref;
+
+    public MockWeakReference(T t) {
+        this.ref = new WeakReference<T>(t);
+    }
+
+    private Object writeReplace() throws ObjectStreamException {
+        return new MockStrongReference<T>(get(), true);
+    }
+
+    @Override
+    public T get() {
+        T ref = this.ref.get();
+
+        if (ref == null) {
+            throw new IllegalStateException("The mock object was garbage collected. " +
+                "This should not happen in normal circumstances when using public API. " +
+                "Typically, the test class keeps strong reference to the mock object " +
+                "and it prevents getting the mock collected. Mockito internally needs " +
+                "to keep weak references to mock objects to avoid memory leaks for " +
+                "certain types of MockMaker implementations. If you see this exception " +
+                "using Mockito public API, please file a bug. For more information see " +
+                "issue #1313.");
+        }
+
+        return ref;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java b/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
index 172868c..c3b348b 100644
--- a/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
+++ b/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.junit;
@@ -15,15 +15,13 @@
         this.testFailure = testFailure;
     }
 
+    @Override
     public Throwable getFailure() {
         return testFailure;
     }
 
-    public Object getTestClassInstance() {
-        return testClassInstance;
-    }
-
-    public String getTestMethodName() {
-        return testMethodName;
+    @Override
+    public String getTestName() {
+        return testClassInstance.getClass().getSimpleName() + "." + testMethodName;
     }
 }
diff --git a/src/main/java/org/mockito/internal/junit/JUnitRule.java b/src/main/java/org/mockito/internal/junit/JUnitRule.java
index 8763354..b825416 100644
--- a/src/main/java/org/mockito/internal/junit/JUnitRule.java
+++ b/src/main/java/org/mockito/internal/junit/JUnitRule.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.junit;
@@ -7,9 +7,10 @@
 import org.junit.runners.model.FrameworkMethod;
 import org.junit.runners.model.Statement;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.quality.Strictness;
+import org.mockito.MockitoSession;
+import org.mockito.internal.session.MockitoSessionLoggerAdapter;
 import org.mockito.internal.util.MockitoLogger;
+import org.mockito.quality.Strictness;
 import org.mockito.junit.MockitoRule;
 
 /**
@@ -18,44 +19,32 @@
 public class JUnitRule implements MockitoRule {
 
     private final MockitoLogger logger;
-    private final UniversalTestListener listener;
+    private Strictness strictness;
+    private MockitoSession session;
 
     /**
-     * @param logger target for the stubbing warnings
      * @param strictness how strict mocking / stubbing is concerned
      */
     public JUnitRule(MockitoLogger logger, Strictness strictness) {
         this.logger = logger;
-        this.listener = new UniversalTestListener(strictness, logger);
+        this.strictness = strictness;
     }
 
 	@Override
 	public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
         return new Statement() {
             public void evaluate() throws Throwable {
-                //Ideally, JUnit rule should use MockitoSession API so that it dogfoods our public API.
-                //See https://github.com/mockito/mockito/issues/898
-                Mockito.framework().addListener(listener);
-                Throwable testFailure;
-                try {
-                    //mock initialization could be part of listeners but to avoid duplication I left it here:
-                    MockitoAnnotations.initMocks(target);
-                    testFailure = evaluateSafely(base);
-                } finally {
-                    Mockito.framework().removeListener(listener);
-                }
-
-                //If the 'testFinished' fails below, we don't see the original failure, thrown later
-                DefaultTestFinishedEvent event = new DefaultTestFinishedEvent(target, method.getName(), testFailure);
-                listener.testFinished(event);
-
+                session = Mockito.mockitoSession()
+                    .name(target.getClass().getSimpleName() + "." + method.getName())
+                    .strictness(strictness)
+                    .logger(new MockitoSessionLoggerAdapter(logger))
+                    .initMocks(target)
+                    .startMocking();
+                Throwable testFailure = evaluateSafely(base);
+                session.finishMocking(testFailure);
                 if (testFailure != null) {
                     throw testFailure;
                 }
-
-                //Validate only when there is no test failure to avoid reporting multiple problems
-                //This could be part of the listener but to avoid duplication I left it here:
-                Mockito.validateMockitoUsage();
             }
 
             private Throwable evaluateSafely(Statement base) {
@@ -70,11 +59,16 @@
     }
 
     public MockitoRule silent() {
-        return new JUnitRule(logger, Strictness.LENIENT);
+        return strictness(Strictness.LENIENT);
     }
 
     public MockitoRule strictness(Strictness strictness) {
-        this.listener.setStrictness(strictness);
+        this.strictness = strictness;
+        // session is null when this method is called during initialization of
+        // the @Rule field of the test class
+        if (session != null) {
+            session.setStrictness(strictness);
+        }
         return this;
     }
 }
diff --git a/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java b/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
index 408c581..26d4e4e 100644
--- a/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
+++ b/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
@@ -1,10 +1,9 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.junit;
 
-import org.mockito.internal.junit.util.TestName;
 import org.mockito.internal.util.MockitoLogger;
 import org.mockito.mock.MockCreationSettings;
 
@@ -30,10 +29,9 @@
         //TODO make it better, it's easy to forget to clean up mocks and we still create new instance of list that nobody will read, it's also duplicated
         mocks = new LinkedList<Object>();
 
-        String testName = TestName.getTestName(event);
         if (event.getFailure() != null) {
             //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users
-            new ArgMismatchFinder().getStubbingArgMismatches(createdMocks).format(testName, logger);
+            new ArgMismatchFinder().getStubbingArgMismatches(createdMocks).format(event.getTestName(), logger);
         }
     }
 
diff --git a/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java b/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
index 18b099a..43b373a 100644
--- a/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
+++ b/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.junit;
@@ -8,8 +8,6 @@
 
     Throwable getFailure();
 
-    Object getTestClassInstance();
-
-    String getTestMethodName();
+    String getTestName();
 
 }
diff --git a/src/main/java/org/mockito/internal/junit/UniversalTestListener.java b/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
index 8db020b..66c9dee 100644
--- a/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
+++ b/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.junit;
@@ -60,14 +60,13 @@
     }
 
     private static void emitWarnings(MockitoLogger logger, TestFinishedEvent event, Collection<Object> mocks) {
-        String testName = event.getTestClassInstance().getClass().getSimpleName() + "." + event.getTestMethodName();
         if (event.getFailure() != null) {
             //print stubbing mismatches only when there is a test failure
             //to avoid false negatives. Give hint only when test fails.
-            new ArgMismatchFinder().getStubbingArgMismatches(mocks).format(testName, logger);
+            new ArgMismatchFinder().getStubbingArgMismatches(mocks).format(event.getTestName(), logger);
         } else {
             //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users
-            new UnusedStubbingsFinder().getUnusedStubbings(mocks).format(testName, logger);
+            new UnusedStubbingsFinder().getUnusedStubbings(mocks).format(event.getTestName(), logger);
         }
     }
 
diff --git a/src/main/java/org/mockito/internal/junit/util/TestName.java b/src/main/java/org/mockito/internal/junit/util/TestName.java
deleted file mode 100644
index 6f09937..0000000
--- a/src/main/java/org/mockito/internal/junit/util/TestName.java
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit.util;
-
-import org.mockito.internal.junit.TestFinishedEvent;
-
-/**
- * Provides test name
- */
-public class TestName {
-
-    public static String getTestName(TestFinishedEvent event) {
-        return event.getTestClassInstance().getClass().getSimpleName() + "." + event.getTestMethodName();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/text/ArrayIterator.java b/src/main/java/org/mockito/internal/matchers/text/ArrayIterator.java
deleted file mode 100644
index 32d3c66..0000000
--- a/src/main/java/org/mockito/internal/matchers/text/ArrayIterator.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers.text;
-
-import java.lang.reflect.Array;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-/**
- * Inspired on hamcrest, internal package class,
- * TODO add specific unit tests instead of relying on higher level unit tests
- */
-class ArrayIterator implements Iterator<Object> {
-
-    private final Object array;
-    private int currentIndex = 0;
-
-    public ArrayIterator(Object array) {
-        if (array == null) {
-            //TODO extract a small utility for null-checking
-            throw new IllegalArgumentException("Expected array instance but got null");
-        }
-        if (!array.getClass().isArray()) {
-            throw new IllegalArgumentException("Expected array but got object of type: "
-                    + array.getClass() + ", the object: " + array.toString());
-        }
-        this.array = array;
-    }
-
-    public boolean hasNext() {
-        return currentIndex < Array.getLength(array);
-    }
-
-    public Object next() {
-        if (!hasNext()) {
-            throw new NoSuchElementException();
-        }
-        return Array.get(array, currentIndex++);
-    }
-
-    public void remove() {
-        throw new UnsupportedOperationException("cannot remove items from an array");
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
index f741cbc..6f5882f 100644
--- a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
+++ b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
@@ -4,6 +4,7 @@
  */
 package org.mockito.internal.matchers.text;
 
+import java.lang.reflect.Array;
 import java.util.Iterator;
 import java.util.Map;
 
@@ -21,7 +22,7 @@
      * Prints given value so that it is neatly readable by humans.
      * Handles explosive toString() implementations.
      */
-    public static String print(Object value) {
+    public static String print(final Object value) {
         if (value == null) {
             return "null";
         }
@@ -50,7 +51,21 @@
             return printMap((Map<?, ?>) value);
         }
         if (value.getClass().isArray()) {
-            return printValues("[", ", ", "]", new ArrayIterator(value));
+            return printValues("[", ", ", "]", new Iterator<Object>() {
+                private int currentIndex = 0;
+
+                public boolean hasNext() {
+                    return currentIndex < Array.getLength(value);
+                }
+
+                public Object next() {
+                    return Array.get(value, currentIndex++);
+                }
+
+                public void remove() {
+                    throw new UnsupportedOperationException("cannot remove items from an array");
+                }
+            });
         }
         if (value instanceof FormattedText) {
             return (((FormattedText) value).getText());
diff --git a/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java b/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
index a0f8c66..2685ddf 100644
--- a/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
+++ b/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
@@ -47,8 +47,8 @@
         };
     }
 
-    public void reportOngoingStubbing(OngoingStubbing iOngoingStubbing) {
-        this.ongoingStubbing = iOngoingStubbing;
+    public void reportOngoingStubbing(OngoingStubbing ongoingStubbing) {
+        this.ongoingStubbing = ongoingStubbing;
     }
 
     public OngoingStubbing<?> pullOngoingStubbing() {
@@ -129,7 +129,7 @@
     }
 
     public String toString() {
-        return  "iOngoingStubbing: " + ongoingStubbing +
+        return  "ongoingStubbing: " + ongoingStubbing +
         ", verificationMode: " + verificationMode +
         ", stubbingInProgress: " + stubbingInProgress;
     }
diff --git a/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java b/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
index 897e613..2f26ff1 100644
--- a/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
+++ b/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.runners;
@@ -16,6 +16,7 @@
 import org.junit.runners.model.Statement;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
+import org.mockito.internal.junit.DefaultTestFinishedEvent;
 import org.mockito.internal.junit.MockitoTestListener;
 import org.mockito.internal.util.Supplier;
 
diff --git a/src/main/java/org/mockito/internal/runners/DefaultTestFinishedEvent.java b/src/main/java/org/mockito/internal/runners/DefaultTestFinishedEvent.java
deleted file mode 100644
index 2eee23f..0000000
--- a/src/main/java/org/mockito/internal/runners/DefaultTestFinishedEvent.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.runners;
-
-import org.mockito.internal.junit.TestFinishedEvent;
-
-class DefaultTestFinishedEvent implements TestFinishedEvent {
-
-    private final Object testClassInstance;
-    private final String testMethodName;
-    private final Throwable failure;
-
-    DefaultTestFinishedEvent(Object testClassInstance, String testMethodName, Throwable failure) {
-        this.testClassInstance = testClassInstance;
-        this.testMethodName = testMethodName;
-        this.failure = failure;
-    }
-
-    @Override
-    public Object getTestClassInstance() {
-        return testClassInstance;
-    }
-
-    @Override
-    public String getTestMethodName() {
-        return testMethodName;
-    }
-
-    @Override
-    public Throwable getFailure() {
-        return failure;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java b/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
index bfd6be8..d9b21e5 100644
--- a/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
+++ b/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.session;
@@ -7,17 +7,44 @@
 import org.mockito.MockitoSession;
 import org.mockito.internal.framework.DefaultMockitoSession;
 import org.mockito.internal.util.ConsoleMockitoLogger;
+import org.mockito.internal.util.MockitoLogger;
 import org.mockito.quality.Strictness;
 import org.mockito.session.MockitoSessionBuilder;
+import org.mockito.session.MockitoSessionLogger;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Collections.emptyList;
 
 public class DefaultMockitoSessionBuilder implements MockitoSessionBuilder {
 
-    private Object testClassInstance;
+    private List<Object> testClassInstances = new ArrayList<Object>();
+    private String name;
     private Strictness strictness;
+    private MockitoSessionLogger logger;
 
     @Override
     public MockitoSessionBuilder initMocks(Object testClassInstance) {
-        this.testClassInstance = testClassInstance;
+        if (testClassInstance != null) {
+            this.testClassInstances.add(testClassInstance);
+        }
+        return this;
+    }
+
+    @Override
+    public MockitoSessionBuilder initMocks(Object... testClassInstances) {
+        if (testClassInstances != null) {
+            for (Object instance : testClassInstances) {
+                initMocks(instance);
+            }
+        }
+        return this;
+    }
+
+    @Override
+    public MockitoSessionBuilder name(String name) {
+        this.name = name;
         return this;
     }
 
@@ -28,10 +55,26 @@
     }
 
     @Override
+    public MockitoSessionBuilder logger(MockitoSessionLogger logger) {
+        this.logger = logger;
+        return this;
+    }
+
+    @Override
     public MockitoSession startMocking() {
         //Configure default values
-        Object effectiveTest = this.testClassInstance == null ? new Object() : this.testClassInstance;
+        List<Object> effectiveTestClassInstances;
+        String effectiveName;
+        if (testClassInstances.isEmpty()) {
+            effectiveTestClassInstances = emptyList();
+            effectiveName = this.name == null ? "<Unnamed Session>" : this.name;
+        } else {
+            effectiveTestClassInstances = new ArrayList<Object>(testClassInstances);
+            Object lastTestClassInstance = testClassInstances.get(testClassInstances.size() - 1);
+            effectiveName = this.name == null ? lastTestClassInstance.getClass().getName() : this.name;
+        }
         Strictness effectiveStrictness = this.strictness == null ? Strictness.STRICT_STUBS : this.strictness;
-        return new DefaultMockitoSession(effectiveTest, effectiveStrictness, new ConsoleMockitoLogger());
+        MockitoLogger logger = this.logger == null ? new ConsoleMockitoLogger() : new MockitoLoggerAdapter(this.logger);
+        return new DefaultMockitoSession(effectiveTestClassInstances, effectiveName, effectiveStrictness, logger);
     }
 }
diff --git a/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java b/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
new file mode 100644
index 0000000..b7329e7
--- /dev/null
+++ b/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.session;
+
+import org.mockito.internal.util.MockitoLogger;
+import org.mockito.session.MockitoSessionLogger;
+
+class MockitoLoggerAdapter implements MockitoLogger {
+
+    private final MockitoSessionLogger logger;
+
+    MockitoLoggerAdapter(MockitoSessionLogger logger) {
+        this.logger = logger;
+    }
+
+    @Override
+    public void log(Object what) {
+        logger.log(String.valueOf(what));
+    }
+}
diff --git a/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java b/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
new file mode 100644
index 0000000..2e8634b
--- /dev/null
+++ b/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.session;
+
+import org.mockito.internal.util.MockitoLogger;
+import org.mockito.session.MockitoSessionLogger;
+
+public class MockitoSessionLoggerAdapter implements MockitoSessionLogger {
+
+    private final MockitoLogger logger;
+
+    public MockitoSessionLoggerAdapter(MockitoLogger logger) {
+        this.logger = logger;
+    }
+
+    @Override
+    public void log(String hint) {
+        logger.log(hint);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
index f88fc03..120320b 100644
--- a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
@@ -4,11 +4,6 @@
  */
 package org.mockito.internal.stubbing;
 
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
-
 import org.mockito.internal.invocation.StubInfoImpl;
 import org.mockito.internal.verification.DefaultRegisteredInvocations;
 import org.mockito.internal.verification.RegisteredInvocations;
@@ -21,6 +16,11 @@
 import org.mockito.stubbing.Stubbing;
 import org.mockito.stubbing.ValidableAnswer;
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
 import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
 
 @SuppressWarnings("unchecked")
@@ -93,10 +93,6 @@
         return null;
     }
 
-    public void addAnswerForVoidMethod(Answer answer) {
-        answersForStubbing.add(answer);
-    }
-
     public void setAnswersForStubbing(List<Answer<?>> answers) {
         answersForStubbing.addAll(answers);
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java b/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
index 7296095..25e8be7 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
@@ -5,7 +5,7 @@
 package org.mockito.internal.stubbing.answers;
 
 import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.instance.Instantiator;
+import org.mockito.creation.instance.Instantiator;
 import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues;
 import org.mockito.internal.util.reflection.LenientCopyTool;
 import org.mockito.invocation.InvocationOnMock;
diff --git a/src/main/java/org/mockito/internal/util/collections/Sets.java b/src/main/java/org/mockito/internal/util/collections/Sets.java
index a5a80f1..f1972e9 100644
--- a/src/main/java/org/mockito/internal/util/collections/Sets.java
+++ b/src/main/java/org/mockito/internal/util/collections/Sets.java
@@ -18,10 +18,6 @@
         return HashCodeAndEqualsSafeSet.of(mocks);
     }
 
-    public static IdentitySet newIdentitySet() {
-        return new IdentitySet();
-    }
-
     public static <T> Set<T> newSet(T ... elements) {
         if (elements == null) {
             throw new IllegalArgumentException("Expected an array of elements (or empty array) but received a null.");
diff --git a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
index c147693..b411a73 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
+++ b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
@@ -26,7 +26,7 @@
 
     private static final AtomicLong ID = new AtomicLong();
 
-    final ConcurrentMap<WeakKey<K>, V> target;
+    public final ConcurrentMap<WeakKey<K>, V> target;
 
     private final Thread thread;
 
diff --git a/src/main/java/org/mockito/invocation/InvocationFactory.java b/src/main/java/org/mockito/invocation/InvocationFactory.java
index 8339642..1803718 100644
--- a/src/main/java/org/mockito/invocation/InvocationFactory.java
+++ b/src/main/java/org/mockito/invocation/InvocationFactory.java
@@ -8,6 +8,7 @@
 import org.mockito.MockitoFramework;
 import org.mockito.mock.MockCreationSettings;
 
+import java.io.Serializable;
 import java.lang.reflect.Method;
 import java.util.concurrent.Callable;
 
@@ -19,7 +20,7 @@
  * <p>
  * Please don't provide your own implementation of {@link Invocation} type.
  * Mockito team needs flexibility to add new methods to this interface if we need to.
- * If you integrate Mockito framework and you need an instance of {@link Invocation}, use {@link #createInvocation(Object, MockCreationSettings, Method, Callable, Object...)}.
+ * If you integrate Mockito framework and you need an instance of {@link Invocation}, use {@link #createInvocation(Object, MockCreationSettings, Method, RealMethodBehavior, Object...)}.
  *
  * @since 2.10.0
  */
@@ -27,6 +28,11 @@
 public interface InvocationFactory {
 
     /**
+     * @deprecated Use {@link #createInvocation(Object, MockCreationSettings, Method, RealMethodBehavior, Object...)} instead.
+     *
+     * Why deprecated? We found use cases where we need to handle Throwable and ensure correct stack trace filtering
+     * (removing Mockito internals from the stack trace). Hence the introduction of {@link RealMethodBehavior}.
+     *
      * Creates instance of an {@link Invocation} object.
      * This method is useful for framework integrators to programmatically simulate method calls on mocks using {@link MockHandler}.
      * It enables advanced framework integrations.
@@ -40,6 +46,32 @@
      * @return invocation instance
      * @since 2.10.0
      */
-    @Incubating
+    @Deprecated
     Invocation createInvocation(Object target, MockCreationSettings settings, Method method, Callable realMethod, Object... args);
+
+    /**
+     * Behavior of the real method.
+     *
+     * @since 2.14.0
+     */
+    interface RealMethodBehavior<R> extends Serializable {
+        R call() throws Throwable;
+    }
+
+    /**
+     * Creates instance of an {@link Invocation} object.
+     * This method is useful for framework integrators to programmatically simulate method calls on mocks using {@link MockHandler}.
+     * It enables advanced framework integrations.
+     *
+     * @param target the mock object the method is invoked on.
+     * @param settings creation settings of the mock object.
+     * @param method java method invoked on mock.
+     * @param realMethod real method behavior. Needed for spying / invoking real behavior on mock objects.
+     * @param args the java method arguments
+     *
+     * @return invocation instance
+     * @since 2.14.0
+     */
+    @Incubating
+    Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethodBehavior realMethod, Object... args);
 }
diff --git a/src/main/java/org/mockito/junit/MockitoJUnitRunner.java b/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
index 2a15587..59bc92b 100644
--- a/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
+++ b/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.junit;
 
-import java.lang.reflect.InvocationTargetException;
 import org.junit.runner.Description;
 import org.junit.runner.Runner;
 import org.junit.runner.manipulation.Filter;
@@ -16,12 +15,14 @@
 import org.mockito.MockitoAnnotations;
 import org.mockito.MockitoSession;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.internal.runners.RunnerFactory;
 import org.mockito.internal.runners.InternalRunner;
+import org.mockito.internal.runners.RunnerFactory;
 import org.mockito.internal.runners.StrictRunner;
 import org.mockito.quality.MockitoHint;
 import org.mockito.quality.Strictness;
 
+import java.lang.reflect.InvocationTargetException;
+
 
 /**
  * Mockito JUnit Runner keeps tests clean and improves debugging experience.
@@ -80,6 +81,7 @@
      * stubbing argument mismatches ({@link MockitoJUnitRunner.StrictStubs})
      * and *does not detect* unused stubbings.
      * The runner remains 'silent' even if incorrect stubbing is present.
+     * It is an equivalent of {@link Strictness#LENIENT}.
      * This was the behavior of Mockito JUnit runner in versions 1.x.
      * Using this implementation of the runner is not recommended.
      * Engineers should care for removing unused stubbings because they are dead code,
diff --git a/src/main/java/org/mockito/plugins/InstantiatorProvider.java b/src/main/java/org/mockito/plugins/InstantiatorProvider.java
index b776f6e..354b87b 100644
--- a/src/main/java/org/mockito/plugins/InstantiatorProvider.java
+++ b/src/main/java/org/mockito/plugins/InstantiatorProvider.java
@@ -8,6 +8,10 @@
 import org.mockito.mock.MockCreationSettings;
 
 /**
+ * @deprecated since 2.15.4 because this internal class was leaking from the public API.
+ * For more information why deprecated, see {@link org.mockito.plugins.InstantiatorProvider2} and
+ * <a href="https://github.com/mockito/mockito/issues/1303">Issue 1303</a>
+ *
  * <p>
  *     Mockito will invoke this interface in order to fetch an instance instantiator provider.
  * </p>
@@ -44,13 +48,24 @@
  *     qualified name in the following file
  *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider</code>.
  * </p>
+ * <p>
+ *     This class is deprecated and was replaced by
+ *     {@link org.mockito.plugins.InstantiatorProvider2}. Hence if there is both a
+ *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider</code> and
+ *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider2</code> the second one
+ *     takes preference.
+ * </p>
  *
- * @since 21.10.15
+ * @since 2.0.31
  */
+@Deprecated
 public interface InstantiatorProvider {
 
     /**
+     * @deprecated, see {@link InstantiatorProvider}.
+     *
      * Returns an instantiator, used to create new class instances.
      */
+    @Deprecated
     Instantiator getInstantiator(MockCreationSettings<?> settings);
 }
diff --git a/src/main/java/org/mockito/plugins/InstantiatorProvider2.java b/src/main/java/org/mockito/plugins/InstantiatorProvider2.java
new file mode 100644
index 0000000..3bc1f32
--- /dev/null
+++ b/src/main/java/org/mockito/plugins/InstantiatorProvider2.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * <p>
+ *     Mockito will invoke this interface in order to fetch an instance instantiator provider.
+ * </p>
+ *
+ * <p>
+ *     By default, an internal byte-buddy/asm/objenesis based implementation is used.
+ * </p>
+ *
+ * <h3>Using the extension point</h3>
+ *
+ * <p>
+ *     The plugin mechanism of mockito works in a similar way as the
+ *     {@link java.util.ServiceLoader}, however instead of looking in the <code>META-INF</code>
+ *     directory, Mockito will look in <code>mockito-extensions</code> directory.
+ *     <em>The reason for that is that Android SDK strips jar from the <code>META-INF</code>
+ *     directory when creating an APK.</em>
+ * </p>
+ *
+ * <ol style="list-style-type: lower-alpha">
+ *     <li>The implementation itself, for example
+ *         <code>org.awesome.mockito.AwesomeInstantiatorProvider2</code> that implements the
+ *         <code>InstantiatorProvider2</code>.</li>
+ *     <li>A file "<code>mockito-extensions/org.mockito.plugins.InstantiatorProvider2</code>".
+ *         The content of this file is exactly a <strong>one</strong> line with the qualified
+ *         name: <code>org.awesome.mockito.AwesomeInstantiatorProvider</code>.</li>
+ * </ol></p>
+ *
+ * <p>
+ *     Note that if several <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider2</code>
+ *     files exists in the classpath, Mockito will only use the first returned by the standard
+ *     {@link ClassLoader#getResource} mechanism.
+ * <p>
+ *     So just create a custom implementation of {@link InstantiatorProvider2} and place the
+ *     qualified name in the following file
+ *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider2</code>.
+ * </p>
+ *
+ * @since 2.15.4
+ */
+public interface InstantiatorProvider2 {
+
+    /**
+     * Returns an instantiator, used to create new class instances.
+     *
+     * @since 2.15.4
+     */
+    Instantiator getInstantiator(MockCreationSettings<?> settings);
+}
diff --git a/src/main/java/org/mockito/quality/Strictness.java b/src/main/java/org/mockito/quality/Strictness.java
index 4e1126a..c9da8d3 100644
--- a/src/main/java/org/mockito/quality/Strictness.java
+++ b/src/main/java/org/mockito/quality/Strictness.java
@@ -80,7 +80,8 @@
      *      <li>Cleaner, more DRY tests ("Don't Repeat Yourself"):
      *          If you use {@link org.mockito.Mockito#verifyNoMoreInteractions(Object...)}
      *          you no longer need to explicitly verify stubbed invocations.
-     *          They are automatically verified for you.</li>
+     *          They are automatically verified for you. However if you have more invocations,
+     *          the test won't fail since it won't check that there are no more interactions on that stub.</li>
      *  </ul>
      *
      * For more information see {@link Strictness}.
diff --git a/src/main/java/org/mockito/session/MockitoSessionBuilder.java b/src/main/java/org/mockito/session/MockitoSessionBuilder.java
index b13062b..474b7f9 100644
--- a/src/main/java/org/mockito/session/MockitoSessionBuilder.java
+++ b/src/main/java/org/mockito/session/MockitoSessionBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.session;
@@ -20,7 +20,7 @@
 public interface MockitoSessionBuilder {
 
     /**
-     * Configures the test class instance for initialization of fields annotated with Mockito annotations
+     * Adds the test class instance for initialization of fields annotated with Mockito annotations
      * like {@link org.mockito.Mock}.
      * When this method is invoked it <strong>does not perform</strong> initialization of mocks on the spot!
      * Only when {@link #startMocking()} is invoked then annotated fields will be initialized.
@@ -30,11 +30,12 @@
      * Migrate from {@link MockitoAnnotations#initMocks(Object)}
      * to {@link MockitoSession}!
      * <p>
+     * This method may be called multiple times to add multiple, e.g. nested, test class instances.
+     * <p>
      * See code sample in {@link MockitoSession}.
      *
      * @param testClassInstance test class instance that contains fields with Mockito annotations to be initialized.
-     *  Passing {@code null} is permitted and will make the session use a default value.
-     *  The current default is '{@code new Object()}'.
+     *  Passing {@code null} is permitted but will be ignored.
      * @return the same builder instance for fluent configuration of {@code MockitoSession}.
      * @since 2.7.0
      */
@@ -42,6 +43,46 @@
     MockitoSessionBuilder initMocks(Object testClassInstance);
 
     /**
+     * Adds the test class instances for initialization of fields annotated with Mockito annotations
+     * like {@link org.mockito.Mock}.
+     * <p>
+     * In most scenarios, you only need to init mocks on a single test class instance.
+     * This method is useful for advanced framework integrations (like JUnit5), when a test uses multiple, e.g. nested, test class instances.
+     * <p>
+     * This method calls {@link #initMocks(Object)} for each passed test class instance.
+     *
+     * @param testClassInstances test class instances that contains fields with Mockito annotations to be initialized.
+     *  Passing {@code null} or an empty array is permitted but will be ignored.
+     * @return the same builder instance for fluent configuration of {@code MockitoSession}.
+     * @see #initMocks(Object)
+     * @since 2.15.0
+     */
+    @Incubating
+    MockitoSessionBuilder initMocks(Object... testClassInstances);
+
+    /**
+     * Configures the name of the {@code MockitoSession} instance.
+     * <p>
+     * The name is used to output {@linkplain org.mockito.quality.MockitoHint hints} when
+     * {@linkplain MockitoSession#finishMocking() finishing} a session.
+     * <p>
+     * This method is intended to be used by framework integrations, e.g. JUnit. When building
+     * a {@code MockitoSession} for direct use, users are not expected to call it.
+     *
+     * @param name of {@code MockitoSession} instance.
+     *  Passing {@code null} is permitted and will make the session use a default value.
+     *  The current default is the name of the last test class instance passed to
+     *  {@link #initMocks(Object)} or {@link #initMocks(Object...)}, if available;
+     *  otherwise, {@code "<Unnamed Session>"} is used.
+     *
+     * @return the same builder instance for fluent configuration of {@code MockitoSession}.
+     * @see org.mockito.quality.MockitoHint
+     * @since 2.15.0
+     */
+    @Incubating
+    MockitoSessionBuilder name(String name);
+
+    /**
      * Configures strictness of {@code MockitoSession} instance.
      * See examples in {@link MockitoSession}.
      *
@@ -56,6 +97,25 @@
     MockitoSessionBuilder strictness(Strictness strictness);
 
     /**
+     * Configures logger used by {@code MockitoSession} for emitting
+     * {@linkplain org.mockito.quality.MockitoHint warnings} when finishing the session.
+     * <p>
+     * Please note that the use of {@linkplain Strictness#STRICT_STUBS strict stubs} is
+     * recommended over emitting warnings because warnings are easily ignored and spoil the log output.
+     * Instead of using this method, please consider setting strictness with {@link #strictness(Strictness)}.
+     *
+     * @param logger for warnings emitted when finishing {@code MockitoSession}.
+     *  Passing {@code null} is permitted and will make the session use a default value.
+     *  By default, warnings will be logged to the console.
+     *
+     * @return the same builder instance for fluent configuration of {@code MockitoSession}.
+     * @see org.mockito.quality.MockitoHint
+     * @since 2.15.0
+     */
+    @Incubating
+    MockitoSessionBuilder logger(MockitoSessionLogger logger);
+
+    /**
      * Starts new mocking session! Creates new {@code MockitoSession} instance to initialize the session.
      * At this point annotated fields are initialized per {@link #initMocks(Object)} method.
      * When you are done with the session it is required to invoke {@link MockitoSession#finishMocking()}.
diff --git a/src/main/java/org/mockito/session/MockitoSessionLogger.java b/src/main/java/org/mockito/session/MockitoSessionLogger.java
new file mode 100644
index 0000000..e5f40ad
--- /dev/null
+++ b/src/main/java/org/mockito/session/MockitoSessionLogger.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.session;
+
+import org.mockito.Incubating;
+import org.mockito.MockitoSession;
+
+/**
+ * Logger for {@linkplain org.mockito.quality.MockitoHint hints} emitted when
+ * finishing mocking for a {@link MockitoSession}.
+ * <p>
+ * This class is intended to be used by framework integrations, e.g. JUnit. When using
+ * {@link MockitoSession} directly, you'll probably not need it.
+ *
+ * @since 2.15.0
+ */
+@Incubating
+public interface MockitoSessionLogger {
+
+    /**
+     * Logs the hint.
+     *
+     * @param hint to log; never {@code null}
+     */
+    @Incubating
+    void log(String hint);
+
+}
diff --git a/src/main/java/org/mockito/stubbing/OngoingStubbing.java b/src/main/java/org/mockito/stubbing/OngoingStubbing.java
index bc768d2..e2d298b 100644
--- a/src/main/java/org/mockito/stubbing/OngoingStubbing.java
+++ b/src/main/java/org/mockito/stubbing/OngoingStubbing.java
@@ -43,7 +43,7 @@
      *
      * @param value return value
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      */
     OngoingStubbing<T> thenReturn(T value);
 
@@ -60,7 +60,7 @@
      * @param value first return value
      * @param values next return values
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      */
     // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation warnings (on call site)
     @SuppressWarnings ({"unchecked", "varargs"})
@@ -84,7 +84,7 @@
      *
      * @param throwables to be thrown on method invocation
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      */
     OngoingStubbing<T> thenThrow(Throwable... throwables);
 
@@ -108,7 +108,7 @@
      *
      * @param throwableType to be thrown on method invocation
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      * @since 2.1.0
      */
     OngoingStubbing<T> thenThrow(Class<? extends Throwable> throwableType);
@@ -141,7 +141,7 @@
      * @param toBeThrown to be thrown on method invocation
      * @param nextToBeThrown next to be thrown on method invocation
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      * @since 2.1.0
      */
     // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation warnings (on call site)
@@ -175,7 +175,7 @@
      * <p>
      * See examples in javadoc for {@link Mockito#when}
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      */
     OngoingStubbing<T> thenCallRealMethod();
 
@@ -191,7 +191,7 @@
      *
      * @param answer the custom answer to execute.
      *
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      */
     OngoingStubbing<T> thenAnswer(Answer<?> answer);
 
@@ -209,7 +209,7 @@
      * </code></pre>
      *
      * @param answer the custom answer to execute.
-     * @return iOngoingStubbing object that allows stubbing consecutive calls
+     * @return object that allows stubbing consecutive calls
      *
      * @see #thenAnswer(Answer)
      * @since 1.9.0
diff --git a/src/test/java/org/mockito/InvocationFactoryTest.java b/src/test/java/org/mockito/InvocationFactoryTest.java
new file mode 100644
index 0000000..893f95f
--- /dev/null
+++ b/src/test/java/org/mockito/InvocationFactoryTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockito;
+
+import org.junit.Test;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
+import org.mockitoutil.TestBase;
+
+import java.util.concurrent.Callable;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.withSettings;
+
+public class InvocationFactoryTest extends TestBase {
+    static class TestClass {
+        public String testMethod() throws Throwable {
+            return "un-mocked";
+        }
+    }
+
+    final TestClass mock = spy(TestClass.class);
+
+    @Test
+    public void call_method_that_throws_a_throwable() throws Throwable {
+        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
+            withSettings().build(TestClass.class),
+            TestClass.class.getDeclaredMethod("testMethod"),
+            new InvocationFactory.RealMethodBehavior() {
+            @Override
+            public Object call() throws Throwable {
+                throw new Throwable("mocked");
+            }
+        });
+
+        try {
+            Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
+        } catch (Throwable t) {
+            assertEquals("mocked", t.getMessage());
+            return;
+        }
+
+        fail();
+    }
+
+    @Test
+    public void call_method_that_returns_a_string() throws Throwable {
+        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
+            withSettings().build(TestClass.class),
+            TestClass.class.getDeclaredMethod("testMethod"),
+            new InvocationFactory.RealMethodBehavior() {
+                @Override
+                public Object call() throws Throwable {
+                    return "mocked";
+                }
+            });
+
+        Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
+        assertEquals("mocked", ret);
+    }
+
+    @Test
+    public void deprecated_api_still_works() throws Throwable {
+        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
+            withSettings().build(TestClass.class),
+            TestClass.class.getDeclaredMethod("testMethod"),
+            new Callable() {
+                public Object call() throws Exception {
+                    return "mocked";
+                }
+            });
+
+        Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
+        assertEquals("mocked", ret);
+    }
+}
diff --git a/src/test/java/org/mockito/StaticMockingExperimentTest.java b/src/test/java/org/mockito/StaticMockingExperimentTest.java
index a74d5eb..bb5e225 100644
--- a/src/test/java/org/mockito/StaticMockingExperimentTest.java
+++ b/src/test/java/org/mockito/StaticMockingExperimentTest.java
@@ -10,12 +10,12 @@
 import org.mockito.exceptions.verification.WantedButNotInvoked;
 import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
 import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
 import org.mockito.invocation.MockHandler;
 import org.mockitoutil.TestBase;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -43,9 +43,9 @@
     Foo mock = Mockito.mock(Foo.class);
     MockHandler handler = Mockito.mockingDetails(mock).getMockHandler();
     Method staticMethod;
-    Callable realMethod = new Callable() {
+    InvocationFactory.RealMethodBehavior realMethod = new InvocationFactory.RealMethodBehavior() {
         @Override
-        public Object call() throws Exception {
+        public Object call() throws Throwable {
             return null;
         }
     };
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java b/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
index 41fe3cc..5935eae 100644
--- a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
+++ b/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
@@ -7,6 +7,8 @@
 import org.junit.Test;
 import org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker;
 import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MockMaker;
 import org.mockitoutil.TestBase;
 
@@ -23,5 +25,7 @@
             plugins.getDefaultPluginClass(INLINE_ALIAS));
         assertEquals(InlineByteBuddyMockMaker.class, plugins.getInlineMockMaker().getClass());
         assertEquals(ByteBuddyMockMaker.class, plugins.getDefaultPlugin(MockMaker.class).getClass());
+        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider.class));
+        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
     }
 }
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java b/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
new file mode 100644
index 0000000..ab01858
--- /dev/null
+++ b/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.when;
+
+public class PluginLoaderTest {
+
+    @Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+    @Mock PluginInitializer initializer;
+    @Mock DefaultMockitoPlugins plugins;
+    @InjectMocks PluginLoader loader;
+
+    @Test
+    public void loads_plugin() {
+        when(initializer.loadImpl(FooPlugin.class)).thenReturn(new FooPlugin());
+
+        //when
+        FooPlugin plugin = loader.loadPlugin(FooPlugin.class);
+
+        //then
+        assertNotNull(plugin);
+    }
+
+    @Test
+    public void loads_alternative_plugin() {
+        willReturn(null).given(initializer).loadImpl(FooPlugin.class);
+        BarPlugin expected = new BarPlugin();
+        willReturn(expected).given(initializer).loadImpl(BarPlugin.class);
+
+        //when
+        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
+
+        //then
+        assertSame(plugin, expected);
+    }
+
+    @Test
+    public void loads_default_plugin() {
+        willReturn(null).given(initializer).loadImpl(FooPlugin.class);
+        willReturn(null).given(initializer).loadImpl(BarPlugin.class);
+        FooPlugin expected = new FooPlugin();
+        willReturn(expected).given(plugins).getDefaultPlugin(FooPlugin.class);
+
+        //when
+        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
+
+        //then
+        assertSame(plugin, expected);
+    }
+
+    @Test
+    public void fails_to_load_plugin() {
+        RuntimeException cause = new RuntimeException("Boo!");
+        when(initializer.loadImpl(Foo.class)).thenThrow(cause);
+
+        //when
+        final Foo plugin = loader.loadPlugin(Foo.class);
+
+        //then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                plugin.toString(); //call any method on the plugin
+            }
+        }).isInstanceOf(IllegalStateException.class)
+            .hasMessage("Could not initialize plugin: interface org.mockito.internal.configuration.plugins.PluginLoaderTest$Foo (alternate: null)")
+            .hasCause(cause);
+    }
+
+    static class FooPlugin {}
+    static class BarPlugin {}
+    static interface Foo {}
+}
diff --git a/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java b/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
index 50030df..320287c 100644
--- a/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
+++ b/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
@@ -65,7 +65,7 @@
         assertEquals(new ConstructorInstantiator(false, 123).newInstance(SomeClass3.class).getClass(), SomeClass3.class);
     }
 
-    @Test(expected = InstantiationException.class)
+    @Test(expected = org.mockito.creation.instance.InstantiationException.class)
     public void fails_when_null_is_passed_for_a_primitive() {
         assertEquals(new ConstructorInstantiator(false, new Object[]{null}).newInstance(SomeClass3.class).getClass(), SomeClass3.class);
     }
@@ -75,7 +75,7 @@
         try {
             new ConstructorInstantiator(false, new Object[0]).newInstance(SomeClass2.class);
             fail();
-        } catch (InstantiationException e) {
+        } catch (org.mockito.creation.instance.InstantiationException e) {
             assertThat(e).hasMessageContaining("Unable to create instance of 'SomeClass2'.\n" +
                     "Please ensure that the target class has a 0-arg constructor.");
         }
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java b/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
index 696d34a..b3106a6 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
+++ b/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
@@ -6,7 +6,7 @@
 package org.mockito.internal.invocation;
 
 import org.mockito.Mockito;
-import org.mockito.internal.creation.bytebuddy.InterceptedInvocation;
+import org.mockito.internal.invocation.mockref.MockStrongReference;
 import org.mockito.internal.debugging.LocationImpl;
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.Location;
@@ -17,7 +17,7 @@
 import java.util.List;
 
 import static java.util.Arrays.asList;
-import static org.mockito.internal.creation.bytebuddy.InterceptedInvocation.NO_OP;
+import static org.mockito.internal.invocation.InterceptedInvocation.NO_OP;
 
 /**
  * Build an invocation.
@@ -61,7 +61,7 @@
             }
         }
 
-        Invocation i = new InterceptedInvocation(mock,
+        Invocation i = new InterceptedInvocation(new MockStrongReference<Object>(mock, false),
             new SerializableMethod(method),
             args,
             NO_OP,
diff --git a/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java b/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
new file mode 100644
index 0000000..1e3d8e9
--- /dev/null
+++ b/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation.mockref;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
+import org.mockitoutil.TestBase;
+
+import static org.junit.Assert.fail;
+
+public class MockWeakReferenceTest extends TestBase {
+
+    @Test
+    public void descriptive_exception_when_mock_was_collected() {
+        try {
+            //when
+            new MockWeakReference(null).get();
+            //then
+            fail();
+        } catch (Exception e) {
+            Assertions.assertThat(e).hasMessageContaining("The mock object was garbage collected");
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java b/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
index f519186..855afb0 100644
--- a/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
+++ b/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
@@ -1,29 +1,42 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockito.internal.session;
 
 import org.junit.After;
 import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoSession;
 import org.mockito.StateMaster;
 import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
 import org.mockito.quality.Strictness;
+import org.mockito.session.MockitoSessionLogger;
 import org.mockitoutil.ThrowableAssert;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.when;
+import static org.mockito.quality.Strictness.WARN;
+
 public class DefaultMockitoSessionBuilderTest {
 
     @After public void after() {
         new StateMaster().clearMockitoListeners();
     }
 
-    @Test public void creates_sessions() throws Exception {
+    @Test public void creates_sessions() {
         //no configuration is legal
         new DefaultMockitoSessionBuilder().startMocking().finishMocking();
 
         //passing null to configuration is legal, default value will be used
-        new DefaultMockitoSessionBuilder().initMocks(null).startMocking().finishMocking();
-        new DefaultMockitoSessionBuilder().initMocks(null).strictness(null).startMocking().finishMocking();
+        new DefaultMockitoSessionBuilder().initMocks((Object) null).startMocking().finishMocking();
+        new DefaultMockitoSessionBuilder().initMocks((Object[]) null).startMocking().finishMocking();
+        new DefaultMockitoSessionBuilder().initMocks(null, null).strictness(null).startMocking().finishMocking();
         new DefaultMockitoSessionBuilder().strictness(null).startMocking().finishMocking();
 
         //happy path
@@ -32,7 +45,49 @@
         new DefaultMockitoSessionBuilder().strictness(Strictness.LENIENT).startMocking().finishMocking();
     }
 
-    @Test public void requires_finish_mocking() throws Exception {
+    @Test public void creates_sessions_for_multiple_test_class_instances_for_repeated_calls() {
+        TestClass testClass = new TestClass();
+        TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
+
+        new DefaultMockitoSessionBuilder().initMocks(testClass).initMocks(nestedTestClass).startMocking().finishMocking();
+
+        assertNotNull(testClass.set);
+        assertNotNull(nestedTestClass.list);
+    }
+
+    @Test public void creates_sessions_for_multiple_test_class_instances_for_varargs_call() {
+        TestClass testClass = new TestClass();
+        TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
+
+        new DefaultMockitoSessionBuilder().initMocks(testClass, nestedTestClass).startMocking().finishMocking();
+
+        assertNotNull(testClass.set);
+        assertNotNull(nestedTestClass.list);
+    }
+
+    @Test public void uses_logger_and_strictness() {
+        TestClass testClass = new TestClass();
+
+        final List<String> hints = new ArrayList<String>();
+        MockitoSession session = new DefaultMockitoSessionBuilder()
+            .initMocks(testClass)
+            .strictness(WARN)
+            .logger(new MockitoSessionLogger() {
+                @Override
+                public void log(String hint) {
+                    hints.add(hint);
+                }
+            })
+            .startMocking();
+
+        when(testClass.set.add(1)).thenReturn(true);
+
+        session.finishMocking();
+
+        assertFalse(hints.isEmpty());
+    }
+
+    @Test public void requires_finish_mocking() {
         new DefaultMockitoSessionBuilder().startMocking();
 
         ThrowableAssert.assertThat(new Runnable() {
@@ -41,4 +96,13 @@
             }
         }).throwsException(UnfinishedMockingSessionException.class);
     }
+
+    class TestClass {
+
+        @Mock public Set<Object> set;
+
+        class NestedTestClass {
+            @Mock public List<Object> list;
+        }
+    }
 }
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
index 0e77824..de5eb13 100644
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
@@ -5,8 +5,6 @@
 
 package org.mockito.internal.stubbing;
 
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.exceptions.base.MockitoException;
@@ -21,6 +19,7 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
 
 public class InvocationContainerImplStubbingTest extends TestBase {
 
@@ -96,27 +95,6 @@
     }
 
     @Test
-    public void should_add_throwable_for_void_method() throws Throwable {
-        invocationContainerImpl.addAnswerForVoidMethod(new ThrowsException(new MyException()));
-        invocationContainerImpl.setMethodForStubbing(new InvocationMatcher(simpleMethod));
-
-        try {
-            invocationContainerImpl.answerTo(simpleMethod);
-            fail();
-        } catch (MyException e) {}
-    }
-
-    @Test
-    public void should_validate_throwable_for_void_method() throws Throwable {
-        invocationContainerImpl.addAnswerForVoidMethod(new ThrowsException(new Exception()));
-
-        try {
-            invocationContainerImpl.setMethodForStubbing(new InvocationMatcher(simpleMethod));
-            fail();
-        } catch (MockitoException e) {}
-    }
-
-    @Test
     public void should_validate_throwable() throws Throwable {
         try {
             invocationContainerImpl.addAnswer(new ThrowsException(null));
diff --git a/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java b/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
new file mode 100644
index 0000000..d9720f9
--- /dev/null
+++ b/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockitoutil.TestBase;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/**
+ * @see <a href="https://github.com/mockito/mockito/issues/1279">Issue #1279</a>
+ */
+public class MockitoStubbedCallInAnswerTest extends TestBase {
+
+    @Mock Foo foo;
+    @Mock Bar bar;
+
+    @Test
+    public void stubbing_the_right_mock() throws Exception {
+        //stubbing on different mock should not be altered
+        when(bar.doInt()).thenReturn(0);
+        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
+            @Override
+            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                return bar.doInt();
+            }
+        });
+        assertEquals(0, foo.doInt());
+        assertEquals(0, bar.doInt());
+
+        //when we override the stubbing
+        when(foo.doInt()).thenReturn(1);
+
+        //we expect it to be reflected:
+        assertEquals(1, foo.doInt());
+
+        //but the stubbing on a different mock should not be altered:
+        assertEquals(0, bar.doInt());
+    }
+
+    @Test
+    public void return_type_validation() throws Exception {
+        when(foo.doString()).thenAnswer(new Answer<String>() {
+            public String answer(InvocationOnMock invocation) throws Throwable {
+                //invoking a method on a different mock, with different return type
+                return String.valueOf(bar.doInt());
+            }
+        });
+        assertEquals("0", foo.doString());
+
+        //we can override stubbing without misleading return type validation errors:
+        when(foo.doString()).thenReturn("");
+        assertEquals("", foo.doString());
+    }
+
+    @Test
+    public void prevents_stack_overflow() throws Exception {
+        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
+            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                return bar.doInt();
+            }
+        });
+        assertEquals(0, foo.doInt());
+
+        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
+            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                return bar.doInt() + 1;
+            }
+        });
+
+        //calling below used to cause SO error
+        assertEquals(1, foo.doInt());
+    }
+
+    @Test
+    public void overriding_stubbing() throws Exception {
+        when(bar.doInt()).thenReturn(10);
+        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
+            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                return bar.doInt() + 1;
+            }
+        });
+
+        assertEquals(11, foo.doInt());
+
+        //when we override the stubbing with a different one
+        when(foo.doInt()).thenReturn(100);
+
+        //we expect it to be reflected:
+        assertEquals(100, foo.doInt());
+    }
+
+    interface Foo {
+        String doString();
+        int doInt();
+    }
+
+    interface Bar {
+        int doInt();
+    }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
index 59e5999..f4e3e95 100644
--- a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
@@ -8,18 +8,20 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.mockito.Mock;
-import org.mockito.quality.Strictness;
 import org.mockito.exceptions.misusing.PotentialStubbingProblem;
 import org.mockito.exceptions.misusing.UnfinishedVerificationException;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
 import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
 import org.mockitousage.IMethods;
 import org.mockitoutil.SafeJUnitRule;
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 import static org.mockitoutil.TestBase.filterLineNo;
 
 public class StrictJUnitRuleTest {
@@ -97,7 +99,7 @@
                                 "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API\n" +
                                 "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.\n" +
                                 "  - stubbed method is intentionally invoked with different arguments by code under test\n" +
-                                "    Please use 'default' or 'silent' JUnit Rule.\n" +
+                                "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).\n" +
                                 "For more information see javadoc for PotentialStubbingProblem class."),
                         filterLineNo(t.getMessage()));
             }
@@ -140,7 +142,7 @@
                         "Following stubbings are unnecessary (click to navigate to relevant line of code):\n" +
                         "  1. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n" +
                         "  2. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n" +
-                        "Please remove unnecessary stubbings or use 'silent' option. More info: javadoc for UnnecessaryStubbingException class."), filterLineNo(t.getMessage()));
+                        "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."), filterLineNo(t.getMessage()));
             }
         });
 
diff --git a/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java b/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
index 0d8cead..6b6017a 100644
--- a/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
@@ -53,7 +53,7 @@
                         "Following stubbings are unnecessary (click to navigate to relevant line of code):\n" +
                         "  1. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n" +
                         "  2. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n" +
-                        "Please remove unnecessary stubbings or use 'silent' option. More info: javadoc for UnnecessaryStubbingException class.",
-                filterLineNo(failure.getException().getMessage()));
+                        "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.",
+            filterLineNo(failure.getException().getMessage()));
     }
 }
diff --git a/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java b/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
index 0d164c6..a1a3500 100644
--- a/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
+++ b/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
@@ -6,8 +6,10 @@
 
 import org.junit.Test;
 import org.mockito.Mockito;
+import org.mockito.internal.creation.instance.Instantiator;
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.InstantiatorProvider;
+import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MockMaker;
 import org.mockito.plugins.MockitoPlugins;
 import org.mockito.plugins.PluginSwitch;
@@ -15,17 +17,29 @@
 import org.mockitoutil.TestBase;
 
 import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.withSettings;
 
 public class MockitoPluginsTest extends TestBase {
 
     private final MockitoPlugins plugins = Mockito.framework().getPlugins();
 
-    @Test public void provides_built_in_plugins() {
+    @Test
+    public void provides_built_in_plugins() {
         assertNotNull(plugins.getInlineMockMaker());
         assertNotNull(plugins.getDefaultPlugin(MockMaker.class));
         assertNotNull(plugins.getDefaultPlugin(StackTraceCleanerProvider.class));
         assertNotNull(plugins.getDefaultPlugin(PluginSwitch.class));
         assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider.class));
+        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
         assertNotNull(plugins.getDefaultPlugin(AnnotationEngine.class));
     }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void instantiator_provider_backwards_compatibility() {
+        InstantiatorProvider provider = plugins.getDefaultPlugin(InstantiatorProvider.class);
+        Instantiator instantiator = provider.getInstantiator(withSettings().build(MockitoPluginsTest.class));
+
+        assertNotNull(instantiator.newInstance(MockitoPluginsTest.class));
+    }
 }
diff --git a/src/test/java/org/mockitousage/session/MockitoSessionTest.java b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
index e992f83..960d888 100644
--- a/src/test/java/org/mockitousage/session/MockitoSessionTest.java
+++ b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
@@ -15,13 +15,17 @@
 import org.mockito.quality.Strictness;
 import org.mockitousage.IMethods;
 import org.mockitoutil.JUnitResultAssert;
+import org.mockitoutil.TestBase;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-public class MockitoSessionTest {
+public class MockitoSessionTest extends TestBase {
 
     private JUnitCore junit = new JUnitCore();
 
@@ -66,6 +70,33 @@
                 .failsExactly(AssertionError.class, UnfinishedStubbingException.class);
     }
 
+    @Test public void allows_initializing_mocks_manually() {
+        //when
+        Result result = junit.run(MockitoSessionTest.SessionWithManuallyInitializedMock.class);
+
+        //expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test public void allows_updating_strictness() {
+        //when
+        Result result = junit.run(MockitoSessionTest.SessionWithUpdatedStrictness.class);
+
+        //expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test public void allows_overriding_failure() {
+        //when
+        Result result = junit.run(MockitoSessionTest.SessionWithOverriddenFailure.class);
+
+        //expect
+        JUnitResultAssert.assertThat(result).isSuccessful();
+
+        //in order to demonstrate feature, we intentionally misuse Mockito and need to clean up state
+        resetState();
+    }
+
     public static class SessionWithoutAnyConfiguration {
 
         @Mock IMethods mock;
@@ -139,4 +170,52 @@
             assertTrue(false);
         }
     }
+
+    public static class SessionWithManuallyInitializedMock {
+        @Mock IMethods mock;
+        IMethods mock2 = Mockito.mock(IMethods.class, "manual mock");
+
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test public void manual_mock_preserves_its_settings() {
+            assertEquals("mock", mockingDetails(mock).getMockCreationSettings().getMockName().toString());
+            assertEquals("manual mock", mockingDetails(mock2).getMockCreationSettings().getMockName().toString());
+        }
+    }
+
+    public static class SessionWithUpdatedStrictness {
+        @Mock IMethods mock;
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+
+        @After public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test public void manual_mock_preserves_its_settings() {
+            when(mock.simpleMethod(1)).thenReturn("foo");
+
+            //when
+            mockito.setStrictness(Strictness.LENIENT);
+
+            //then no exception is thrown, even though the arg is different
+            mock.simpleMethod(2);
+        }
+    }
+
+    public static class SessionWithOverriddenFailure {
+        @Mock IMethods mock;
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After public void after() {
+            mockito.finishMocking(new RuntimeException("Boo!"));
+        }
+
+        @Test public void invalid_mockito_usage() {
+            verify(mock);
+        }
+    }
 }
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
index 74acd78..754b7dc 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
@@ -1,27 +1,40 @@
 /*
- * Copyright (c) 2017 Mockito contributors
+ * Copyright (c) 2018 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
 package org.mockitousage.stubbing;
 
+import org.junit.After;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoSession;
+import org.mockito.StateMaster;
+import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.framework.DefaultMockitoSession;
 import org.mockito.internal.util.SimpleMockitoLogger;
 import org.mockito.quality.Strictness;
 import org.mockitousage.IMethods;
 
+import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
 import static org.mockitoutil.TestBase.filterLineNo;
 
 public class StubbingWarningsTest {
 
+    private static final String TEST_NAME = "test.name";
+
     @Mock IMethods mock;
 
     SimpleMockitoLogger logger = new SimpleMockitoLogger();
-    MockitoSession mockito = new DefaultMockitoSession(this, Strictness.WARN, logger);
+    MockitoSession mockito = new DefaultMockitoSession(singletonList((Object) this), TEST_NAME, Strictness.WARN, logger);
+
+    @After public void after() {
+        StateMaster stateMaster = new StateMaster();
+        stateMaster.reset();
+        stateMaster.clearMockitoListeners();
+    }
 
     @Test public void few_interactions() throws Throwable {
         //when
@@ -65,7 +78,7 @@
         //because it was simpler to implement. This can be improved given we put priority to improve the warnings.
         //then
         assertEquals(filterLineNo(
-            "[MockitoHint] StubbingWarningsTest.null (see javadoc for MockitoHint):\n" +
+            "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" +
             "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.stubbing_argument_mismatch(StubbingWarningsTest.java:0)\n"),
                 filterLineNo(logger.getLoggedInfo()));
     }
@@ -78,8 +91,25 @@
 
         //then
         assertEquals(filterLineNo(
-            "[MockitoHint] StubbingWarningsTest.null (see javadoc for MockitoHint):\n" +
+            "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" +
             "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.unused_stubbing(StubbingWarningsTest.java:0)\n"),
                 filterLineNo(logger.getLoggedInfo()));
     }
+
+    @Test(expected = MockitoException.class) public void unfinished_verification_without_throwable() throws Throwable {
+        //when
+        verify(mock);
+
+        mockito.finishMocking();
+    }
+
+    @Test public void unfinished_verification_with_throwable() throws Throwable {
+        //when
+        verify(mock);
+
+        mockito.finishMocking(new AssertionError());
+
+        // then
+        logger.assertEmpty();
+    }
 }
diff --git a/src/test/java/org/mockitoutil/TestBase.java b/src/test/java/org/mockitoutil/TestBase.java
index 2971ee5..ca3d7b8 100644
--- a/src/test/java/org/mockitoutil/TestBase.java
+++ b/src/test/java/org/mockitoutil/TestBase.java
@@ -11,7 +11,8 @@
 import org.mockito.StateMaster;
 import org.mockito.internal.MockitoCore;
 import org.mockito.internal.configuration.ConfigurationAccess;
-import org.mockito.internal.creation.bytebuddy.InterceptedInvocation;
+import org.mockito.internal.invocation.mockref.MockStrongReference;
+import org.mockito.internal.invocation.InterceptedInvocation;
 import org.mockito.internal.debugging.LocationImpl;
 import org.mockito.internal.invocation.InvocationBuilder;
 import org.mockito.internal.invocation.InvocationMatcher;
@@ -64,8 +65,9 @@
         for (int i = 0; i < args.length; i++) {
             types[i] = args[i].getClass();
         }
-        return new InterceptedInvocation(mock(type), new SerializableMethod(type.getMethod(methodName,
-                types)), args, InterceptedInvocation.NO_OP, new LocationImpl(), 1);
+        return new InterceptedInvocation(new MockStrongReference<Object>(mock(type), false),
+            new SerializableMethod(type.getMethod(methodName, types)), args, InterceptedInvocation.NO_OP,
+            new LocationImpl(), 1);
     }
 
     protected static Invocation invocationAt(String location) {
diff --git a/stub/java/org/mockito/internal/invocation/DefaultInvocationFactory.java b/stub/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
deleted file mode 100644
index c9b8a7c..0000000
--- a/stub/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mockito.internal.invocation;
-
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationFactory;
-import org.mockito.mock.MockCreationSettings;
-
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-
-public class DefaultInvocationFactory implements InvocationFactory {
-
-    public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, Callable realMethod, Object... args) {
-        throw new RuntimeException("Not implemented");
-    }
-}
diff --git a/subprojects/inline/inline.gradle b/subprojects/inline/inline.gradle
index be10361..b8d2577 100644
--- a/subprojects/inline/inline.gradle
+++ b/subprojects/inline/inline.gradle
@@ -8,3 +8,6 @@
 }
 
 tasks.javadoc.enabled = false
+
+//required by the "StressTest.java"
+test.maxHeapSize = "256m"
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/RecursionTest.java b/subprojects/inline/src/test/java/org/mockitoinline/RecursionTest.java
new file mode 100644
index 0000000..2a4494e
--- /dev/null
+++ b/subprojects/inline/src/test/java/org/mockitoinline/RecursionTest.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import static org.mockito.Mockito.spy;
+
+public class RecursionTest {
+
+    @Test
+    public void testMockConcurrentHashMap() {
+        ConcurrentMap<String, String> map = spy(new ConcurrentHashMap<String, String>());
+        map.putIfAbsent("a", "b");
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/StressTest.java b/subprojects/inline/src/test/java/org/mockitoinline/StressTest.java
new file mode 100644
index 0000000..c6a5506
--- /dev/null
+++ b/subprojects/inline/src/test/java/org/mockitoinline/StressTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+public class StressTest {
+    public class TestClass {
+        public String getStuff() {
+            return "A";
+        }
+    }
+
+    @Test
+    public void call_a_lot_of_mocks() {
+        //This requires smaller heap set for the test process, see "inline.gradle"
+        for (int i = 0; i < 40000; i++) {
+            TestClass mock = mock(TestClass.class);
+            when(mock.getStuff()).thenReturn("B");
+            assertEquals("B", mock.getStuff());
+
+            TestClass serializableMock = mock(TestClass.class, withSettings().serializable());
+            when(serializableMock.getStuff()).thenReturn("C");
+            assertEquals("C", serializableMock.getStuff());
+
+            if (i % 1024 == 0) {
+                System.out.println(i + "/40000 mocks called");
+            }
+        }
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/SuperCallTest.java b/subprojects/inline/src/test/java/org/mockitoinline/SuperCallTest.java
new file mode 100644
index 0000000..1fe8196
--- /dev/null
+++ b/subprojects/inline/src/test/java/org/mockitoinline/SuperCallTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+public final class SuperCallTest {
+
+    @Test
+    public void testSuperMethodCall() {
+        Dummy d = spy(new Dummy());
+        d.foo();
+        verify(d).bar(eq("baz"));
+    }
+
+    static class Dummy {
+
+        public void foo() {
+            bar("baz");
+        }
+
+        // Also fails if public.
+        void bar(String s) {
+            return;
+        }
+    }
+}