diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 98b50ee..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-# IntelliJ IDEA
-.idea/
-*.iml
diff --git a/Android.bp b/Android.bp
index 22e8cbf..a82e8f6 100644
--- a/Android.bp
+++ b/Android.bp
@@ -44,8 +44,14 @@
             ],
         },
     },
-    sdk_version: "16",
+    sdk_version: "core_current",
     java_version: "1.7",
+
+    errorprone: {
+        javacflags: [
+            "-Xep:CollectionIncompatibleType:WARN",  // b/74213384
+        ],
+    }
 }
 
 // Compatibility library for old name of host target
@@ -60,7 +66,7 @@
     hostdex: true,
     no_framework_libs: true,
     static_libs: ["mockito"],
-    sdk_version: "16",
+    sdk_version: "core_current",
 }
 
 // Compatibility library for old name of host target
@@ -70,75 +76,15 @@
     java_resource_dirs: ["subprojects/inline/src/main/resources"],
 }
 
-// Main target for dependent projects. Bundles all the run-time dependencies
-// needed to run Mockito tests on the device.
-java_library_static {
-    name: "mockito-target",
-    no_framework_libs: true,
-    static_libs: [
-        "mockito-target-minus-junit4",
-        "junit",
-    ],
-    sdk_version: "16",
-}
-
-// A mockito target that doesn't pull in junit. This is used to work around
-// issues caused by multiple copies of junit in the classpath, usually when a test
-// using mockito is run using android.test.runner.
-java_library_static {
-    name: "mockito-target-minus-junit4",
-    no_framework_libs: true,
-    static_libs: [
-        "mockito",
-        "dexmaker",
-        "dexmaker-mockmaker",
-        "objenesis",
-    ],
-    libs: ["junit"],
-    sdk_version: "16",
-
-    java_version: "1.7",
-}
-
-// Main target for dependent projects. Bundles all the run-time dependencies
-// needed to run Mockito tests on the device.
-java_library_static {
-    name: "mockito-target-inline",
-    no_framework_libs: true,
-    static_libs: [
-        "mockito-target-inline-minus-junit4",
-        "junit",
-    ],
-    sdk_version: "current",
-}
-
-// A mockito target that doesn't pull in junit. This is used to work around
-// issues caused by multiple copies of junit in the classpath, usually when a test
-// using mockito is run using android.test.runner.
-java_library_static {
-    name: "mockito-target-inline-minus-junit4",
-    no_framework_libs: true,
-    static_libs: [
-        "mockito",
-        "dexmaker",
-        "dexmaker-inline-mockmaker",
-        "objenesis",
-    ],
-    libs: ["junit"],
-    sdk_version: "current",
-
-    java_version: "1.7",
-}
-
 // Host prebuilt dependencies.
 // ============================================================
 java_import_host {
     name: "mockito-byte-buddy",
-    jars: ["lib/byte-buddy-1.7.9.jar"],
+    jars: ["lib/byte-buddy-1.8.15.jar"],
 }
 
 java_import_host {
     name: "mockito-byte-buddy-agent",
-    jars: ["lib/byte-buddy-agent-1.7.9.jar"],
+    jars: ["lib/byte-buddy-agent-1.8.15.jar"],
 }
 
diff --git a/README.version b/README.version
index bbabbe6..35f650c 100644
--- a/README.version
+++ b/README.version
@@ -1,5 +1,5 @@
 URL: https://github.com/mockito/mockito
-Version: v2.16.0
+Version: v2.21.0
 License: Apache 2.0
 Description: Mockito is a mocking framework with a clean and simple API.
 
diff --git a/lib/byte-buddy-1.7.9-sources.jar b/lib/byte-buddy-1.7.9-sources.jar
deleted file mode 100644
index 0dd5b51..0000000
--- a/lib/byte-buddy-1.7.9-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/byte-buddy-1.7.9.jar b/lib/byte-buddy-1.7.9.jar
deleted file mode 100644
index a348888..0000000
--- a/lib/byte-buddy-1.7.9.jar
+++ /dev/null
Binary files differ
diff --git a/lib/byte-buddy-1.8.15-sources.jar b/lib/byte-buddy-1.8.15-sources.jar
new file mode 100644
index 0000000..523015e
--- /dev/null
+++ b/lib/byte-buddy-1.8.15-sources.jar
Binary files differ
diff --git a/lib/byte-buddy-1.8.15.jar b/lib/byte-buddy-1.8.15.jar
new file mode 100644
index 0000000..b8c8379
--- /dev/null
+++ b/lib/byte-buddy-1.8.15.jar
Binary files differ
diff --git a/lib/byte-buddy-1.7.9.jar.txt b/lib/byte-buddy-1.8.15.jar.txt
similarity index 100%
rename from lib/byte-buddy-1.7.9.jar.txt
rename to lib/byte-buddy-1.8.15.jar.txt
diff --git a/lib/byte-buddy-agent-1.7.9-sources.jar b/lib/byte-buddy-agent-1.7.9-sources.jar
deleted file mode 100644
index 4940121..0000000
--- a/lib/byte-buddy-agent-1.7.9-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/byte-buddy-agent-1.7.9.jar b/lib/byte-buddy-agent-1.7.9.jar
deleted file mode 100644
index 9fcfb59..0000000
--- a/lib/byte-buddy-agent-1.7.9.jar
+++ /dev/null
Binary files differ
diff --git a/lib/byte-buddy-agent-1.7.9.jar.txt b/lib/byte-buddy-agent-1.7.9.jar.txt
deleted file mode 100644
index e06d208..0000000
--- a/lib/byte-buddy-agent-1.7.9.jar.txt
+++ /dev/null
@@ -1,202 +0,0 @@
-Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   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.
-
diff --git a/lib/byte-buddy-agent-1.8.15-sources.jar b/lib/byte-buddy-agent-1.8.15-sources.jar
new file mode 100644
index 0000000..24ab2ee
--- /dev/null
+++ b/lib/byte-buddy-agent-1.8.15-sources.jar
Binary files differ
diff --git a/lib/byte-buddy-agent-1.8.15.jar b/lib/byte-buddy-agent-1.8.15.jar
new file mode 100644
index 0000000..1709e55
--- /dev/null
+++ b/lib/byte-buddy-agent-1.8.15.jar
Binary files differ
diff --git a/lib/byte-buddy-1.7.9.jar.txt b/lib/byte-buddy-agent-1.8.15.jar.txt
similarity index 100%
copy from lib/byte-buddy-1.7.9.jar.txt
copy to lib/byte-buddy-agent-1.8.15.jar.txt
diff --git a/src/main/java/org/mockito/CheckReturnValue.java b/src/main/java/org/mockito/CheckReturnValue.java
index 59bfc33..0498c14 100644
--- a/src/main/java/org/mockito/CheckReturnValue.java
+++ b/src/main/java/org/mockito/CheckReturnValue.java
@@ -28,5 +28,5 @@
     ElementType.TYPE
 })
 @Retention(RetentionPolicy.CLASS)
-@interface CheckReturnValue {
+public @interface CheckReturnValue {
 }
diff --git a/src/main/java/org/mockito/MockSettings.java b/src/main/java/org/mockito/MockSettings.java
index 82dc050..c79c243 100644
--- a/src/main/java/org/mockito/MockSettings.java
+++ b/src/main/java/org/mockito/MockSettings.java
@@ -4,12 +4,15 @@
  */
 package org.mockito;
 
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
 import org.mockito.invocation.InvocationFactory;
 import org.mockito.invocation.MockHandler;
 import org.mockito.listeners.InvocationListener;
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.SerializableMode;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 
 import java.io.Serializable;
@@ -316,4 +319,18 @@
      */
     @Incubating
     <T> MockCreationSettings<T> build(Class<T> typeToMock);
+
+    /**
+     * Lenient mocks bypass "strict stubbing" validation (see {@link Strictness#STRICT_STUBS}).
+     * When mock is declared as lenient none of its stubbings will be checked for potential stubbing problems such as
+     * 'unnecessary stubbing' ({@link UnnecessaryStubbingException}) or for 'stubbing argument mismatch' {@link PotentialStubbingProblem}.
+     *
+     * <pre class="code"><code class="java">
+     *   Foo mock = mock(Foo.class, withSettings.lenient());
+     * </code></pre>
+     *
+     * For more information and an elaborate example, see {@link Mockito#lenient()}.
+     */
+    @Incubating
+    MockSettings lenient();
 }
diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java
index b25dae5..2d06e58 100644
--- a/src/main/java/org/mockito/Mockito.java
+++ b/src/main/java/org/mockito/Mockito.java
@@ -4,6 +4,8 @@
  */
 package org.mockito;
 
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
 import org.mockito.internal.InternalMockHandler;
 import org.mockito.internal.MockitoCore;
 import org.mockito.internal.creation.MockSettingsImpl;
@@ -28,6 +30,7 @@
 import org.mockito.session.MockitoSessionLogger;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.Answer1;
+import org.mockito.stubbing.LenientStubber;
 import org.mockito.stubbing.OngoingStubbing;
 import org.mockito.stubbing.Stubber;
 import org.mockito.stubbing.Stubbing;
@@ -94,11 +97,13 @@
  *      <a href="#37">37. Java 8 Custom Answer Support (Since 2.1.0)</a><br/>
  *      <a href="#38">38. Meta data and generic type retention (Since 2.1.0)</a><br/>
  *      <a href="#39">39. Mocking final types, enums and final methods (Since 2.1.0)</a><br/>
- *      <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="#40">40. Improved productivity and cleaner tests with "stricter" Mockito (Since 2.+)</a><br/>
+ *      <a href="#41">41. Advanced public API for framework integrations (Since 2.10.+)</a><br/>
+ *      <a href="#42">42. New API for integrations: listening on verification start events (Since 2.11.+)</a><br/>
+ *      <a href="#43">43. 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/>
+ *      <a href="#45">45. New JUnit Jupiter (JUnit5+) extension</a><br/>
+ *      <a href="#46">46. New <code>Mockito.lenient()</code> and <code>MockSettings.lenient()</code> methods (Since 2.20.0</a><br/>
  * </b>
  *
  * <h3 id="0">0. <a class="meaningful_link" href="#mockito2" name="mockito2">Migrating to Mockito 2</a></h3>
@@ -111,7 +116,7 @@
  * see '<a href="https://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2">What's new in Mockito 2</a>' wiki page.
  * We hope that you enjoy Mockito 2!
  *
- * <h3 id="0.1">0.1. <a class="meaningful_link" href="#mockito" name="mockito-android">Mockito Android support</a></h3>
+ * <h3 id="0.1">0.1. <a class="meaningful_link" href="#mockito-android" name="mockito-android">Mockito Android support</a></h3>
  *
  * With Mockito version 2.6.1 we ship "native" Android support. To enable Android support, add the `mockito-android` library as dependency
  * to your project. This artifact is published to the same Mockito organization and can be imported for Android as follows:
@@ -521,15 +526,16 @@
  * any clean & simple code. However, if you do have a need to stub with the generic Answer interface, here is an example:
  *
  * <pre class="code"><code class="java">
- * when(mock.someMethod(anyString())).thenAnswer(new Answer() {
- *     Object answer(InvocationOnMock invocation) {
- *         Object[] args = invocation.getArguments();
- *         Object mock = invocation.getMock();
- *         return "called with arguments: " + args;
- *     }
+ * when(mock.someMethod(anyString())).thenAnswer(
+ *     new Answer() {
+ *         public Object answer(InvocationOnMock invocation) {
+ *             Object[] args = invocation.getArguments();
+ *             Object mock = invocation.getMock();
+ *             return "called with arguments: " + Arrays.toString(args);
+ *         }
  * });
  *
- * //the following prints "called with arguments: foo"
+ * //Following prints "called with arguments: [foo]"
  * System.out.println(mock.someMethod("foo"));
  * </code></pre>
  *
@@ -878,20 +884,17 @@
  * Examples:
  * <p>
  * <pre class="code"><code class="java">
- *   //passes when someMethod() is called within given time span
+ *   //passes when someMethod() is called no later than within 100 ms
+ *   //exits immediately when verification is satisfied (e.g. may not wait full 100 ms)
  *   verify(mock, timeout(100)).someMethod();
  *   //above is an alias to:
  *   verify(mock, timeout(100).times(1)).someMethod();
  *
- *   //passes when someMethod() is called <b>*exactly*</b> 2 times within given time span
+ *   //passes as soon as someMethod() has been called 2 times under 100 ms
  *   verify(mock, timeout(100).times(2)).someMethod();
  *
- *   //passes when someMethod() is called <b>*at least*</b> 2 times within given time span
+ *   //equivalent: this also passes as soon as someMethod() has been called 2 times under 100 ms
  *   verify(mock, timeout(100).atLeast(2)).someMethod();
- *
- *   //verifies someMethod() within given time span using given verification mode
- *   //useful only if you have your own custom verification modes.
- *   verify(mock, new Timeout(100, yourOwnVerificationMode)).someMethod();
  * </code></pre>
  *
  *
@@ -982,9 +985,9 @@
  *   details.getMockCreationSettings().getTypeToMock();
  *   details.getMockCreationSettings().getDefaultAnswer();
  *
- *   //Getting interactions and stubbings of the mock:
+ *   //Getting invocations and stubbings of the mock:
  *   MockingDetails details = mockingDetails(mock);
- *   details.getInteractions();
+ *   details.getInvocations();
  *   details.getStubbings();
  *
  *   //Printing all interactions (including stubbing, unused stubs)
@@ -1054,7 +1057,7 @@
  * then(person).should(times(2)).ride(bike);
  * </code></pre>
  *
- * For more information and an example see {@link BDDMockito#then(Object)}}
+ * For more information and an example see {@link BDDMockito#then(Object)}
  *
  *
  *
@@ -1166,7 +1169,7 @@
  * More information here {@link org.mockito.plugins.PluginSwitch}.
  *
  *
- * <h3 id="35">35. <a class="meaningful_link" href="#BDD_behavior_verification" name="BDD_behavior_verification">Custom verification failure message</a> (Since 2.1.0)</h3>
+ * <h3 id="35">35. <a class="meaningful_link" href="#Custom_verification_failure_message" name="Custom_verification_failure_message">Custom verification failure message</a> (Since 2.1.0)</h3>
  * <p>
  * Allows specifying a custom message to be printed if verification fails.
  * <p>
@@ -1211,7 +1214,7 @@
  *
  * // this can also be used when defining the behaviour of a mock under different inputs
  * // in this case if the input list was fewer than 3 items the mock returns null
- * when(mock.someMethod(argThat(list -> list.size()<3))).willReturn(null);
+ * when(mock.someMethod(argThat(list -> list.size()<3))).thenReturn(null);
  * </code></pre>
  *
  * <h3 id="37">37. <a class="meaningful_link" href="#Java_8_Custom_Answers" name="Java_8_Custom_Answers">Java 8 Custom Answer Support</a> (Since 2.1.0)</h3>
@@ -1325,10 +1328,6 @@
  * Currently, the feature is still optional as we wait for more feedback from the community.
  *
  * <p>
- * This feature is turned off by default because it is based on completely different mocking mechanism
- * that requires more feedback from the community.
- *
- * <p>
  * This alternative mock maker which uses
  * a combination of both Java instrumentation API and sub-classing rather than creating a new class to represent
  * a mock. This way, it becomes possible to mock final types and methods.
@@ -1371,7 +1370,7 @@
  * <code>org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker</code>
  *
  * <h3 id="40">40. <a class="meaningful_link" href="#strict_mockito" name="strict_mockito">
- *     (*new*) Improved productivity and cleaner tests with "stricter" Mockito</a> (Since 2.+)</h3>
+ *     Improved productivity and cleaner tests with "stricter" Mockito</a> (Since 2.+)</h3>
  *
  * To quickly find out how "stricter" Mockito can make you more productive and get your tests cleaner, see:
  * <ul>
@@ -1399,7 +1398,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.+)</a></h3>
+ *      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">
@@ -1452,7 +1451,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.+)</a></h3>
+ *       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>).
@@ -1472,7 +1471,7 @@
  * </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>
+ *       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>
@@ -1506,6 +1505,33 @@
  * <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>
+ *
+ * <h3 id="45">45. <a class="meaningful_link" href="#junit5_mockito" name="junit5_mockito">New JUnit Jupiter (JUnit5+) extension</a></h3>
+ *
+ * For integration with JUnit Jupiter (JUnit5+), use the `org.mockito:mockito-junit-jupiter` artifact.
+ * For more information about the usage of the integration, see <a href="http://javadoc.io/page/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">the JavaDoc of <code>MockitoExtension</code></a>.
+ *
+ * <h3 id="46">46. <a class="meaningful_link" href="#mockito_lenient" name="mockito_lenient">
+ *       New <code>Mockito.lenient()</code> and <code>MockSettings.lenient()</code> methods (Since 2.20.0)</a></h3>
+ *
+ * Strict stubbing feature is available since early Mockito 2.
+ * It is very useful because it drives cleaner tests and improved productivity.
+ * Strict stubbing reports unnecessary stubs, detects stubbing argument mismatch and makes the tests more DRY ({@link Strictness#STRICT_STUBS}).
+ * This comes with a trade-off: in some cases, you may get false negatives from strict stubbing.
+ * To remedy those scenarios you can now configure specific stubbing to be lenient, while all the other stubbings and mocks use strict stubbing:
+ *
+ * <pre class="code"><code class="java">
+ *   lenient().when(mock.foo()).thenReturn("ok");
+ * </code></pre>
+ *
+ * If you want all the stubbings on a given mock to be lenient, you can configure the mock accordingly:
+ *
+ * <pre class="code"><code class="java">
+ *   Foo mock = Mockito.mock(Foo.class, withSettings().lenient());
+ * </code></pre>
+ *
+ * For more information refer to {@link Mockito#lenient()}.
+ * Let us know how do you find the new feature by opening a GitHub issue to discuss!
  */
 @SuppressWarnings("unchecked")
 public class Mockito extends ArgumentMatchers {
@@ -1773,6 +1799,7 @@
      * @param classToMock class or interface to mock
      * @return mock object
      */
+    @CheckReturnValue
     public static <T> T mock(Class<T> classToMock) {
         return mock(classToMock, withSettings());
     }
@@ -1792,6 +1819,7 @@
      * @param name of the mock
      * @return mock object
      */
+    @CheckReturnValue
     public static <T> T mock(Class<T> classToMock, String name) {
         return mock(classToMock, withSettings()
                 .name(name)
@@ -1810,6 +1838,7 @@
      * @return A {@link org.mockito.MockingDetails} instance.
      * @since 1.9.5
      */
+    @CheckReturnValue
     public static MockingDetails mockingDetails(Object toInspect) {
         return MOCKITO_CORE.mockingDetails(toInspect);
     }
@@ -1833,6 +1862,7 @@
      *
      * @return mock object
      */
+    @CheckReturnValue
     public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
         return mock(classToMock, withSettings().defaultAnswer(defaultAnswer));
     }
@@ -1860,6 +1890,7 @@
      * @param mockSettings additional mock settings
      * @return mock object
      */
+    @CheckReturnValue
     public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
         return MOCKITO_CORE.mock(classToMock, mockSettings);
     }
@@ -1943,6 +1974,7 @@
      *            to spy on
      * @return a spy of the real object
      */
+    @CheckReturnValue
     public static <T> T spy(T object) {
         return MOCKITO_CORE.mock((Class<T>) object.getClass(), withSettings()
                 .spiedInstance(object)
@@ -1977,6 +2009,7 @@
      * @since 1.10.12
      */
     @Incubating
+    @CheckReturnValue
     public static <T> T spy(Class<T> classToSpy) {
         return MOCKITO_CORE.mock(classToSpy, withSettings()
                 .useConstructor()
@@ -2521,13 +2554,17 @@
      *
      * @return InOrder object to be used to verify in order
      */
+    @CheckReturnValue
     public static InOrder inOrder(Object... mocks) {
         return MOCKITO_CORE.inOrder(mocks);
     }
 
     /**
      * Ignores stubbed methods of given mocks for the sake of verification.
-     * Sometimes useful when coupled with <code>verifyNoMoreInteractions()</code> or verification <code>inOrder()</code>.
+     * Please consider using {@link Strictness#STRICT_STUBS} feature which eliminates the need for <code>ignoreStubs()</code>
+     * and provides other benefits.
+     * <p>
+     * <code>ignoreStubs()</code> is sometimes useful when coupled with <code>verifyNoMoreInteractions()</code> or verification <code>inOrder()</code>.
      * Helps avoiding redundant verification of stubbed calls - typically we're not interested in verifying stubs.
      * <p>
      * <b>Warning</b>, <code>ignoreStubs()</code> might lead to overuse of <code>verifyNoMoreInteractions(ignoreStubs(...));</code>
@@ -2572,17 +2609,31 @@
      * Ignoring stubs can be used with <b>verification in order</b>:
      * <pre class="code"><code class="java">
      *  List list = mock(List.class);
-     *  when(mock.get(0)).thenReturn("foo");
+     *  when(list.get(0)).thenReturn("foo");
      *
      *  list.add(0);
-     *  System.out.println(list.get(0)); //we don't want to verify this
      *  list.clear();
+     *  System.out.println(list.get(0)); //we don't want to verify this
      *
      *  InOrder inOrder = inOrder(ignoreStubs(list));
      *  inOrder.verify(list).add(0);
      *  inOrder.verify(list).clear();
      *  inOrder.verifyNoMoreInteractions();
      * </code></pre>
+     * Stubbed invocations are automatically verified with {@link Strictness#STRICT_STUBS} feature
+     * and it eliminates the need for <code>ignoreStubs()</code>. Example below uses JUnit Rules:
+     * <pre class="code"><code class="java">
+     *  &#064;Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+     *
+     *  List list = mock(List.class);
+     *  when(list.get(0)).thenReturn("foo");
+     *
+     *  list.size();
+     *  verify(list).size();
+     *
+     *  list.get(0); // Automatically verified by STRICT_STUBS
+     *  verifyNoMoreInteractions(list); // No need of ignoreStubs()
+     * </code></pre>
      *
      * @since 1.9.0
      * @param mocks input mocks that will be changed
@@ -2604,6 +2655,7 @@
      *
      * @return verification mode
      */
+    @CheckReturnValue
     public static VerificationMode times(int wantedNumberOfInvocations) {
         return VerificationModeFactory.times(wantedNumberOfInvocations);
     }
@@ -2625,6 +2677,7 @@
      *
      * @return verification mode
      */
+    @CheckReturnValue
     public static VerificationMode never() {
         return times(0);
     }
@@ -2640,6 +2693,7 @@
      *
      * @return verification mode
      */
+    @CheckReturnValue
     public static VerificationMode atLeastOnce() {
         return VerificationModeFactory.atLeastOnce();
     }
@@ -2656,6 +2710,7 @@
      *
      * @return verification mode
      */
+    @CheckReturnValue
     public static VerificationMode atLeast(int minNumberOfInvocations) {
         return VerificationModeFactory.atLeast(minNumberOfInvocations);
     }
@@ -2672,6 +2727,7 @@
      *
      * @return verification mode
      */
+    @CheckReturnValue
     public static VerificationMode atMost(int maxNumberOfInvocations) {
         return VerificationModeFactory.atMost(maxNumberOfInvocations);
     }
@@ -2689,6 +2745,7 @@
      * @param wantedNumberOfInvocations number of invocations to verify
      * @return  verification mode
      */
+    @CheckReturnValue
     public static VerificationMode calls( int wantedNumberOfInvocations ){
         return VerificationModeFactory.calls( wantedNumberOfInvocations );
     }
@@ -2709,72 +2766,65 @@
      *
      * @return verification mode
      */
+    @CheckReturnValue
     public static VerificationMode only() {
         return VerificationModeFactory.only();
     }
 
     /**
-     * Allows verifying with timeout. It causes a verify to wait for a specified period of time for a desired
-     * interaction rather than fails immediately if has not already happened. May be useful for testing in concurrent
-     * conditions.
+     * Verification will be triggered after given amount of millis, allowing testing of async code.
+     * Useful when interactions with the mock object did not happened yet.
+     * Extensive use of after() method can be a code smell - there are better ways of testing concurrent code.
      * <p>
-     * This differs from {@link Mockito#after after()} in that after() will wait the full period, unless
-     * the final test result is known early (e.g. if a never() fails), whereas timeout() will stop early as soon
-     * as verification passes, producing different behaviour when used with times(2), for example, which can pass
-     * and then later fail. In that case, timeout would pass as soon as times(2) passes, whereas after would run until
-     * times(2) failed, and then fail.
+     * See also {@link #after(long)} method for testing async code.
+     * Differences between {@code timeout()} and {@code after} are explained in Javadoc for {@link #after(long)}.
      * <p>
-     * This feature should be used rarely - figure out a better way of testing your multi-threaded system.
+     * Extensive use of {@code timeout()} method can be a code smell - there are better ways of testing concurrent code.
      * <pre class="code"><code class="java">
-     *   //passes when someMethod() is called within given time span
+     *   //passes when someMethod() is called no later than within 100 ms
+     *   //exits immediately when verification is satisfied (e.g. may not wait full 100 ms)
      *   verify(mock, timeout(100)).someMethod();
      *   //above is an alias to:
      *   verify(mock, timeout(100).times(1)).someMethod();
      *
-     *   //passes as soon as someMethod() has been called 2 times before the given timeout
+     *   //passes as soon as someMethod() has been called 2 times under 100 ms
      *   verify(mock, timeout(100).times(2)).someMethod();
      *
-     *   //equivalent: this also passes as soon as someMethod() has been called 2 times before the given timeout
+     *   //equivalent: this also passes as soon as someMethod() has been called 2 times under 100 ms
      *   verify(mock, timeout(100).atLeast(2)).someMethod();
-     *
-     *   //verifies someMethod() within given time span using given verification mode
-     *   //useful only if you have your own custom verification modes.
-     *   verify(mock, new Timeout(100, yourOwnVerificationMode)).someMethod();
      * </code></pre>
      *
      * See examples in javadoc for {@link Mockito} class
      *
-     * @param millis - time span in milliseconds
+     * @param millis - duration in milliseconds
      *
-     * @return verification mode
+     * @return object that allows fluent specification of the verification (times(x), atLeast(y), etc.)
      */
+    @CheckReturnValue
     public static VerificationWithTimeout timeout(long millis) {
         return new Timeout(millis, VerificationModeFactory.times(1));
     }
 
     /**
-     * Allows verifying over a given period. It causes a verify to wait for a specified period of time for a desired
-     * interaction rather than failing immediately if has not already happened. May be useful for testing in concurrent
-     * conditions.
-     * <p>
-     * This differs from {@link Mockito#timeout timeout()} in that after() will wait the full period, whereas timeout()
-     * will stop early as soon as verification passes, producing different behaviour when used with times(2), for example,
-     * which can pass and then later fail. In that case, timeout would pass as soon as times(2) passes, whereas after would
-     * run the full time, which point it will fail, as times(2) has failed.
-     * <p>
-     * This feature should be used rarely - figure out a better way of testing your multi-threaded system.
+     * Verification will be triggered after given amount of millis, allowing testing of async code.
+     * Useful when interactions with the mock object did not happened yet.
+     * Extensive use of after() method can be a code smell - there are better ways of testing concurrent code.
      * <p>
      * Not yet implemented to work with InOrder verification.
+     * <p>
+     * See also {@link #timeout(long)} method for testing async code.
+     * Differences between {@code timeout()} and {@code after()} are explained below.
+     *
      * <pre class="code"><code class="java">
      *   //passes after 100ms, if someMethod() has only been called once at that time.
      *   verify(mock, after(100)).someMethod();
      *   //above is an alias to:
      *   verify(mock, after(100).times(1)).someMethod();
      *
-     *   //passes if someMethod() is called <b>*exactly*</b> 2 times after the given timespan
+     *   //passes if someMethod() is called <b>*exactly*</b> 2 times, as tested after 100 millis
      *   verify(mock, after(100).times(2)).someMethod();
      *
-     *   //passes if someMethod() has not been called after the given timespan
+     *   //passes if someMethod() has not been called, as tested after 100 millis
      *   verify(mock, after(100).never()).someMethod();
      *
      *   //verifies someMethod() after a given time span using given verification mode
@@ -2782,12 +2832,31 @@
      *   verify(mock, new After(100, yourOwnVerificationMode)).someMethod();
      * </code></pre>
      *
+     * <strong>timeout() vs. after()</strong>
+     * <ul>
+     *     <li>timeout() exits immediately with success when verification passes</li>
+     *     <li>after() awaits full duration to check if verification passes</li>
+     * </ul>
+     * Examples:
+     * <pre class="code"><code class="java">
+     *   //1.
+     *   mock.foo();
+     *   verify(mock, after(1000)).foo();
+     *   //waits 1000 millis and succeeds
+     *
+     *   //2.
+     *   mock.foo();
+     *   verify(mock, timeout(1000)).foo();
+     *   //succeeds immediately
+     * </code></pre>
+     *
      * See examples in javadoc for {@link Mockito} class
      *
-     * @param millis - time span in milliseconds
+     * @param millis - duration in milliseconds
      *
-     * @return verification mode
+     * @return object that allows fluent specification of the verification
      */
+    @CheckReturnValue
     public static VerificationAfterDelay after(long millis) {
         return new After(millis, VerificationModeFactory.times(1));
     }
@@ -2871,6 +2940,7 @@
      *
      * @return mock settings instance with defaults.
      */
+    @CheckReturnValue
     public static MockSettings withSettings() {
         return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS);
     }
@@ -2884,6 +2954,7 @@
      * @return verification mode
      * @since 2.1.0
      */
+    @CheckReturnValue
     public static VerificationMode description(String description) {
         return times(1).description(description);
     }
@@ -2893,6 +2964,7 @@
      * An instance of {@code MockingDetails} can be retrieved via {@link #mockingDetails(Object)}.
      */
     @Deprecated
+    @CheckReturnValue
     static MockitoDebugger debug() {
         return new MockitoDebuggerImpl();
     }
@@ -2903,6 +2975,7 @@
      * @since 2.1.0
      */
     @Incubating
+    @CheckReturnValue
     public static MockitoFramework framework() {
         return new DefaultMockitoFramework();
     }
@@ -2916,7 +2989,76 @@
      * @since 2.7.0
      */
     @Incubating
+    @CheckReturnValue
     public static MockitoSessionBuilder mockitoSession() {
         return new DefaultMockitoSessionBuilder();
     }
+
+    /**
+     * Lenient stubs bypass "strict stubbing" validation (see {@link Strictness#STRICT_STUBS}).
+     * When stubbing is declared as lenient, it will not be checked for potential stubbing problems such as
+     * 'unnecessary stubbing' ({@link UnnecessaryStubbingException}) or for 'stubbing argument mismatch' {@link PotentialStubbingProblem}.
+     *
+     * <pre class="code"><code class="java">
+     *   lenient().when(mock.foo()).thenReturn("ok");
+     * </code></pre>
+     *
+     * Most mocks in most tests don't need leniency and should happily prosper with {@link Strictness#STRICT_STUBS}.
+     * <ul>
+     *     <li>If a specific stubbing needs to be lenient - use this method</li>
+     *     <li>If a specific mock need to have stubbings lenient - use {@link MockSettings#lenient()}</li>
+     *     <li>If a specific test method / test class needs to have all stubbings lenient
+     *          - configure strictness using our JUnit support ({@link MockitoJUnit} or Mockito Session ({@link MockitoSession})</li>
+     *
+     * <h3>Elaborate example</h3>
+     *
+     * In below example, 'foo.foo()' is a stubbing that was moved to 'before()' method to avoid duplication.
+     * Doing so makes one of the test methods ('test3()') fail with 'unnecessary stubbing'.
+     * To resolve it we can configure 'foo.foo()' stubbing in 'before()' method to be lenient.
+     * Alternatively, we can configure entire 'foo' mock as lenient.
+     * <p>
+     * This example is simplified and not realistic.
+     * Pushing stubbings to 'before()' method may cause tests to be less readable.
+     * Some repetition in tests is OK, use your own judgement to write great tests!
+     * It is not desired to eliminate all possible duplication from the test code
+     * because it may add complexity and conceal important test information.
+     *
+     * <pre class="code"><code class="java">
+     * public class SomeTest {
+     *
+     *     &#064;Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(STRICT_STUBS);
+     *
+     *     &#064;Mock Foo foo;
+     *     &#064;Mock Bar bar;
+     *
+     *     &#064;Before public void before() {
+     *         when(foo.foo()).thenReturn("ok");
+     *
+     *         // it is better to configure the stubbing to be lenient:
+     *         // lenient().when(foo.foo()).thenReturn("ok");
+     *
+     *         // or the entire mock to be lenient:
+     *         // foo = mock(Foo.class, withSettings().lenient());
+     *     }
+     *
+     *     &#064;Test public void test1() {
+     *         foo.foo();
+     *     }
+     *
+     *     &#064;Test public void test2() {
+     *         foo.foo();
+     *     }
+     *
+     *     &#064;Test public void test3() {
+     *         bar.bar();
+     *     }
+     * }
+     * </code></pre>
+     *
+     * @since 2.20.0
+     */
+    @Incubating
+    public static LenientStubber lenient() {
+        return MOCKITO_CORE.lenient();
+    }
 }
diff --git a/src/main/java/org/mockito/codegen/InjectionBase.java b/src/main/java/org/mockito/codegen/InjectionBase.java
new file mode 100644
index 0000000..b582c3b
--- /dev/null
+++ b/src/main/java/org/mockito/codegen/InjectionBase.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.codegen;
+
+/**
+ * This class is required to resolve a method handle lookup for the {@code org.mockito.codegen} package what requires a preexisting class for the package.
+ * By defining this class, the JVM (starting from Java 9) assures that this package is a part of the Mockito module such that we gain full access rights.
+ */
+public class InjectionBase {
+
+    private InjectionBase() {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java b/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
index 42e990d..5eb6a77 100644
--- a/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
+++ b/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
@@ -5,8 +5,8 @@
 package org.mockito.exceptions.misusing;
 
 import org.mockito.Mockito;
-import org.mockito.quality.Strictness;
 import org.mockito.exceptions.base.MockitoException;
+import org.mockito.quality.Strictness;
 
 /**
  * {@code PotentialStubbingProblem} improves productivity by failing the test early when the user
@@ -53,23 +53,7 @@
  *  It is a well known limitation of Mockito API and another example how Mockito optimizes its clean API for 95% of the cases
  *  while still supporting edge cases.
  *  </li>
- *  <li>Reduce the strictness level in the test method (only for JUnit Rules):
- * <pre class="code"><code class="java">
- * public class ExampleTest {
- *     &#064;Rule
- *     public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
- *
- *     &#064;Test public void exampleTest() {
- *         //Change the strictness level only for this test method:
- *         mockito.strictness(Strictness.LENIENT);
- *
- *         //remaining test code
- *     }
- * }
- * </code></pre>
- *  Currently, reducing strictness is only available to JUnit rules.
- *  If you need it in a different context let us know at <a href="https://github.com/mockito/mockito/issues/857">issue 857</a>.
- *  </li>
+ *  <li>Reduce the strictness level per stubbing, per mock or per test - see {@link Mockito#lenient()}</li>
  *  <li>To opt-out in Mockito 2.x, simply remove the strict stubbing setting in the test class.</li>
  * </ol>
  * <p>
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java b/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
index c8713b3..2d4605b 100644
--- a/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
@@ -4,23 +4,22 @@
  */
 package org.mockito.exceptions.misusing;
 
+import org.mockito.Mockito;
 import org.mockito.MockitoSession;
 import org.mockito.exceptions.base.MockitoException;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.junit.MockitoRule;
-import org.mockito.quality.MockitoHint;
-import org.mockito.quality.Strictness;
 
 /**
  * This exception indicates presence of unused stubbings.
  * It is highly recommended to remove unused stubbings to keep the codebase clean.
- * You can opt-out from detecting unused stubbings by configuring:
- * <ul>
- *     <li>JUnit rule - {@link MockitoRule#strictness(Strictness)} or {@link MockitoRule#silent()}</li>
- *     <li>JUnit runner - {@link MockitoJUnitRunner.Silent}</li>
- *     <li>Mockito session - {@link MockitoSession}</li>
- * </ul>
- * For more information about detecting unused stubbings, see {@link MockitoHint}.
+ * In a rare scenario that unused stubbing is a false negative you can opt out from the validation via
+ * (in order of ascending scope):
+ * <ol>
+ *     <li>Declaring specific stubbing as 'lenient' - {@link Mockito#lenient()}</li>
+ *     <li>Declaring specific mock as 'lenient' - {@link org.mockito.MockSettings#lenient()}</li>
+ *     <li>Declaring all mocks in given test class or test method mock as 'lenient' with
+ *          our JUnit support ({@link org.mockito.junit.MockitoJUnit}) or Mockito session ({@link MockitoSession})</li>
+ * </ol>
+ *
  * <p>
  * Unnecessary stubbings are stubbed method calls that were never realized during test execution. Example:
  * <pre class="code"><code class="java">
@@ -45,11 +44,6 @@
  * Mockito JUnit Runner triggers <code>UnnecessaryStubbingException</code> only when none of the test methods use the stubbings.
  * This means that it is ok to put default stubbing in a 'setup' method or in test class constructor.
  * That default stubbing needs to be used at least once by one of the test methods.
- * <p>
- * To find out more about detecting unused stubbings see {@link MockitoHint}.
- * See javadoc for {@link MockitoRule} to understand the behavior or Mockito JUnit Rules.
- * See javadoc for {@link MockitoJUnitRunner} to find out how Mockito JUnit Runner detects unused stubs.
- * See javadoc for {@link MockitoSession} to find out about detecting unused stubs without JUnit.
  */
 public class UnnecessaryStubbingException extends MockitoException {
     public UnnecessaryStubbingException(String message) {
diff --git a/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
new file mode 100644
index 0000000..c3c0ed4
--- /dev/null
+++ b/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockito.exceptions.verification;
+
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+/**
+ * Thrown when atMost(x) verification fails. See {@link org.mockito.Mockito#atMost(int)}.
+ *
+ * @since 2.20.5
+ */
+public class MoreThanAllowedActualInvocations extends MockitoAssertionError {
+
+    public MoreThanAllowedActualInvocations(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java
index 419d228..68b580a 100644
--- a/src/main/java/org/mockito/internal/MockitoCore.java
+++ b/src/main/java/org/mockito/internal/MockitoCore.java
@@ -12,6 +12,7 @@
 import org.mockito.internal.invocation.finder.VerifiableInvocationsFinder;
 import org.mockito.internal.listeners.VerificationStartedNotifier;
 import org.mockito.internal.progress.MockingProgress;
+import org.mockito.internal.stubbing.DefaultLenientStubber;
 import org.mockito.internal.stubbing.InvocationContainerImpl;
 import org.mockito.internal.stubbing.OngoingStubbingImpl;
 import org.mockito.internal.stubbing.StubberImpl;
@@ -25,6 +26,8 @@
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.LenientStubber;
 import org.mockito.stubbing.OngoingStubbing;
 import org.mockito.stubbing.Stubber;
 import org.mockito.verification.VerificationMode;
@@ -41,6 +44,7 @@
 import static org.mockito.internal.exceptions.Reporter.nullPassedToVerify;
 import static org.mockito.internal.exceptions.Reporter.nullPassedToVerifyNoMoreInteractions;
 import static org.mockito.internal.exceptions.Reporter.nullPassedWhenCreatingInOrder;
+import static org.mockito.internal.exceptions.Reporter.stubPassedToVerify;
 import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
 import static org.mockito.internal.util.MockUtil.createMock;
 import static org.mockito.internal.util.MockUtil.getInvocationContainer;
@@ -88,7 +92,9 @@
             throw notAMockPassedToVerify(mock.getClass());
         }
         MockHandler handler = mockingDetails.getMockHandler();
-
+        if (handler.getMockSettings().isStubOnly()) {
+            throw stubPassedToVerify();
+        }
         mock = (T) VerificationStartedNotifier.notifyVerificationStarted(
             handler.getMockSettings().getVerificationStartedListeners(), mockingDetails);
 
@@ -165,10 +171,14 @@
     }
 
     public Stubber stubber() {
+        return stubber(null);
+    }
+
+    public Stubber stubber(Strictness strictness) {
         MockingProgress mockingProgress = mockingProgress();
         mockingProgress.stubbingStarted();
         mockingProgress.resetOngoingStubbing();
-        return new StubberImpl();
+        return new StubberImpl(strictness);
     }
 
     public void validateMockitoUsage() {
@@ -202,4 +212,8 @@
     public MockingDetails mockingDetails(Object toInspect) {
         return new DefaultMockingDetails(toInspect);
     }
+
+    public LenientStubber lenient() {
+        return new DefaultLenientStubber();
+    }
 }
diff --git a/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java b/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
index 2f6757d..91086d2 100644
--- a/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
+++ b/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
@@ -14,13 +14,18 @@
  * Instantiates a mock on a field annotated by {@link Mock}
  */
 public class MockAnnotationProcessor implements FieldAnnotationProcessor<Mock> {
+    @Override
     public Object process(Mock annotation, Field field) {
+        return processAnnotationForMock(annotation, field.getType(), field.getName());
+    }
+
+    public static Object processAnnotationForMock(Mock annotation, Class<?> type, String name) {
         MockSettings mockSettings = Mockito.withSettings();
         if (annotation.extraInterfaces().length > 0) { // never null
             mockSettings.extraInterfaces(annotation.extraInterfaces());
         }
         if ("".equals(annotation.name())) {
-            mockSettings.name(field.getName());
+            mockSettings.name(name);
         } else {
             mockSettings.name(annotation.name());
         }
@@ -33,6 +38,6 @@
 
         // see @Mock answer default value
         mockSettings.defaultAnswer(annotation.answer());
-        return Mockito.mock(field.getType(), mockSettings);
+        return Mockito.mock(type, mockSettings);
     }
 }
diff --git a/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java b/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
index a80efbe..92d045d 100644
--- a/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
+++ b/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
@@ -140,7 +140,7 @@
         for (Class<? extends Annotation> u : undesiredAnnotations) {
             if (field.isAnnotationPresent(u)) {
                 throw unsupportedCombinationOfAnnotations(annotation.getSimpleName(),
-                                                          annotation.getClass().getSimpleName());
+                                                          u.getSimpleName());
             }
         }
     }
diff --git a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
index 82af98a..ca67730 100644
--- a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
+++ b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
@@ -226,6 +226,12 @@
         return validatedSettings(typeToMock, (CreationSettings<T>) this);
     }
 
+    @Override
+    public MockSettings lenient() {
+        this.lenient = true;
+        return this;
+    }
+
     private static <T> CreationSettings<T> validatedSettings(Class<T> typeToMock, CreationSettings<T> source) {
         MockCreationValidator validator = new MockCreationValidator();
 
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
index 7d60f6c..64139c2 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
@@ -15,6 +15,7 @@
 import net.bytebuddy.description.method.ParameterDescription;
 import net.bytebuddy.description.type.TypeDescription;
 import net.bytebuddy.dynamic.ClassFileLocator;
+import net.bytebuddy.dynamic.scaffold.MethodGraph;
 import net.bytebuddy.dynamic.scaffold.TypeValidation;
 import net.bytebuddy.implementation.Implementation;
 import net.bytebuddy.jar.asm.ClassVisitor;
@@ -22,6 +23,7 @@
 import net.bytebuddy.jar.asm.Opcodes;
 import net.bytebuddy.matcher.ElementMatchers;
 import net.bytebuddy.pool.TypePool;
+import net.bytebuddy.utility.OpenedClassReader;
 import net.bytebuddy.utility.RandomString;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.util.concurrent.WeakConcurrentMap;
@@ -29,7 +31,6 @@
 import org.mockito.mock.SerializableMode;
 
 import java.lang.instrument.ClassFileTransformer;
-import java.lang.instrument.IllegalClassFormatException;
 import java.lang.instrument.Instrumentation;
 import java.lang.reflect.Modifier;
 import java.security.ProtectionDomain;
@@ -44,6 +45,8 @@
 
 public class InlineBytecodeGenerator implements BytecodeGenerator, ClassFileTransformer {
 
+    private static final String PRELOAD = "org.mockito.inline.preload";
+
     @SuppressWarnings("unchecked")
     static final Set<Class<?>> EXCLUDES = new HashSet<Class<?>>(Arrays.asList(Class.class,
             Boolean.class,
@@ -62,34 +65,75 @@
 
     private final WeakConcurrentSet<Class<?>> mocked;
 
-    private final String identifier;
-
-    private final MockMethodAdvice advice;
-
     private final BytecodeGenerator subclassEngine;
 
+    private final AsmVisitorWrapper mockTransformer;
+
     private volatile Throwable lastException;
 
     public InlineBytecodeGenerator(Instrumentation instrumentation, WeakConcurrentMap<Object, MockMethodInterceptor> mocks) {
+        preload();
         this.instrumentation = instrumentation;
         byteBuddy = new ByteBuddy()
-                .with(TypeValidation.DISABLED)
-                .with(Implementation.Context.Disabled.Factory.INSTANCE);
+            .with(TypeValidation.DISABLED)
+            .with(Implementation.Context.Disabled.Factory.INSTANCE)
+            .with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE);
         mocked = new WeakConcurrentSet<Class<?>>(WeakConcurrentSet.Cleaner.INLINE);
-        identifier = RandomString.make();
-        advice = new MockMethodAdvice(mocks, identifier);
+        String identifier = RandomString.make();
         subclassEngine = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(withDefaultConfiguration()
-                .withBinders(of(MockMethodAdvice.Identifier.class, identifier))
-                .to(MockMethodAdvice.ForReadObject.class), isAbstract().or(isNative()).or(isToString())), false);
-        MockMethodDispatcher.set(identifier, advice);
+            .withBinders(of(MockMethodAdvice.Identifier.class, identifier))
+            .to(MockMethodAdvice.ForReadObject.class), isAbstract().or(isNative()).or(isToString())), false);
+        mockTransformer = new AsmVisitorWrapper.ForDeclaredMethods()
+            .method(isVirtual()
+                    .and(not(isBridge().or(isHashCode()).or(isEquals()).or(isDefaultFinalizer())))
+                    .and(not(isDeclaredBy(nameStartsWith("java.")).<MethodDescription>and(isPackagePrivate()))),
+                Advice.withCustomMapping()
+                    .bind(MockMethodAdvice.Identifier.class, identifier)
+                    .to(MockMethodAdvice.class))
+            .method(isHashCode(),
+                Advice.withCustomMapping()
+                    .bind(MockMethodAdvice.Identifier.class, identifier)
+                    .to(MockMethodAdvice.ForHashCode.class))
+            .method(isEquals(),
+                Advice.withCustomMapping()
+                    .bind(MockMethodAdvice.Identifier.class, identifier)
+                    .to(MockMethodAdvice.ForEquals.class));
+        MockMethodDispatcher.set(identifier, new MockMethodAdvice(mocks, identifier));
         instrumentation.addTransformer(this, true);
     }
 
+    /**
+     * Mockito allows to mock about any type, including such types that we are relying on ourselves. This can cause a circularity:
+     * In order to check if an instance is a mock we need to look up if this instance is registered in the {@code mocked} set. But to look
+     * up this instance, we need to create key instances that rely on weak reference properties. Loading the later classes will happen before
+     * the key instances are completed what will cause Mockito to check if those key instances are themselves mocks what causes a loop which
+     * results in a circularity error. This is not normally a problem as we explicitly check if the instance that we investigate is one of
+     * our instance of which we hold a reference by reference equality what does not cause any code execution. But it seems like the load
+     * order plays a role here with unloaded types being loaded before we even get to check the mock instance property. To avoid this, we are
+     * making sure that crucuial JVM types are loaded before we create the first inline mock. Unfortunately, these types dependant on a JVM's
+     * implementation and we can only maintain types that we know of from well-known JVM implementations such as HotSpot and extend this list
+     * once we learn of further problematic types for future Java versions. To allow users to whitelist their own types, we do not also offer
+     * a property that allows running problematic tests before a new Mockito version can be released and that allows us to ask users to
+     * easily validate that whitelisting actually solves a problem as circularities could also be caused by other problems.
+     */
+    private static void preload() {
+        String preloads = System.getProperty(PRELOAD);
+        if (preloads == null) {
+            preloads = "java.lang.WeakPairMap,java.lang.WeakPairMap$Pair,java.lang.WeakPairMap$Pair$Weak";
+        }
+        for (String preload : preloads.split(",")) {
+            try {
+                Class.forName(preload, false, null);
+            } catch (ClassNotFoundException ignored) {
+            }
+        }
+    }
+
     @Override
     public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
         boolean subclassingRequired = !features.interfaces.isEmpty()
-                || features.serializableMode != SerializableMode.NONE
-                || Modifier.isAbstract(features.mockedType.getModifiers());
+            || features.serializableMode != SerializableMode.NONE
+            || Modifier.isAbstract(features.mockedType.getModifiers());
 
         checkSupportedCombination(subclassingRequired, features);
 
@@ -157,29 +201,19 @@
                             String className,
                             Class<?> classBeingRedefined,
                             ProtectionDomain protectionDomain,
-                            byte[] classfileBuffer) throws IllegalClassFormatException {
+                            byte[] classfileBuffer) {
         if (classBeingRedefined == null
-                || !mocked.contains(classBeingRedefined)
-                || EXCLUDES.contains(classBeingRedefined)) {
+            || !mocked.contains(classBeingRedefined)
+            || EXCLUDES.contains(classBeingRedefined)) {
             return null;
         } else {
             try {
                 return byteBuddy.redefine(classBeingRedefined, ClassFileLocator.Simple.of(classBeingRedefined.getName(), classfileBuffer))
-                        // Note: The VM erases parameter meta data from the provided class file (bug). We just add this information manually.
-                        .visit(new ParameterWritingVisitorWrapper(classBeingRedefined))
-                        .visit(Advice.withCustomMapping()
-                                .bind(MockMethodAdvice.Identifier.class, identifier)
-                                .to(MockMethodAdvice.class).on(isVirtual()
-                                        .and(not(isBridge().or(isHashCode()).or(isEquals()).or(isDefaultFinalizer())))
-                                        .and(not(isDeclaredBy(nameStartsWith("java.")).<MethodDescription>and(isPackagePrivate())))))
-                        .visit(Advice.withCustomMapping()
-                                .bind(MockMethodAdvice.Identifier.class, identifier)
-                                .to(MockMethodAdvice.ForHashCode.class).on(isHashCode()))
-                        .visit(Advice.withCustomMapping()
-                                .bind(MockMethodAdvice.Identifier.class, identifier)
-                                .to(MockMethodAdvice.ForEquals.class).on(isEquals()))
-                        .make()
-                        .getBytes();
+                    // Note: The VM erases parameter meta data from the provided class file (bug). We just add this information manually.
+                    .visit(new ParameterWritingVisitorWrapper(classBeingRedefined))
+                    .visit(mockTransformer)
+                    .make()
+                    .getBytes();
             } catch (Throwable throwable) {
                 lastException = throwable;
                 return null;
@@ -214,7 +248,7 @@
             private final TypeDescription typeDescription;
 
             private ParameterAddingClassVisitor(ClassVisitor cv, TypeDescription typeDescription) {
-                super(Opcodes.ASM5, cv);
+                super(OpenedClassReader.ASM_API, cv);
                 this.typeDescription = typeDescription;
             }
 
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
index dc5c6e5..b659c73 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
@@ -38,6 +38,8 @@
 
 class SubclassBytecodeGenerator implements BytecodeGenerator {
 
+    private static final String CODEGEN_PACKAGE = "org.mockito.codegen.";
+
     private final SubclassLoader loader;
 
     private final ByteBuddy byteBuddy;
@@ -46,6 +48,11 @@
     private final Implementation readReplace;
     private final ElementMatcher<? super MethodDescription> matcher;
 
+    private final Implementation dispatcher = to(DispatcherDefaultingToRealMethod.class);
+    private final Implementation hashCode = to(MockMethodInterceptor.ForHashCode.class);
+    private final Implementation equals = to(MockMethodInterceptor.ForEquals.class);
+    private final Implementation writeReplace = to(MockMethodInterceptor.ForWriteReplace.class);
+
     public SubclassBytecodeGenerator() {
         this(new SubclassInjectionLoader());
     }
@@ -68,31 +75,32 @@
 
     @Override
     public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
+        String name = nameFor(features.mockedType);
         DynamicType.Builder<T> builder =
                 byteBuddy.subclass(features.mockedType)
-                         .name(nameFor(features.mockedType))
+                         .name(name)
                          .ignoreAlso(isGroovyMethod())
                          .annotateType(features.stripAnnotations
                              ? new Annotation[0]
                              : features.mockedType.getAnnotations())
                          .implement(new ArrayList<Type>(features.interfaces))
                          .method(matcher)
-                           .intercept(to(DispatcherDefaultingToRealMethod.class))
+                           .intercept(dispatcher)
                            .transform(withModifiers(SynchronizationState.PLAIN))
                            .attribute(features.stripAnnotations
                                ? MethodAttributeAppender.NoOp.INSTANCE
                                : INCLUDING_RECEIVER)
                          .method(isHashCode())
-                           .intercept(to(MockMethodInterceptor.ForHashCode.class))
+                           .intercept(hashCode)
                          .method(isEquals())
-                           .intercept(to(MockMethodInterceptor.ForEquals.class))
+                           .intercept(equals)
                          .serialVersionUid(42L)
                          .defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE)
                          .implement(MockAccess.class)
                            .intercept(FieldAccessor.ofBeanProperty());
         if (features.serializableMode == SerializableMode.ACROSS_CLASSLOADERS) {
             builder = builder.implement(CrossClassLoaderSerializableMock.class)
-                             .intercept(to(MockMethodInterceptor.ForWriteReplace.class));
+                             .intercept(writeReplace);
         }
         if (readReplace != null) {
             builder = builder.defineMethod("readObject", void.class, Visibility.PRIVATE)
@@ -118,7 +126,7 @@
                 .or(hasParameters(whereAny(hasType(isPackagePrivate())))));
         }
         return builder.make()
-                      .load(classLoader, loader.getStrategy(features.mockedType))
+                      .load(classLoader, loader.resolveStrategy(features.mockedType, classLoader, name.startsWith(CODEGEN_PACKAGE)))
                       .getLoaded();
     }
 
@@ -132,7 +140,7 @@
         if (isComingFromJDK(type)
                 || isComingFromSignedJar(type)
                 || isComingFromSealedPackage(type)) {
-            typeName = "codegen." + typeName;
+            typeName = CODEGEN_PACKAGE + type.getSimpleName();
         }
         return String.format("%s$%s$%d", typeName, "MockitoMock", Math.abs(random.nextInt()));
     }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
index 20125f1..454dd8e 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
@@ -4,12 +4,104 @@
  */
 package org.mockito.internal.creation.bytebuddy;
 
+import net.bytebuddy.dynamic.loading.ClassInjector;
 import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import org.mockito.codegen.InjectionBase;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.Platform;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import static org.mockito.internal.util.StringUtil.join;
 
 class SubclassInjectionLoader implements SubclassLoader {
 
+    private static final String ERROR_MESSAGE = join("The current JVM does not support any class injection mechanism.",
+        "",
+        "Currently, Mockito supports injection via neither by method handle lookups or using sun.misc.Unsafe",
+        "Neither seems to be available on your current JVM.");
+
+    private final SubclassLoader loader;
+
+    SubclassInjectionLoader() {
+        if (!Boolean.getBoolean("org.mockito.internal.simulateJava11") && ClassInjector.UsingReflection.isAvailable()) {
+            this.loader = new WithReflection();
+        } else if (ClassInjector.UsingLookup.isAvailable()) {
+            this.loader = tryLookup();
+        } else {
+            throw new MockitoException(join(ERROR_MESSAGE, "", Platform.describe()));
+        }
+    }
+
+    private static SubclassLoader tryLookup() {
+        try {
+            Class<?> methodHandles = Class.forName("java.lang.invoke.MethodHandles");
+            Object lookup = methodHandles.getMethod("lookup").invoke(null);
+            Method privateLookupIn = methodHandles.getMethod("privateLookupIn", Class.class, Class.forName("java.lang.invoke.MethodHandles$Lookup"));
+            Object codegenLookup = privateLookupIn.invoke(null, InjectionBase.class, lookup);
+            return new WithLookup(lookup, codegenLookup, privateLookupIn);
+        } catch (Exception exception) {
+            throw new MockitoException(join(ERROR_MESSAGE, "", Platform.describe()), exception);
+        }
+    }
+
+    private static class WithReflection implements SubclassLoader {
+
+        @Override
+        public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
+            return ClassLoadingStrategy.Default.INJECTION.with(codegen ? InjectionBase.class.getProtectionDomain() : mockedType.getProtectionDomain());
+        }
+    }
+
+    private static class WithLookup implements SubclassLoader {
+
+        private final Object lookup;
+
+        private final Object codegenLookup;
+
+        private final Method privateLookupIn;
+
+        WithLookup(Object lookup, Object codegenLookup, Method privateLookupIn) {
+            this.lookup = lookup;
+            this.codegenLookup = codegenLookup;
+            this.privateLookupIn = privateLookupIn;
+        }
+
+        @Override
+        public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
+            if (codegen) {
+                return ClassLoadingStrategy.UsingLookup.of(codegenLookup);
+            } else if (classLoader != mockedType.getClassLoader()) {
+                return ClassLoadingStrategy.Default.WRAPPER.with(mockedType.getProtectionDomain());
+            } else {
+                try {
+                    Object privateLookup;
+                    try {
+                        privateLookup = privateLookupIn.invoke(null, mockedType, lookup);
+                    } catch (InvocationTargetException exception) {
+                        if (exception.getCause() instanceof IllegalAccessException) {
+                            return ClassLoadingStrategy.Default.WRAPPER.with(mockedType.getProtectionDomain());
+                        } else {
+                            throw exception.getCause();
+                        }
+                    }
+                    return ClassLoadingStrategy.UsingLookup.of(privateLookup);
+                } catch (Throwable exception) {
+                    throw new MockitoException(join(
+                        "The Java module system prevents Mockito from defining a mock class in the same package as " + mockedType,
+                        "",
+                        "To overcome this, you must open and export the mocked type to Mockito.",
+                        "Remember that you can also do so programmatically if the mocked class is defined by the same module as your test code",
+                        exception
+                    ));
+                }
+            }
+        }
+    }
+
     @Override
-    public ClassLoadingStrategy<ClassLoader> getStrategy(Class<?> mockedType) {
-        return ClassLoadingStrategy.Default.INJECTION.with(mockedType.getProtectionDomain());
+    public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
+        return loader.resolveStrategy(mockedType, classLoader, codegen);
     }
 }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
index 80b17ac..194c282 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
@@ -6,8 +6,18 @@
 
 import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
 
+/**
+ * A subclass loader is responsible for resolving a class loading strategy for a mock that is implemented as a subclass.
+ */
 public interface SubclassLoader {
 
-    ClassLoadingStrategy<ClassLoader> getStrategy(Class<?> mockedType);
-
+    /**
+     * Resolves a class loading strategy.
+     *
+     * @param mockedType  The type being mocked.
+     * @param classLoader The class loader being used.
+     * @param codegen     {@code true} if the mock is loaded in the {@code org.mockito.codegen} package.
+     * @return An appropriate class loading strategy.
+     */
+    ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen);
 }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
index 34c31fe..ea51edf 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
@@ -36,7 +36,7 @@
                         public Class<?> call() throws Exception {
                             return bytecodeGenerator.mockClass(params);
                         }
-                    }, classLoader == null ? BOOTSTRAP_LOCK : classLoader);
+                    }, BOOTSTRAP_LOCK);
         } catch (IllegalArgumentException exception) {
             Throwable cause = exception.getCause();
             if (cause instanceof RuntimeException) {
diff --git a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
index 4befa99..03afd80 100644
--- a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
+++ b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
@@ -37,6 +37,7 @@
     private boolean useConstructor;
     private Object outerClassInstance;
     private Object[] constructorArgs;
+    protected boolean lenient;
 
     public CreationSettings() {}
 
@@ -55,6 +56,7 @@
         this.useConstructor = copy.isUsingConstructor();
         this.outerClassInstance = copy.getOuterClassInstance();
         this.constructorArgs = copy.getConstructorArgs();
+        this.lenient = copy.lenient;
     }
 
     @Override
@@ -153,4 +155,9 @@
     public boolean isStubOnly() {
         return stubOnly;
     }
+
+    @Override
+    public boolean isLenient() {
+        return lenient;
+    }
 }
diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java
index 57094c0..2bc4445 100644
--- a/src/main/java/org/mockito/internal/exceptions/Reporter.java
+++ b/src/main/java/org/mockito/internal/exceptions/Reporter.java
@@ -8,6 +8,7 @@
 import org.mockito.exceptions.base.MockitoAssertionError;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.misusing.*;
+import org.mockito.exceptions.verification.MoreThanAllowedActualInvocations;
 import org.mockito.exceptions.verification.NeverWantedButInvoked;
 import org.mockito.exceptions.verification.NoInteractionsWanted;
 import org.mockito.exceptions.verification.SmartNullPointerException;
@@ -358,63 +359,71 @@
         ));
     }
 
-    public static MockitoAssertionError tooManyActualInvocations(int wantedCount, int actualCount, DescribedInvocation wanted, Location firstUndesired) {
-        String message = createTooManyInvocationsMessage(wantedCount, actualCount, wanted, firstUndesired);
+    public static MockitoAssertionError tooManyActualInvocations(int wantedCount, int actualCount, DescribedInvocation wanted, List<Location> locations) {
+        String message = createTooManyInvocationsMessage(wantedCount, actualCount, wanted, locations);
         return new TooManyActualInvocations(message);
     }
 
     private static String createTooManyInvocationsMessage(int wantedCount, int actualCount, DescribedInvocation wanted,
-                                                          Location firstUndesired) {
+                                                          List<Location> invocations) {
         return join(
                 wanted.toString(),
                 "Wanted " + pluralize(wantedCount) + ":",
                 new LocationImpl(),
-                "But was " + pluralize(actualCount) + ". Undesired invocation:",
-                firstUndesired,
+                "But was " + pluralize(actualCount) + ":",
+                createAllLocationsMessage(invocations),
                 ""
         );
     }
 
-    public static MockitoAssertionError neverWantedButInvoked(DescribedInvocation wanted, Location firstUndesired) {
+    public static MockitoAssertionError neverWantedButInvoked(DescribedInvocation wanted, List<Location> invocations) {
         return new NeverWantedButInvoked(join(
                 wanted.toString(),
                 "Never wanted here:",
                 new LocationImpl(),
                 "But invoked here:",
-                firstUndesired,
-                ""
+                createAllLocationsMessage(invocations)
         ));
     }
 
-    public static MockitoAssertionError tooManyActualInvocationsInOrder(int wantedCount, int actualCount, DescribedInvocation wanted, Location firstUndesired) {
-        String message = createTooManyInvocationsMessage(wantedCount, actualCount, wanted, firstUndesired);
+    public static MockitoAssertionError tooManyActualInvocationsInOrder(int wantedCount, int actualCount, DescribedInvocation wanted, List<Location> invocations) {
+        String message = createTooManyInvocationsMessage(wantedCount, actualCount, wanted, invocations);
         return new VerificationInOrderFailure(join(
                 "Verification in order failure:" + message
         ));
     }
 
-    private static String createTooLittleInvocationsMessage(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted,
-                                                            Location lastActualInvocation) {
-        String ending =
-                (lastActualInvocation != null) ? lastActualInvocation + "\n" : "\n";
+    private static String createAllLocationsMessage(List<Location> locations) {
+        if (locations == null) {
+            return "\n";
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Location location : locations) {
+            sb.append(location).append("\n");
+        }
+        return sb.toString();
+    }
 
+    private static String createTooLittleInvocationsMessage(org.mockito.internal.reporting.Discrepancy discrepancy,
+                                                            DescribedInvocation wanted,
+                                                            List<Location> locations) {
         return join(
                 wanted.toString(),
                 "Wanted " + discrepancy.getPluralizedWantedCount() + (discrepancy.getWantedCount() == 0 ? "." : ":"),
                 new LocationImpl(),
                 "But was " + discrepancy.getPluralizedActualCount() + (discrepancy.getActualCount() == 0 ? "." : ":"),
-                ending
+                createAllLocationsMessage(locations)
         );
     }
 
-    public static MockitoAssertionError tooLittleActualInvocations(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, Location lastActualLocation) {
-        String message = createTooLittleInvocationsMessage(discrepancy, wanted, lastActualLocation);
+    public static MockitoAssertionError tooLittleActualInvocations(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, List<Location> allLocations) {
+        String message = createTooLittleInvocationsMessage(discrepancy, wanted, allLocations);
 
         return new TooLittleActualInvocations(message);
     }
 
-    public static MockitoAssertionError tooLittleActualInvocationsInOrder(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, Location lastActualLocation) {
-        String message = createTooLittleInvocationsMessage(discrepancy, wanted, lastActualLocation);
+    public static MockitoAssertionError tooLittleActualInvocationsInOrder(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, List<Location> locations) {
+        String message = createTooLittleInvocationsMessage(discrepancy, wanted, locations);
 
         return new VerificationInOrderFailure(join(
                 "Verification in order failure:" + message
@@ -509,9 +518,8 @@
         ));
     }
 
-
-    public static MockitoAssertionError wantedAtMostX(int maxNumberOfInvocations, int foundSize) {
-        return new MockitoAssertionError(join("Wanted at most " + pluralize(maxNumberOfInvocations) + " but was " + foundSize));
+    public static MoreThanAllowedActualInvocations wantedAtMostX(int maxNumberOfInvocations, int foundSize) {
+        return new MoreThanAllowedActualInvocations(join("Wanted at most " + pluralize(maxNumberOfInvocations) + " but was " + foundSize));
     }
 
     public static MockitoException misplacedArgumentMatcher(List<LocalizedMatcher> lastMatchers) {
diff --git a/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java b/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
index f5216ee..9892422 100644
--- a/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
+++ b/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
@@ -7,6 +7,7 @@
 import org.hamcrest.Matcher;
 import org.hamcrest.StringDescription;
 import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.VarargMatcher;
 
 public class HamcrestArgumentMatcher<T> implements ArgumentMatcher<T> {
 
@@ -20,6 +21,10 @@
         return this.matcher.matches(argument);
     }
 
+    public boolean isVarargMatcher() {
+        return matcher instanceof VarargMatcher;
+    }
+
     public String toString() {
         //TODO SF add unit tests and integ test coverage for describeTo()
         return StringDescription.toString(matcher);
diff --git a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java b/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
index 57a9d43..a5c6458 100644
--- a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
+++ b/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
@@ -7,7 +7,6 @@
 import org.mockito.internal.creation.settings.CreationSettings;
 import org.mockito.internal.invocation.InvocationMatcher;
 import org.mockito.internal.invocation.MatchersBinder;
-import org.mockito.internal.listeners.StubbingLookupListener;
 import org.mockito.internal.stubbing.InvocationContainerImpl;
 import org.mockito.internal.stubbing.OngoingStubbingImpl;
 import org.mockito.internal.stubbing.StubbedInvocationMatcher;
@@ -20,9 +19,7 @@
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.verification.VerificationMode;
 
-import java.util.List;
-
-import static org.mockito.internal.exceptions.Reporter.stubPassedToVerify;
+import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
 import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
 
 /**
@@ -44,7 +41,7 @@
         this.mockSettings = mockSettings;
 
         this.matchersBinder = new MatchersBinder();
-        this.invocationContainer = new InvocationContainerImpl( mockSettings);
+        this.invocationContainer = new InvocationContainerImpl(mockSettings);
     }
 
     public Object handle(Invocation invocation) throws Throwable {
@@ -71,7 +68,7 @@
             // We need to check if verification was started on the correct mock
             // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
             if (((MockAwareVerificationMode) verificationMode).getMock() == invocation.getMock()) {
-                VerificationDataImpl data = createVerificationData(invocationContainer, invocationMatcher);
+                VerificationDataImpl data = new VerificationDataImpl(invocationContainer, invocationMatcher);
                 verificationMode.verify(data);
                 return null;
             } else {
@@ -88,7 +85,9 @@
 
         // look for existing answer for this invocation
         StubbedInvocationMatcher stubbing = invocationContainer.findAnswerFor(invocation);
-        notifyStubbedAnswerLookup(invocation, stubbing);
+        // TODO #793 - when completed, we should be able to get rid of the casting below
+        notifyStubbedAnswerLookup(invocation, stubbing, invocationContainer.getStubbingsAscending(),
+                                  (CreationSettings) mockSettings);
 
         if (stubbing != null) {
             stubbing.captureArgumentsFrom(invocation);
@@ -121,21 +120,4 @@
     public InvocationContainer getInvocationContainer() {
         return invocationContainer;
     }
-
-    private VerificationDataImpl createVerificationData(InvocationContainerImpl invocationContainer, InvocationMatcher invocationMatcher) {
-        if (mockSettings.isStubOnly()) {
-            throw stubPassedToVerify();     // this throws an exception
-        }
-
-        return new VerificationDataImpl(invocationContainer, invocationMatcher);
-    }
-
-    private void notifyStubbedAnswerLookup(Invocation invocation, StubbedInvocationMatcher exception) {
-        //TODO #793 - when completed, we should be able to get rid of the casting below
-        List<StubbingLookupListener> listeners = ((CreationSettings) mockSettings).getStubbingLookupListeners();
-        for (StubbingLookupListener listener : listeners) {
-            listener.onStubbingLookup(invocation, exception);
-        }
-    }
 }
-
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
index 57c335f..260321b 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
+++ b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
@@ -138,6 +138,14 @@
         return unverified;
     }
 
+    public static List<Location> getAllLocations(List<Invocation> invocations) {
+        List<Location> locations = new LinkedList<Location>();
+        for (Invocation invocation : invocations) {
+            locations.add(invocation.getLocation());
+        }
+        return locations;
+    }
+
     private static class RemoveNotMatching implements Filter<Invocation> {
         private final MatchableInvocation wanted;
 
diff --git a/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java b/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
index e085c25..e47156f 100644
--- a/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
+++ b/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
@@ -12,6 +12,7 @@
 import java.util.List;
 
 import org.mockito.ArgumentMatcher;
+import org.mockito.internal.hamcrest.HamcrestArgumentMatcher;
 import org.mockito.internal.matchers.CapturingMatcher;
 import org.mockito.internal.matchers.VarargMatcher;
 import org.mockito.invocation.Invocation;
@@ -95,15 +96,19 @@
             return ONE_MATCHER_PER_ARGUMENT;
         }
 
-        if (rawArguments == matcherCount && isLastMatcherVargargMatcher(matchers)) {
+        if (rawArguments == matcherCount && isLastMatcherVarargMatcher(matchers)) {
             return MATCH_EACH_VARARGS_WITH_LAST_MATCHER;
         }
 
         return ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS;
     }
 
-    private static boolean isLastMatcherVargargMatcher(final List<ArgumentMatcher<?>> matchers) {
-        return lastMatcher(matchers) instanceof VarargMatcher;
+    private static boolean isLastMatcherVarargMatcher(final List<ArgumentMatcher<?>> matchers) {
+        ArgumentMatcher<?> argumentMatcher = lastMatcher(matchers);
+        if (argumentMatcher instanceof HamcrestArgumentMatcher<?>) {
+           return  ((HamcrestArgumentMatcher<?>) argumentMatcher).isVarargMatcher();
+        }
+        return argumentMatcher instanceof VarargMatcher;
     }
 
     private static List<ArgumentMatcher<?>> appendLastMatcherNTimes(List<ArgumentMatcher<?>> matchers, int timesToAppendLastMatcher) {
diff --git a/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java b/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
index 0f9ac6d..5aec36d 100644
--- a/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
+++ b/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
@@ -23,7 +23,7 @@
     public List<Invocation> find(List<?> mocks) {
         List<Invocation> unused = new LinkedList<Invocation>();
         for (Object mock : mocks) {
-            List<Stubbing> fromSingleMock = MockUtil.getInvocationContainer(mock).getStubbedInvocations();
+            List<Stubbing> fromSingleMock = MockUtil.getInvocationContainer(mock).getStubbingsDescending();
             for(Stubbing s : fromSingleMock) {
                 if (!s.wasUsed()) {
                      unused.add(s.getInvocation());
diff --git a/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java b/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
index c7e2551..4885d63 100644
--- a/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
+++ b/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
@@ -5,9 +5,10 @@
 package org.mockito.internal.junit;
 
 import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.listeners.StubbingLookupEvent;
 import org.mockito.internal.listeners.StubbingLookupListener;
+import org.mockito.internal.stubbing.UnusedStubbingReporting;
 import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MatchableInvocation;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Stubbing;
 
@@ -15,7 +16,7 @@
 import java.util.LinkedList;
 import java.util.List;
 
-import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.internal.stubbing.StrictnessSelector.determineStrictness;
 
 /**
  * Default implementation of stubbing lookup listener.
@@ -30,31 +31,33 @@
         this.currentStrictness = strictness;
     }
 
-    public void onStubbingLookup(Invocation invocation, MatchableInvocation stubbingFound) {
-        if (currentStrictness != Strictness.STRICT_STUBS) {
+    public void onStubbingLookup(StubbingLookupEvent event) {
+        Strictness actualStrictness = determineStrictness(event.getStubbingFound(), event.getMockSettings(), currentStrictness);
+
+        if (actualStrictness != Strictness.STRICT_STUBS) {
             return;
         }
 
-        if (stubbingFound == null) {
+        if (event.getStubbingFound() == null) {
             //If stubbing was not found for invocation it means that either the mock invocation was not stubbed or
             //we have a stubbing arg mismatch.
-            List<Invocation> argMismatchStubbings = potentialArgMismatches(invocation);
+            List<Invocation> argMismatchStubbings = potentialArgMismatches(event.getInvocation(), event.getAllStubbings());
             if (!argMismatchStubbings.isEmpty()) {
                 mismatchesReported = true;
-                Reporter.potentialStubbingProblem(invocation, argMismatchStubbings);
+                Reporter.potentialStubbingProblem(event.getInvocation(), argMismatchStubbings);
             }
         } else {
             //when strict stubs are in use, every time a stub is realized in the code it is implicitly marked as verified
             //this way, the users don't have to repeat themselves to verify stubbed invocations (DRY)
-            invocation.markVerified();
+            event.getInvocation().markVerified();
         }
     }
 
-    private static List<Invocation> potentialArgMismatches(Invocation invocation) {
+    private static List<Invocation> potentialArgMismatches(Invocation invocation, Collection<Stubbing> stubbings) {
         List<Invocation> matchingStubbings = new LinkedList<Invocation>();
-        Collection<Stubbing> stubbings = mockingDetails(invocation.getMock()).getStubbings();
         for (Stubbing s : stubbings) {
-            if (!s.wasUsed() && s.getInvocation().getMethod().getName().equals(invocation.getMethod().getName())) {
+            if (UnusedStubbingReporting.shouldBeReported(s)
+                && s.getInvocation().getMethod().getName().equals(invocation.getMethod().getName())) {
                 matchingStubbings.add(s.getInvocation());
             }
         }
diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java b/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
index 5b6434d..3505d2c 100644
--- a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
+++ b/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
@@ -6,11 +6,11 @@
 
 import org.mockito.internal.exceptions.Reporter;
 import org.mockito.internal.util.MockitoLogger;
-import org.mockito.internal.util.collections.ListUtil;
 import org.mockito.invocation.Invocation;
 import org.mockito.stubbing.Stubbing;
 
 import java.util.Collection;
+import java.util.LinkedList;
 import java.util.List;
 
 /**
@@ -47,16 +47,19 @@
         return unused.toString();
     }
 
-    public void reportUnused() {
-        if (!unused.isEmpty()) {
-            List<Invocation> invocations = ListUtil.convert(unused, (ListUtil.Converter) new ListUtil.Converter<Stubbing, Invocation>() {
-                public Invocation convert(Stubbing s) {
-                    return s.getInvocation();
-                }
-            });
-
-
-            Reporter.unncessaryStubbingException(invocations);
+    void reportUnused() {
+        if (unused.isEmpty()) {
+            return;
         }
+
+        List<Invocation> invocations = new LinkedList<Invocation>();
+        for (Stubbing stubbing : unused) {
+            invocations.add(stubbing.getInvocation());
+        }
+        if (invocations.isEmpty()) {
+            return;
+        }
+
+        Reporter.unncessaryStubbingException(invocations);
     }
 }
diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
index 715c393..14c61c5 100644
--- a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
+++ b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
@@ -4,12 +4,18 @@
  */
 package org.mockito.internal.junit;
 
-import org.mockito.stubbing.Stubbing;
 import org.mockito.internal.invocation.finder.AllInvocationsFinder;
+import org.mockito.internal.stubbing.UnusedStubbingReporting;
 import org.mockito.internal.util.collections.ListUtil.Filter;
 import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import static org.mockito.internal.util.collections.ListUtil.filter;
 
@@ -19,14 +25,15 @@
 public class UnusedStubbingsFinder {
 
     /**
-     * Gets all unused stubbings for given set of mock objects, in order
+     * Gets all unused stubbings for given set of mock objects, in order.
+     * Stubbings explicitily marked as LENIENT are not included.
      */
     public UnusedStubbings getUnusedStubbings(Iterable<Object> mocks) {
         Set<Stubbing> stubbings = AllInvocationsFinder.findStubbings(mocks);
 
         List<Stubbing> unused = filter(stubbings, new Filter<Stubbing>() {
             public boolean isOut(Stubbing s) {
-                return s.wasUsed();
+                return !UnusedStubbingReporting.shouldBeReported(s);
             }
         });
 
@@ -50,7 +57,7 @@
         //note that those are _not_ locations where the stubbings was used
         Set<String> locationsOfUsedStubbings = new HashSet<String>();
         for (Stubbing s : stubbings) {
-            if (s.wasUsed()) {
+            if (!UnusedStubbingReporting.shouldBeReported(s)) {
                 String location = s.getInvocation().getLocation().toString();
                 locationsOfUsedStubbings.add(location);
             }
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupEvent.java b/src/main/java/org/mockito/internal/listeners/StubbingLookupEvent.java
new file mode 100644
index 0000000..0d45edd
--- /dev/null
+++ b/src/main/java/org/mockito/internal/listeners/StubbingLookupEvent.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.listeners;
+
+import org.mockito.invocation.Invocation;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Stubbing;
+
+import java.util.Collection;
+
+/**
+ * Represent an information about the looked up stubbing
+ */
+public interface StubbingLookupEvent {
+    /**
+     * @return The invocation that causes stubbing lookup
+     */
+    Invocation getInvocation();
+
+    /**
+     * @return Looked up stubbing. It can be <code>null</code>, which indicates that the invocation was not stubbed
+     */
+    Stubbing getStubbingFound();
+
+    /**
+     * @return All stubbings declared on the mock object that we are invoking
+     */
+    Collection<Stubbing> getAllStubbings();
+
+    /**
+     * @return Settings of the mock object that we are invoking
+     */
+    MockCreationSettings getMockSettings();
+}
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java b/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java
index 81cf537..6fa37a1 100644
--- a/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java
+++ b/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java
@@ -4,9 +4,6 @@
  */
 package org.mockito.internal.listeners;
 
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MatchableInvocation;
-
 /**
  * Listens to attempts to look up stubbing answer for given mocks. This class is internal for now.
  * <p>
@@ -27,11 +24,7 @@
     /**
      * Called by the framework when Mockito looked up an answer for invocation on a mock.
      *
-     * TODO when making this public, we should have an event object instead of 2 arguments in the listener.
-     *
-     * @param invocation the invocation on the mock
-     * @param stubbingFound - can be null - it indicates that the invocation was not stubbed.
+     * @param stubbingLookupEvent - Information about the looked up stubbing
      */
-    void onStubbingLookup(Invocation invocation, MatchableInvocation stubbingFound);
-
+    void onStubbingLookup(StubbingLookupEvent stubbingLookupEvent);
 }
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java b/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
new file mode 100644
index 0000000..3e55001
--- /dev/null
+++ b/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.listeners;
+
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.invocation.Invocation;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Stubbing;
+
+import java.util.Collection;
+import java.util.List;
+
+public class StubbingLookupNotifier {
+
+    public static void notifyStubbedAnswerLookup(Invocation invocation, Stubbing stubbingFound,
+                                                 Collection<Stubbing> allStubbings, CreationSettings creationSettings) {
+        List<StubbingLookupListener> listeners = creationSettings.getStubbingLookupListeners();
+        if (listeners.isEmpty()) {
+            return;
+        }
+        StubbingLookupEvent event = new Event(invocation, stubbingFound, allStubbings, creationSettings);
+        for (StubbingLookupListener listener : listeners) {
+            listener.onStubbingLookup(event);
+        }
+    }
+
+    static class Event implements StubbingLookupEvent {
+        final private Invocation invocation;
+        final private Stubbing stubbing;
+        final private Collection<Stubbing> allStubbings;
+        final private MockCreationSettings mockSettings;
+
+        public Event(Invocation invocation,
+                     Stubbing stubbing,
+                     Collection<Stubbing> allStubbings,
+                     MockCreationSettings mockSettings) {
+            this.invocation = invocation;
+            this.stubbing = stubbing;
+            this.allStubbings = allStubbings;
+            this.mockSettings = mockSettings;
+        }
+
+        @Override
+        public Invocation getInvocation() {
+            return invocation;
+        }
+
+        @Override
+        public Stubbing getStubbingFound() {
+            return stubbing;
+        }
+
+        @Override
+        public Collection<Stubbing> getAllStubbings() {
+            return allStubbings;
+        }
+
+        @Override
+        public MockCreationSettings getMockSettings() {
+            return mockSettings;
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/matchers/Any.java b/src/main/java/org/mockito/internal/matchers/Any.java
index f9f0069..58b6404 100644
--- a/src/main/java/org/mockito/internal/matchers/Any.java
+++ b/src/main/java/org/mockito/internal/matchers/Any.java
@@ -9,13 +9,10 @@
 
 import org.mockito.ArgumentMatcher;
 
-public class Any implements ArgumentMatcher<Object>, VarargMatcher ,Serializable {
+public class Any implements ArgumentMatcher<Object>, VarargMatcher, Serializable {
 
     public static final Any ANY = new Any();
 
-    private Any() {
-    }
-
     public boolean matches(Object actual) {
         return true;
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java b/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
index ddb9a8d..6dd99cd 100644
--- a/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
+++ b/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
@@ -24,7 +24,8 @@
     public OngoingStubbing<T> thenReturn(T value, T... values) {
         OngoingStubbing<T> stubbing = thenReturn(value);
         if (values == null) {
-            // TODO below does not seem right
+            // For no good reason we're configuring null answer here
+            // This has been like that since forever, so let's keep it for compatibility (unless users complain)
             return stubbing.thenReturn(null);
         }
         for (T v : values) {
@@ -65,7 +66,7 @@
     @Override
     public OngoingStubbing<T> thenThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
         if (nextToBeThrown == null) {
-            thenThrow((Class<Throwable>) null);
+            return thenThrow((Class<Throwable>) null);
         }
         OngoingStubbing<T> stubbing = thenThrow(toBeThrown);
         for (Class<? extends Throwable> t : nextToBeThrown) {
diff --git a/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java b/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
new file mode 100644
index 0000000..0f3fe07
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing;
+
+import org.mockito.internal.MockitoCore;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.LenientStubber;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.stubbing.Stubber;
+
+public class DefaultLenientStubber implements LenientStubber {
+
+    private final static MockitoCore MOCKITO_CORE = new MockitoCore();
+
+    @Override
+    public Stubber doThrow(Throwable... toBeThrown) {
+        return stubber().doThrow(toBeThrown);
+    }
+
+    @Override
+    public Stubber doThrow(Class<? extends Throwable> toBeThrown) {
+        return stubber().doThrow(toBeThrown);
+    }
+
+    @Override
+    public Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+        return stubber().doThrow(toBeThrown, nextToBeThrown);
+    }
+
+    @Override
+    public Stubber doAnswer(Answer answer) {
+        return stubber().doAnswer(answer);
+    }
+
+    @Override
+    public Stubber doNothing() {
+        return stubber().doNothing();
+    }
+
+    @Override
+    public Stubber doReturn(Object toBeReturned) {
+        return stubber().doReturn(toBeReturned);
+    }
+
+    @Override
+    public Stubber doReturn(Object toBeReturned, Object... nextToBeReturned) {
+        return stubber().doReturn(toBeReturned, nextToBeReturned);
+    }
+
+    @Override
+    public Stubber doCallRealMethod() {
+        return stubber().doCallRealMethod();
+    }
+
+    @Override
+    public <T> OngoingStubbing<T> when(T methodCall) {
+        OngoingStubbingImpl<T> ongoingStubbing = (OngoingStubbingImpl) MOCKITO_CORE.when(methodCall);
+        ongoingStubbing.setStrictness(Strictness.LENIENT);
+        return ongoingStubbing;
+    }
+
+    private static Stubber stubber() {
+        return MOCKITO_CORE.stubber(Strictness.LENIENT);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java b/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
new file mode 100644
index 0000000..56491b8
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing;
+
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Holds answers declared using 'doAnswer' stubbing style.
+ */
+class DoAnswerStyleStubbing implements Serializable {
+
+    private final List<Answer<?>> answers = new ArrayList<Answer<?>>();
+    private Strictness stubbingStrictness;
+
+    void setAnswers(List<Answer<?>> answers, Strictness stubbingStrictness) {
+        this.stubbingStrictness = stubbingStrictness;
+        this.answers.addAll(answers);
+    }
+
+    boolean isSet() {
+        return answers.isEmpty();
+    }
+
+    void clear() {
+        answers.clear();
+        stubbingStrictness = null;
+    }
+
+    List<Answer<?>> getAnswers() {
+        return answers;
+    }
+
+    Strictness getStubbingStrictness() {
+        return stubbingStrictness;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
index 120320b..6c98f37 100644
--- a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
@@ -12,12 +12,14 @@
 import org.mockito.invocation.InvocationContainer;
 import org.mockito.invocation.MatchableInvocation;
 import org.mockito.mock.MockCreationSettings;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.Stubbing;
 import org.mockito.stubbing.ValidableAnswer;
 
 import java.io.Serializable;
-import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -28,13 +30,16 @@
 
     private static final long serialVersionUID = -5334301962749537177L;
     private final LinkedList<StubbedInvocationMatcher> stubbed = new LinkedList<StubbedInvocationMatcher>();
-    private final List<Answer<?>> answersForStubbing = new ArrayList<Answer<?>>();
+    private final DoAnswerStyleStubbing doAnswerStyleStubbing;
     private final RegisteredInvocations registeredInvocations;
+    private final Strictness mockStrictness;
 
     private MatchableInvocation invocationForStubbing;
 
     public InvocationContainerImpl(MockCreationSettings mockSettings) {
         this.registeredInvocations = createRegisteredInvocations(mockSettings);
+        this.mockStrictness = mockSettings.isLenient() ? Strictness.LENIENT : null;
+        this.doAnswerStyleStubbing = new DoAnswerStyleStubbing();
     }
 
     public void setInvocationForPotentialStubbing(MatchableInvocation invocation) {
@@ -46,19 +51,19 @@
         this.invocationForStubbing = invocationMatcher;
     }
 
-    public void addAnswer(Answer answer) {
+    public void addAnswer(Answer answer, Strictness stubbingStrictness) {
         registeredInvocations.removeLast();
-        addAnswer(answer, false);
+        addAnswer(answer, false, stubbingStrictness);
     }
 
     public void addConsecutiveAnswer(Answer answer) {
-        addAnswer(answer, true);
+        addAnswer(answer, true, null);
     }
 
     /**
      * Adds new stubbed answer and returns the invocation matcher the answer was added to.
      */
-    public StubbedInvocationMatcher addAnswer(Answer answer, boolean isConsecutive) {
+    public StubbedInvocationMatcher addAnswer(Answer answer, boolean isConsecutive, Strictness stubbingStrictness) {
         Invocation invocation = invocationForStubbing.getInvocation();
         mockingProgress().stubbingCompleted();
         if (answer instanceof ValidableAnswer) {
@@ -69,7 +74,8 @@
             if (isConsecutive) {
                 stubbed.getFirst().addAnswer(answer);
             } else {
-                stubbed.addFirst(new StubbedInvocationMatcher(invocationForStubbing, answer));
+                Strictness effectiveStrictness = stubbingStrictness != null ? stubbingStrictness : this.mockStrictness;
+                stubbed.addFirst(new StubbedInvocationMatcher(answer, invocationForStubbing, effectiveStrictness));
             }
             return stubbed.getFirst();
         }
@@ -84,6 +90,7 @@
             for (StubbedInvocationMatcher s : stubbed) {
                 if (s.matches(invocation)) {
                     s.markStubUsed(invocation);
+                    //TODO we should mark stubbed at the point of stubbing, not at the point where the stub is being used
                     invocation.markStubbed(new StubInfoImpl(s));
                     return s;
                 }
@@ -93,12 +100,15 @@
         return null;
     }
 
-    public void setAnswersForStubbing(List<Answer<?>> answers) {
-        answersForStubbing.addAll(answers);
+    /**
+     * Sets the answers declared with 'doAnswer' style.
+     */
+    public void setAnswersForStubbing(List<Answer<?>> answers, Strictness strictness) {
+        doAnswerStyleStubbing.setAnswers(answers, strictness);
     }
 
     public boolean hasAnswersForStubbing() {
-        return !answersForStubbing.isEmpty();
+        return !doAnswerStyleStubbing.isSet();
     }
 
     public boolean hasInvocationForPotentialStubbing() {
@@ -108,10 +118,10 @@
     public void setMethodForStubbing(MatchableInvocation invocation) {
         invocationForStubbing = invocation;
         assert hasAnswersForStubbing();
-        for (int i = 0; i < answersForStubbing.size(); i++) {
-            addAnswer(answersForStubbing.get(i), i != 0);
+        for (int i = 0; i < doAnswerStyleStubbing.getAnswers().size(); i++) {
+            addAnswer(doAnswerStyleStubbing.getAnswers().get(i), i != 0, doAnswerStyleStubbing.getStubbingStrictness());
         }
-        answersForStubbing.clear();
+        doAnswerStyleStubbing.clear();
     }
 
     @Override
@@ -127,10 +137,22 @@
         registeredInvocations.clear();
     }
 
-    public List<Stubbing> getStubbedInvocations() {
+    /**
+     * Stubbings in descending order, most recent first
+     */
+    public List<Stubbing> getStubbingsDescending() {
         return (List) stubbed;
     }
 
+    /**
+     * Stubbings in ascending order, most recent last
+     */
+    public Collection<Stubbing> getStubbingsAscending() {
+        List<Stubbing> result = new LinkedList<Stubbing>(stubbed);
+        Collections.reverse(result);
+        return result;
+    }
+
     public Object invokedMock() {
         return invocationForStubbing.getInvocation().getMock();
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java b/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
index 78a1027..cd27c39 100644
--- a/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
@@ -5,16 +5,18 @@
 package org.mockito.internal.stubbing;
 
 import org.mockito.invocation.Invocation;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.OngoingStubbing;
 
-import static org.mockito.internal.exceptions.Reporter.incorrectUseOfApi;
-
 import java.util.List;
 
+import static org.mockito.internal.exceptions.Reporter.incorrectUseOfApi;
+
 public class OngoingStubbingImpl<T> extends BaseStubbing<T> {
 
     private final InvocationContainerImpl invocationContainer;
+    private Strictness strictness;
 
     public OngoingStubbingImpl(InvocationContainerImpl invocationContainer) {
         this.invocationContainer = invocationContainer;
@@ -26,7 +28,7 @@
             throw incorrectUseOfApi();
         }
 
-        invocationContainer.addAnswer(answer);
+        invocationContainer.addAnswer(answer, strictness);
         return new ConsecutiveStubbing<T>(invocationContainer);
     }
 
@@ -45,6 +47,10 @@
     public <M> M getMock() {
         return (M) invocationContainer.invokedMock();
     }
+
+    public void setStrictness(Strictness strictness) {
+        this.strictness = strictness;
+    }
 }
 
 
diff --git a/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java b/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
new file mode 100644
index 0000000..6009e93
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Stubbing;
+
+/**
+ * Helps determining the actual strictness given that it can be configured in multiple ways (at mock, at stubbing, in rule)
+ */
+public class StrictnessSelector {
+
+    /**
+     * Determines the actual strictness in the following importance order:
+     * 1st - strictness configured when declaring stubbing;
+     * 2nd - strictness configured at mock level;
+     * 3rd - strictness configured at test level (rule, mockito session)
+     *
+     * @param stubbing stubbing to check for strictness. Null permitted.
+     * @param mockSettings settings of the mock object, may or may not have strictness configured. Must not be null.
+     * @param testLevelStrictness strictness configured using the test-level configuration (rule, mockito session). Null permitted.
+     *
+     * @return actual strictness, can be null.
+     */
+    public static Strictness determineStrictness(Stubbing stubbing, MockCreationSettings mockSettings, Strictness testLevelStrictness) {
+        if (stubbing != null && stubbing.getStrictness() != null) {
+            return stubbing.getStrictness();
+        }
+
+        if (mockSettings.isLenient()) {
+            return Strictness.LENIENT;
+        }
+
+        return testLevelStrictness;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java b/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
index 4518210..e7ccac4 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
+++ b/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
@@ -5,11 +5,12 @@
 package org.mockito.internal.stubbing;
 
 import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.MatchableInvocation;
-import org.mockito.stubbing.Stubbing;
 import org.mockito.invocation.DescribedInvocation;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.invocation.MatchableInvocation;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.Stubbing;
 
 import java.io.Serializable;
 import java.util.Queue;
@@ -20,10 +21,12 @@
 
     private static final long serialVersionUID = 4919105134123672727L;
     private final Queue<Answer> answers = new ConcurrentLinkedQueue<Answer>();
+    private final Strictness strictness;
     private DescribedInvocation usedAt;
 
-    public StubbedInvocationMatcher(MatchableInvocation invocation, Answer answer) {
+    public StubbedInvocationMatcher(Answer answer, MatchableInvocation invocation, Strictness strictness) {
         super(invocation.getInvocation(), invocation.getMatchers());
+        this.strictness = strictness;
         this.answers.add(answer);
     }
 
@@ -52,4 +55,9 @@
     public String toString() {
         return super.toString() + " stubbed with: " + answers;
     }
+
+    @Override
+    public Strictness getStrictness() {
+        return strictness;
+    }
 }
diff --git a/src/main/java/org/mockito/internal/stubbing/StubberImpl.java b/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
index b18d05d..2172809 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
@@ -8,6 +8,7 @@
 import org.mockito.internal.stubbing.answers.Returns;
 import org.mockito.internal.stubbing.answers.ThrowsException;
 import org.mockito.internal.util.MockUtil;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.Stubber;
 
@@ -24,6 +25,12 @@
 
 public class StubberImpl implements Stubber {
 
+    private final Strictness strictness;
+
+    public StubberImpl(Strictness strictness) {
+        this.strictness = strictness;
+    }
+
     private final List<Answer<?>> answers = new LinkedList<Answer<?>>();
 
     @Override
@@ -36,7 +43,7 @@
             throw notAMockPassedToWhenMethod();
         }
 
-        MockUtil.getInvocationContainer(mock).setAnswersForStubbing(answers);
+        MockUtil.getInvocationContainer(mock).setAnswersForStubbing(answers, strictness);
 
         return mock;
     }
@@ -83,9 +90,9 @@
         Throwable e;
         try {
             e = newInstance(toBeThrown);
-        } catch (RuntimeException instanciationError) {
+        } catch (RuntimeException instantiationError) {
             mockingProgress().reset();
-            throw instanciationError;
+            throw instantiationError;
         }
         return doThrow(e);
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java b/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
new file mode 100644
index 0000000..6a96592
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing;
+
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Stubbing;
+
+/**
+ * Helps determining if stubbing should be reported as unused
+ */
+public class UnusedStubbingReporting {
+
+    /**
+     * Decides if the stubbing should be reported as unused.
+     * Lenient stubbings are not reported as unused.
+     */
+    public static boolean shouldBeReported(Stubbing stubbing) {
+        return !stubbing.wasUsed() && stubbing.getStrictness() != Strictness.LENIENT;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
index 037520f..502e359 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
@@ -14,23 +14,36 @@
 import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
 import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
 
+/**
+ * An answer that always throws the same throwable.
+ */
 public class ThrowsException implements Answer<Object>, ValidableAnswer, Serializable {
 
     private static final long serialVersionUID = 1128820328555183980L;
     private final Throwable throwable;
     private final ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
 
+    /**
+     * Creates a new answer always throwing the given throwable. If it is null,
+     * {@linkplain ValidableAnswer#validateFor(InvocationOnMock) answer validation}
+     * will fail.
+     */
     public ThrowsException(Throwable throwable) {
         this.throwable = throwable;
     }
 
     public Object answer(InvocationOnMock invocation) throws Throwable {
+        if (throwable == null) {
+            throw new IllegalStateException("throwable is null: " +
+                "you shall not call #answer if #validateFor fails!");
+        }
         if (MockUtil.isMock(throwable)) {
             throw throwable;
         }
         Throwable t = throwable.fillInStackTrace();
 
         if (t == null) {
+            //Custom exceptions sometimes return null, see #866
             throw throwable;
         }
         filter.filter(t);
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
index 3b2cb3d..3909ff0 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
@@ -61,7 +61,7 @@
 
         // matches invocation for verification
         // TODO why don't we do container.findAnswer here?
-        for (Stubbing stubbing : container.getStubbedInvocations()) {
+        for (Stubbing stubbing : container.getStubbingsDescending()) {
             if (container.getInvocationForStubbing().matches(stubbing.getInvocation())) {
                 return stubbing.answer(invocation);
             }
@@ -118,7 +118,7 @@
 
     private StubbedInvocationMatcher recordDeepStubAnswer(final Object mock, InvocationContainerImpl container) {
         DeeplyStubbedAnswer answer = new DeeplyStubbedAnswer(mock);
-        return container.addAnswer(answer, false);
+        return container.addAnswer(answer, false, null);
     }
 
     protected GenericMetadataSupport actualParameterizedType(Object mock) {
diff --git a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
index 0c3669c..4f739cd 100644
--- a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
+++ b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
@@ -8,15 +8,12 @@
 import org.mockito.exceptions.misusing.NotAMockException;
 import org.mockito.internal.debugging.InvocationsPrinter;
 import org.mockito.internal.stubbing.InvocationContainerImpl;
-import org.mockito.internal.stubbing.StubbingComparator;
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.stubbing.Stubbing;
 
 import java.util.Collection;
-import java.util.List;
-import java.util.TreeSet;
 
 /**
  * Class to inspect any object, and identify whether a particular object is either a mock or a spy.  This is
@@ -57,10 +54,7 @@
 
     @Override
     public Collection<Stubbing> getStubbings() {
-        List<? extends Stubbing> stubbings = getInvocationContainer().getStubbedInvocations();
-        TreeSet<Stubbing> out = new TreeSet<Stubbing>(new StubbingComparator());
-        out.addAll(stubbings);
-        return out;
+        return getInvocationContainer().getStubbingsAscending();
     }
 
     @Override
diff --git a/src/main/java/org/mockito/internal/util/Primitives.java b/src/main/java/org/mockito/internal/util/Primitives.java
index 4d813e3..80dd0af 100644
--- a/src/main/java/org/mockito/internal/util/Primitives.java
+++ b/src/main/java/org/mockito/internal/util/Primitives.java
@@ -44,7 +44,7 @@
 
     public static boolean isAssignableFromWrapper(Class<?> valueClass, Class<?> referenceType) {
         if(isPrimitiveOrWrapper(valueClass) && isPrimitiveOrWrapper(referenceType)) {
-            return Primitives.primitiveTypeOf(valueClass).isAssignableFrom(referenceType);
+            return Primitives.primitiveTypeOf(valueClass).isAssignableFrom(Primitives.primitiveTypeOf(referenceType));
         }
         return false;
     }
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 b411a73..487d223 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
+++ b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
@@ -50,6 +50,7 @@
      * @param key The key of the entry.
      * @return The value of the entry or the default value if it did not exist.
      */
+    @SuppressWarnings("CollectionIncompatibleType")
     public V get(K key) {
         if (key == null) throw new NullPointerException();
         V value = target.get(new LatentKey<K>(key));
@@ -69,6 +70,7 @@
      * @param key The key of the entry.
      * @return {@code true} if the key already defines a value.
      */
+    @SuppressWarnings("CollectionIncompatibleType")
     public boolean containsKey(K key) {
         if (key == null) throw new NullPointerException();
         return target.containsKey(new LatentKey<K>(key));
@@ -88,6 +90,7 @@
      * @param key The key of the entry.
      * @return The removed entry or {@code null} if it does not exist.
      */
+    @SuppressWarnings("CollectionIncompatibleType")
     public V remove(K key) {
         if (key == null) throw new NullPointerException();
         return target.remove(new LatentKey<K>(key));
diff --git a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
index 36e35a3..d0eb0b5 100644
--- a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
+++ b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
@@ -17,7 +17,7 @@
 import static org.mockito.internal.invocation.InvocationMarker.markVerifiedInOrder;
 import static org.mockito.internal.invocation.InvocationsFinder.findAllMatchingUnverifiedChunks;
 import static org.mockito.internal.invocation.InvocationsFinder.findInvocations;
-import static org.mockito.internal.invocation.InvocationsFinder.getLastLocation;
+import static org.mockito.internal.invocation.InvocationsFinder.getAllLocations;
 
 public class AtLeastXNumberOfInvocationsChecker {
 
@@ -26,8 +26,8 @@
 
         int actualCount = actualInvocations.size();
         if (wantedCount > actualCount) {
-            Location lastLocation = getLastLocation(actualInvocations);
-            throw tooLittleActualInvocations(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, lastLocation);
+            List<Location> allLocations = getAllLocations(actualInvocations);
+            throw tooLittleActualInvocations(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
         }
 
         markVerified(actualInvocations, wanted);
@@ -39,8 +39,8 @@
         int actualCount = chunk.size();
 
         if (wantedCount > actualCount) {
-            Location lastLocation = getLastLocation(chunk);
-            throw tooLittleActualInvocationsInOrder(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, lastLocation);
+            List<Location> allLocations = getAllLocations(chunk);
+            throw tooLittleActualInvocationsInOrder(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
         }
 
         markVerifiedInOrder(chunk, wanted, orderingContext);
diff --git a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
index 3fa340f..1dfc2f1 100644
--- a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
+++ b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
@@ -5,6 +5,7 @@
 
 package org.mockito.internal.verification.checkers;
 
+import java.util.Arrays;
 import java.util.List;
 import org.mockito.internal.reporting.Discrepancy;
 import org.mockito.internal.verification.api.InOrderContext;
@@ -22,7 +23,7 @@
 import static org.mockito.internal.invocation.InvocationsFinder.findFirstMatchingUnverifiedInvocation;
 import static org.mockito.internal.invocation.InvocationsFinder.findInvocations;
 import static org.mockito.internal.invocation.InvocationsFinder.findMatchingChunk;
-import static org.mockito.internal.invocation.InvocationsFinder.getLastLocation;
+import static org.mockito.internal.invocation.InvocationsFinder.getAllLocations;
 
 public class NumberOfInvocationsChecker {
 
@@ -34,16 +35,14 @@
 
         int actualCount = actualInvocations.size();
         if (wantedCount > actualCount) {
-            Location lastInvocation = getLastLocation(actualInvocations);
-            throw tooLittleActualInvocations(new Discrepancy(wantedCount, actualCount), wanted, lastInvocation);
+            List<Location> allLocations = getAllLocations(actualInvocations);
+            throw tooLittleActualInvocations(new Discrepancy(wantedCount, actualCount), wanted, allLocations);
         }
         if (wantedCount == 0 && actualCount > 0) {
-            Location firstUndesired = actualInvocations.get(wantedCount).getLocation();
-            throw neverWantedButInvoked(wanted, firstUndesired);
+            throw neverWantedButInvoked(wanted, getAllLocations(actualInvocations));
         }
         if (wantedCount < actualCount) {
-            Location firstUndesired = actualInvocations.get(wantedCount).getLocation();
-            throw tooManyActualInvocations(wantedCount, actualCount, wanted, firstUndesired);
+            throw tooManyActualInvocations(wantedCount, actualCount, wanted, getAllLocations(actualInvocations));
         }
 
         markVerified(actualInvocations, wanted);
@@ -55,12 +54,11 @@
         int actualCount = chunk.size();
 
         if (wantedCount > actualCount) {
-            Location lastInvocation = getLastLocation(chunk);
-            throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, lastInvocation);
+            List<Location> allLocations = getAllLocations(chunk);
+            throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, allLocations);
         }
         if (wantedCount < actualCount) {
-            Location firstUndesired = chunk.get(wantedCount).getLocation();
-            throw tooManyActualInvocationsInOrder(wantedCount, actualCount, wanted, firstUndesired);
+            throw tooManyActualInvocationsInOrder(wantedCount, actualCount, wanted, getAllLocations(chunk));
         }
 
         markVerifiedInOrder(chunk, wanted, context);
@@ -72,7 +70,7 @@
         while( actualCount < wantedCount ){
             Invocation next = findFirstMatchingUnverifiedInvocation(invocations, wanted, context );
             if( next == null ){
-                throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, lastLocation );
+                throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, Arrays.asList(lastLocation));
             }
             markVerified( next, wanted );
             context.markVerified( next );
diff --git a/src/main/java/org/mockito/junit/MockitoJUnit.java b/src/main/java/org/mockito/junit/MockitoJUnit.java
index 2f8b65f..da9428b 100644
--- a/src/main/java/org/mockito/junit/MockitoJUnit.java
+++ b/src/main/java/org/mockito/junit/MockitoJUnit.java
@@ -5,13 +5,18 @@
 package org.mockito.junit;
 
 import org.mockito.Incubating;
-import org.mockito.quality.Strictness;
 import org.mockito.internal.junit.JUnitRule;
 import org.mockito.internal.junit.VerificationCollectorImpl;
 import org.mockito.internal.util.ConsoleMockitoLogger;
+import org.mockito.quality.Strictness;
 
 /**
- * The JUnit rule can be used instead of {@link MockitoJUnitRunner}. See {@link MockitoRule}.
+ * Mockito supports JUnit via:
+ * <li>
+ *     <ul>JUnit Rules - see {@link MockitoRule}</ul>
+ *     <ul>JUnit runners - see {@link MockitoJUnitRunner}</ul>
+ *     <ul><a href="http://javadoc.io/page/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">JUnit Jupiter extension</a></ul>
+ * </li>
  *
  * @since 1.10.17
  */
diff --git a/src/main/java/org/mockito/junit/MockitoRule.java b/src/main/java/org/mockito/junit/MockitoRule.java
index 296faa7..561fff7 100644
--- a/src/main/java/org/mockito/junit/MockitoRule.java
+++ b/src/main/java/org/mockito/junit/MockitoRule.java
@@ -6,6 +6,8 @@
 
 import org.junit.rules.MethodRule;
 import org.mockito.Incubating;
+import org.mockito.MockSettings;
+import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.mockito.MockitoSession;
 import org.mockito.quality.MockitoHint;
@@ -104,7 +106,7 @@
      * The strictness, especially "strict stubs" ({@link Strictness#STRICT_STUBS})
      * helps debugging and keeping tests clean.
      * It's a new feature introduced in Mockito 2.3.
-     * Other levels of strictness - "Warn" - current default ({@link Strictness#WARN})
+     * Other levels of strictness - "warn" - ({@link Strictness#WARN})
      * and "lenient" ({@link MockitoRule#silent()}) strictness were already present in Mockito 2.1.0.
      * Version 2.3.0 introduces "strict stubs" ({@link Strictness#STRICT_STUBS}).
      *
@@ -115,21 +117,12 @@
      * }
      * </code></pre>
      *
-     * How strictness level influences the behavior of JUnit rule:
-     * <ol>
-     *     <li>{@link Strictness#LENIENT} - equivalent of {@link MockitoRule#silent()} -
-     *      no added behavior. The default of Mockito 1.x </li>
-     *     <li>{@link Strictness#WARN} - helps keeping tests clean and with debuggability.
-     *     Reports console warnings about unused stubs
-     *     and stubbing argument mismatches (see {@link MockitoHint}).
-     *     The default of Mockito 2.x</li>
-     *     <li>{@link Strictness#STRICT_STUBS} - ensures clean tests,
-     *     reduces test code duplication, improves debuggability.
-     *     See the details in the Javadoc for {@link Strictness#STRICT_STUBS}.
-     * </ol>
-     *
+     * See Javadoc for {@link Strictness} to learn how strictness influences the behavior of the JUnit rule.
+     * See {@link Strictness#STRICT_STUBS} to learn why is it recommended to use "strict stubbing".
+     * <p>
      * It is possible to tweak the strictness per test method.
      * Why would you need it? See the use cases in Javadoc for {@link PotentialStubbingProblem} class.
+     * In order to tweak strictness per stubbing see {@link Mockito#lenient()}, per mock see {@link MockSettings#lenient()}.
      *
      * <pre class="code"><code class="java">
      * public class ExampleTest {
@@ -146,7 +139,7 @@
      * }
      * </code></pre>
      *
-     * "Strict stubs" are tentatively planned to be the default for Mockito v3</li>
+     * "Strict stubs" are planned to be the default for Mockito v3</li>
      * We are very eager to hear feedback about "strict stubbing" feature, let us know by commenting on GitHub
      * <a href="https://github.com/mockito/mockito/issues/769">issue 769</a>.
      * Strict stubbing is an attempt to improve testability and productivity with Mockito. Tell us what you think!
diff --git a/src/main/java/org/mockito/mock/MockCreationSettings.java b/src/main/java/org/mockito/mock/MockCreationSettings.java
index b58daf0..7e74be8 100644
--- a/src/main/java/org/mockito/mock/MockCreationSettings.java
+++ b/src/main/java/org/mockito/mock/MockCreationSettings.java
@@ -6,9 +6,11 @@
 package org.mockito.mock;
 
 import org.mockito.Incubating;
+import org.mockito.MockSettings;
 import org.mockito.NotExtensible;
 import org.mockito.listeners.InvocationListener;
 import org.mockito.listeners.VerificationStartedListener;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 
 import java.util.List;
@@ -109,4 +111,13 @@
      */
     @Incubating
     Object getOuterClassInstance();
+
+    /**
+     * Informs if the mock was created with "lenient" strictness, e.g. having {@link Strictness#LENIENT} characteristic.
+     * For more information about using mocks with lenient strictness, see {@link MockSettings#lenient()}.
+     *
+     * @since 2.20.0
+     */
+    @Incubating
+    boolean isLenient();
 }
diff --git a/src/main/java/org/mockito/quality/MockitoHint.java b/src/main/java/org/mockito/quality/MockitoHint.java
index d752159..f261ac1 100644
--- a/src/main/java/org/mockito/quality/MockitoHint.java
+++ b/src/main/java/org/mockito/quality/MockitoHint.java
@@ -8,10 +8,13 @@
 import org.mockito.junit.MockitoJUnitRunner;
 
 /**
+ * Stubbing hints were introduced in Mockito 2 in order to improve debuggability while keeping backwards compatibility.
+ * As Mockito 2 evolved, hints are replaced by  "strict stubbing" API ({@link Strictness}).
+ * In Mockito 3 we won't be needing hints because {@link Strictness#STRICT_STUBS} will be the default for all mocks.
+ * <p>
+ * Why hints?
  * To improve productivity when writing Java tests
  * stubbing hints and warnings are printed to standard output.
- * See also "strict stubbing" API ({@link Strictness})
- * which drives cleaner tests and productivity more effectively than Mockito hints.
  * <p>
  * Hints contain clickable links that take you right to the line of code that contains a possible problem.
  * Those are hints - they not necessarily indicate real problems 100% of the time.
diff --git a/src/main/java/org/mockito/quality/Strictness.java b/src/main/java/org/mockito/quality/Strictness.java
index c9da8d3..ea9fed8 100644
--- a/src/main/java/org/mockito/quality/Strictness.java
+++ b/src/main/java/org/mockito/quality/Strictness.java
@@ -9,31 +9,31 @@
 import org.mockito.exceptions.misusing.PotentialStubbingProblem;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
 import org.mockito.internal.junit.JUnitRule;
+import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.mockito.junit.MockitoRule;
 
 /**
- * Configures the "strictness" of Mockito during a mocking session.
- * A session typically maps to a single test method invocation.
- * {@code Strictness} drives cleaner tests and better productivity.
- * The easiest way to leverage enhanced {@code Strictness} is using
- * Mockito's JUnit support ({@link MockitoRule} or {@link MockitoJUnitRunner}).
- * If you cannot use JUnit support {@link MockitoSession} is the way to go.
+ * Configures the "strictness" of Mockito, affecting the behavior of stubbings and verification.
+ * "Strict stubbing" is a new feature in Mockito 2 that drives cleaner tests and better productivity.
+ * The easiest way to leverage it is via Mockito's JUnit support ({@link MockitoJUnit}) or Mockito Session ({@link MockitoSession}).
  * <p>
- * How strictness level influences the behavior of the test (mocking session)?
+ * How strictness influences the behavior of the test?
  * <ol>
- *     <li>{@link Strictness#LENIENT} - no added behavior.
- *       The default of Mockito 1.x.
- *       Recommended only if you cannot use {@link #STRICT_STUBS} nor {@link #WARN}.</li>
- *     <li>{@link Strictness#WARN} - helps keeping tests clean and improves debuggability.
- *       Reports console warnings about unused stubs
- *       and stubbing argument mismatch (see {@link org.mockito.quality.MockitoHint}).
- *       The default behavior of Mockito 2.x when {@link JUnitRule} or {@link MockitoJUnitRunner} are used.</li>
- *       Recommended if you cannot use {@link #STRICT_STUBS}.
  *     <li>{@link Strictness#STRICT_STUBS} - ensures clean tests, reduces test code duplication, improves debuggability.
  *       Best combination of flexibility and productivity. Highly recommended.
  *       Planned as default for Mockito v3.
- *       See {@link #STRICT_STUBS} for the details.
+ *       Enable it via {@link MockitoRule}, {@link MockitoJUnitRunner} or {@link MockitoSession}.
+ *       See {@link #STRICT_STUBS} for the details.</li>
+ *     <li>{@link Strictness#LENIENT} - no added behavior.
+ *       The default of Mockito 1.x.
+ *       Recommended only if you cannot use {@link #STRICT_STUBS}</li>
+ *     <li>{@link Strictness#WARN} - cleaner tests but only if you read the console output.
+ *       Reports console warnings about unused stubs
+ *       and stubbing argument mismatch (see {@link org.mockito.quality.MockitoHint}).
+ *       The default behavior of Mockito 2.x when {@link JUnitRule} or {@link MockitoJUnitRunner} are used.
+ *       Recommended if you cannot use {@link #STRICT_STUBS}.
+ *       Introduced originally with Mockito 2 because console warnings was the only compatible way of adding such feature.</li>
  * </ol>
  *
  * @since 2.3.0
@@ -43,7 +43,7 @@
 
     /**
      * No extra strictness. Mockito 1.x behavior.
-     * Recommended only if you cannot use {@link #STRICT_STUBS} nor {@link #WARN}.
+     * Recommended only if you cannot use {@link #STRICT_STUBS}.
      * <p>
      * For more information see {@link Strictness}.
      *
@@ -53,10 +53,10 @@
     LENIENT,
 
     /**
-     * Helps keeping tests clean and improves debuggability.
+     * Helps keeping tests clean and improves debuggability only if you read the console output.
      * Extra warnings emitted to the console, see {@link MockitoHint}.
      * Default Mockito 2.x behavior.
-     * Recommended if you cannot use {@link #STRICT_STUBS}.
+     * Recommended only if you cannot use {@link #STRICT_STUBS} because console output is ignored most of the time.
      * <p>
      * For more information see {@link Strictness}.
      *
@@ -70,6 +70,7 @@
      * Offers best combination of flexibility and productivity.
      * Highly recommended.
      * Planned as default for Mockito v3.
+     * Enable it via our JUnit support ({@link MockitoJUnit}) or {@link MockitoSession}.
      * <p>
      * Adds following behavior:
      *  <ul>
@@ -80,8 +81,7 @@
      *      <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. 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>
+     *          They are automatically verified for you.</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 474b7f9..b3a758b 100644
--- a/src/main/java/org/mockito/session/MockitoSessionBuilder.java
+++ b/src/main/java/org/mockito/session/MockitoSessionBuilder.java
@@ -47,7 +47,7 @@
      * 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.
+     * This method is useful for advanced framework integrations (like JUnit Jupiter), when a test uses multiple, e.g. nested, test class instances.
      * <p>
      * This method calls {@link #initMocks(Object)} for each passed test class instance.
      *
diff --git a/src/main/java/org/mockito/stubbing/BaseStubber.java b/src/main/java/org/mockito/stubbing/BaseStubber.java
new file mode 100644
index 0000000..8c31928
--- /dev/null
+++ b/src/main/java/org/mockito/stubbing/BaseStubber.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.stubbing;
+
+import org.mockito.Mockito;
+import org.mockito.NotExtensible;
+
+/**
+ * Base interface for stubbing consecutive method calls with {@link Mockito#doReturn(Object)} syntax.
+ * This interface is needed so that we can reuse the same hierarchy in subinterfaces.
+ *
+ * @since 2.20.0
+ */
+@NotExtensible
+public interface BaseStubber {
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doThrow(Throwable[])} style:
+     * <pre class="code"><code class="java">
+     *   doThrow(new RuntimeException("one")).
+     *   doThrow(new RuntimeException("two"))
+     *       .when(mock).someVoidMethod();
+     * </code></pre>
+     * See javadoc for {@link Mockito#doThrow(Throwable[])}
+     *
+     * @param toBeThrown to be thrown when the stubbed method is called
+     * @return stubber - to select a method for stubbing
+     */
+    Stubber doThrow(Throwable... toBeThrown);
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doThrow(Class)} style:
+     * <pre class="code"><code class="java">
+     *   doThrow(RuntimeException.class).
+     *   doThrow(IllegalArgumentException.class)
+     *       .when(mock).someVoidMethod();
+     * </code></pre>
+     * See javadoc for {@link Mockito#doThrow(Class)}
+     *
+     * @param toBeThrown exception class to be thrown when the stubbed method is called
+     * @return stubber - to select a method for stubbing
+     *
+     * @since 2.1.0
+     */
+    Stubber doThrow(Class<? extends Throwable> toBeThrown);
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doThrow(Class)} style:
+     * <pre class="code"><code class="java">
+     *   doThrow(RuntimeException.class).
+     *   doThrow(IllegalArgumentException.class)
+     *       .when(mock).someVoidMethod();
+     * </code></pre>
+     * See javadoc for {@link Mockito#doThrow(Class)}
+     *
+     * @param toBeThrown exception class to be thrown when the stubbed method is called
+     * @param nextToBeThrown exception class next to be thrown when the stubbed method is called
+     * @return stubber - to select a method for stubbing
+     *
+     * @since 2.1.0
+     */
+    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation
+    @SuppressWarnings ({"unchecked", "varargs"})
+    Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doAnswer(Answer)} style:
+     * <pre class="code"><code class="java">
+     *   doAnswer(answerOne).
+     *   doAnswer(answerTwo)
+     *       .when(mock).someVoidMethod();
+     * </code></pre>
+     * See javadoc for {@link Mockito#doAnswer(Answer)}
+     *
+     * @param answer to answer when the stubbed method is called
+     * @return stubber - to select a method for stubbing
+     */
+    Stubber doAnswer(Answer answer);
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doNothing()} style:
+     * <pre class="code"><code class="java">
+     *   doNothing().
+     *   doThrow(new RuntimeException("two"))
+     *       .when(mock).someVoidMethod();
+     * </code></pre>
+     * See javadoc for {@link Mockito#doNothing()}
+     *
+     * @return stubber - to select a method for stubbing
+     */
+    Stubber doNothing();
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doReturn(Object)} style.
+     * <p>
+     * See javadoc for {@link Mockito#doReturn(Object)}
+     *
+     * @param toBeReturned to be returned when the stubbed method is called
+     * @return stubber - to select a method for stubbing
+     */
+    Stubber doReturn(Object toBeReturned);
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doReturn(Object)} style.
+     * <p>
+     * See javadoc for {@link Mockito#doReturn(Object, Object...)}
+     *
+     * @param toBeReturned to be returned when the stubbed method is called
+     * @param nextToBeReturned to be returned in consecutive calls when the stubbed method is called
+     * @return stubber - to select a method for stubbing
+     */
+    @SuppressWarnings({"unchecked", "varargs"})
+    Stubber doReturn(Object toBeReturned, Object... nextToBeReturned);
+
+    /**
+     * Use it for stubbing consecutive calls in {@link Mockito#doCallRealMethod()} style.
+     * <p>
+     * See javadoc for {@link Mockito#doCallRealMethod()}
+     *
+     * @return stubber - to select a method for stubbing
+     */
+    Stubber doCallRealMethod();
+}
diff --git a/src/main/java/org/mockito/stubbing/LenientStubber.java b/src/main/java/org/mockito/stubbing/LenientStubber.java
new file mode 100644
index 0000000..9088399
--- /dev/null
+++ b/src/main/java/org/mockito/stubbing/LenientStubber.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.stubbing;
+
+import org.mockito.CheckReturnValue;
+import org.mockito.Mockito;
+import org.mockito.NotExtensible;
+
+/**
+ * Used for declaring optional stubbings with {@link Mockito#lenient()}
+ *
+ * @since 2.20.0
+ */
+@NotExtensible
+public interface LenientStubber extends BaseStubber {
+
+    /**
+     * Allows declaring the method to stub. See {@link Mockito#when(Object)}.
+     * Needed for classic stubbing with when().then()
+     *
+     * @since 2.20.0
+     */
+    @CheckReturnValue
+    <T> OngoingStubbing<T> when(T methodCall);
+}
diff --git a/src/main/java/org/mockito/stubbing/Stubber.java b/src/main/java/org/mockito/stubbing/Stubber.java
index b7507a7..5de954b 100644
--- a/src/main/java/org/mockito/stubbing/Stubber.java
+++ b/src/main/java/org/mockito/stubbing/Stubber.java
@@ -5,6 +5,7 @@
 package org.mockito.stubbing;
 
 import org.mockito.Mockito;
+import org.mockito.NotExtensible;
 
 /**
  * Allows to choose a method when stubbing in doThrow()|doAnswer()|doNothing()|doReturn() style
@@ -39,7 +40,8 @@
  * See examples in javadoc for {@link Mockito}
  */
 @SuppressWarnings("unchecked")
-public interface Stubber {
+@NotExtensible
+public interface Stubber extends BaseStubber {
 
     /**
      * Allows to choose a method when stubbing in doThrow()|doAnswer()|doNothing()|doReturn() style
@@ -70,111 +72,4 @@
      * @return select method for stubbing
      */
     <T> T when(T mock);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doThrow(Throwable[])} style:
-     * <pre class="code"><code class="java">
-     *   doThrow(new RuntimeException("one")).
-     *   doThrow(new RuntimeException("two"))
-     *       .when(mock).someVoidMethod();
-     * </code></pre>
-     * See javadoc for {@link Mockito#doThrow(Throwable[])}
-     *
-     * @param toBeThrown to be thrown when the stubbed method is called
-     * @return stubber - to select a method for stubbing
-     */
-    Stubber doThrow(Throwable... toBeThrown);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doThrow(Class)} style:
-     * <pre class="code"><code class="java">
-     *   doThrow(RuntimeException.class).
-     *   doThrow(IllegalArgumentException.class)
-     *       .when(mock).someVoidMethod();
-     * </code></pre>
-     * See javadoc for {@link Mockito#doThrow(Class)}
-     *
-     * @param toBeThrown exception class to be thrown when the stubbed method is called
-     * @return stubber - to select a method for stubbing
-     *
-     * @since 2.1.0
-     */
-    Stubber doThrow(Class<? extends Throwable> toBeThrown);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doThrow(Class)} style:
-     * <pre class="code"><code class="java">
-     *   doThrow(RuntimeException.class).
-     *   doThrow(IllegalArgumentException.class)
-     *       .when(mock).someVoidMethod();
-     * </code></pre>
-     * See javadoc for {@link Mockito#doThrow(Class)}
-     *
-     * @param toBeThrown exception class to be thrown when the stubbed method is called
-     * @param nextToBeThrown exception class next to be thrown when the stubbed method is called
-     * @return stubber - to select a method for stubbing
-     *
-     * @since 2.1.0
-     */
-    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation
-    @SuppressWarnings ({"unchecked", "varargs"})
-    Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doAnswer(Answer)} style:
-     * <pre class="code"><code class="java">
-     *   doAnswer(answerOne).
-     *   doAnswer(answerTwo)
-     *       .when(mock).someVoidMethod();
-     * </code></pre>
-     * See javadoc for {@link Mockito#doAnswer(Answer)}
-     *
-     * @param answer to answer when the stubbed method is called
-     * @return stubber - to select a method for stubbing
-     */
-    Stubber doAnswer(Answer answer);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doNothing()} style:
-     * <pre class="code"><code class="java">
-     *   doNothing().
-     *   doThrow(new RuntimeException("two"))
-     *       .when(mock).someVoidMethod();
-     * </code></pre>
-     * See javadoc for {@link Mockito#doNothing()}
-     *
-     * @return stubber - to select a method for stubbing
-     */
-    Stubber doNothing();
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doReturn(Object)} style.
-     * <p>
-     * See javadoc for {@link Mockito#doReturn(Object)}
-     *
-     * @param toBeReturned to be returned when the stubbed method is called
-     * @return stubber - to select a method for stubbing
-     */
-    Stubber doReturn(Object toBeReturned);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doReturn(Object)} style.
-     * <p>
-     * See javadoc for {@link Mockito#doReturn(Object, Object...)}
-     *
-     * @param toBeReturned to be returned when the stubbed method is called
-     * @param nextToBeReturned to be returned in consecutive calls when the stubbed method is called
-     * @return stubber - to select a method for stubbing
-     */
-    @SuppressWarnings({"unchecked", "varargs"})
-    Stubber doReturn(Object toBeReturned, Object... nextToBeReturned);
-
-    /**
-     * Use it for stubbing consecutive calls in {@link Mockito#doCallRealMethod()} style.
-     * <p>
-     * See javadoc for {@link Mockito#doCallRealMethod()}
-     *
-     * @return stubber - to select a method for stubbing
-     */
-    Stubber doCallRealMethod();
 }
diff --git a/src/main/java/org/mockito/stubbing/Stubbing.java b/src/main/java/org/mockito/stubbing/Stubbing.java
index 09856fb..cba0917 100644
--- a/src/main/java/org/mockito/stubbing/Stubbing.java
+++ b/src/main/java/org/mockito/stubbing/Stubbing.java
@@ -4,9 +4,12 @@
  */
 package org.mockito.stubbing;
 
+import org.mockito.Incubating;
 import org.mockito.MockingDetails;
+import org.mockito.Mockito;
 import org.mockito.NotExtensible;
 import org.mockito.invocation.Invocation;
+import org.mockito.quality.Strictness;
 
 /**
  * Stubbing declared on the mock object.
@@ -50,4 +53,13 @@
      * @since 2.2.3
      */
     boolean wasUsed();
+
+    /**
+     * Informs about the {@link Strictness} level of this stubbing.
+     * For more information about setting strictness for stubbings see {@link Mockito#lenient()}.
+     *
+     * @since 2.20.0
+     */
+    @Incubating
+    Strictness getStrictness();
 }
diff --git a/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java b/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
index 7670183..1d9dfbb 100644
--- a/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
+++ b/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
@@ -63,7 +63,7 @@
             @SuppressWarnings("unchecked")
             public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
                 for (Annotation firstParamAnnotation : firstParamAnnotations) {
-                    if (annotationClass.isAssignableFrom(firstParamAnnotation.getClass())) {
+                    if (annotationClass.isAssignableFrom(firstParamAnnotation.annotationType())) {
                         return (T) firstParamAnnotation;
                     }
                 }
diff --git a/src/test/java/org/mockito/MockitoTest.java b/src/test/java/org/mockito/MockitoTest.java
index 3b96aff..ca8c4d4 100644
--- a/src/test/java/org/mockito/MockitoTest.java
+++ b/src/test/java/org/mockito/MockitoTest.java
@@ -25,11 +25,13 @@
         assertThat(mockingProgress().pullOngoingStubbing()).isNull();
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=NotAMockException.class)
     public void shouldValidateMockWhenVerifying() {
         Mockito.verify("notMock");
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=NotAMockException.class)
     public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() {
         Mockito.verify("notMock", times(19));
@@ -45,6 +47,7 @@
         Mockito.verifyZeroInteractions("notMock");
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=NotAMockException.class)
     public void shouldValidateMockWhenCreatingInOrderObject() {
         Mockito.inOrder("notMock");
diff --git a/src/test/java/org/mockito/StaticMockingExperimentTest.java b/src/test/java/org/mockito/StaticMockingExperimentTest.java
index bb5e225..cc8a598 100644
--- a/src/test/java/org/mockito/StaticMockingExperimentTest.java
+++ b/src/test/java/org/mockito/StaticMockingExperimentTest.java
@@ -54,6 +54,7 @@
         staticMethod = Foo.class.getDeclaredMethod("staticMethod", String.class);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void verify_static_method() throws Throwable {
         //register staticMethod call on mock
@@ -81,6 +82,7 @@
         handler.handle(differentArg);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void verification_failure_static_method() throws Throwable {
         //register staticMethod call on mock
@@ -178,6 +180,7 @@
         assertEquals(null, result2);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void verifying_new() throws Throwable {
         Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
diff --git a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java b/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
index c243e92..6baae82 100644
--- a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
+++ b/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
@@ -46,6 +46,7 @@
         super.resetState();
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldDetectUnfinishedStubbing() {
         when(mock.simpleMethod());
@@ -70,6 +71,7 @@
         detectsAndCleansUp(new OnDoAnswer(), UnfinishedStubbingException.class);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldDetectUnfinishedDoAnswerStubbing() {
         doAnswer(null);
@@ -94,6 +96,7 @@
         detectsAndCleansUp(new OnDoAnswer(), UnfinishedStubbingException.class);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldDetectUnfinishedVerification() {
         verify(mock);
@@ -149,6 +152,7 @@
         } catch (RuntimeException e) {}
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldCorrectStateAfterDetectingUnfinishedVerification() {
         mock.simpleMethod();
@@ -167,36 +171,42 @@
     }
 
     private static class OnVerify implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             verify(mock);
         }
     }
 
     private static class OnVerifyInOrder implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             inOrder(mock).verify(mock);
         }
     }
 
     private static class OnVerifyZeroInteractions implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             verifyZeroInteractions(mock);
         }
     }
 
     private static class OnVerifyNoMoreInteractions implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             verifyNoMoreInteractions(mock);
         }
     }
 
     private static class OnDoAnswer implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             doAnswer(null);
         }
     }
 
     private static class OnStub implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             when(mock);
         }
@@ -209,12 +219,14 @@
     }
 
     private static class OnMockCreation implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             mock(IMethods.class);
         }
     }
 
     private static class OnSpyCreation implements DetectsInvalidState {
+        @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
         public void detect(IMethods mock) {
             spy(new Object());
         }
diff --git a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
index 61646d7..0937b69 100644
--- a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
+++ b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
@@ -74,6 +74,7 @@
         verifyNoMoreInteractions(listener);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void removes_creation_listener() {
         //given creation listener is added
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
index b07ece4..7172998 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
+++ b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
@@ -185,4 +185,15 @@
         previous = InvocationsFinder.findPreviousVerifiedInOrder(invocations, context);
         assertSame(simpleMethodInvocationTwo, previous);
     }
+
+    @Test
+    public void shouldFindAllStackTraces() {
+        List<Location> all = InvocationsFinder.getAllLocations(invocations);
+        Assertions.assertThat(all).contains(simpleMethodInvocation.getLocation(), simpleMethodInvocationTwo.getLocation(), differentMethodInvocation.getLocation());
+    }
+
+    @Test
+    public void shouldNotFindLocationsForEmptyInvocationsList() {
+        Assertions.assertThat(InvocationsFinder.getAllLocations(Collections.<Invocation>emptyList())).isEmpty();
+    }
 }
diff --git a/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java b/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
index ce389b0..46a75eb 100644
--- a/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
+++ b/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
@@ -14,13 +14,17 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentMatcher;
 import org.mockito.Mock;
+import org.mockito.internal.hamcrest.HamcrestArgumentMatcher;
 import org.mockito.internal.matchers.Any;
 import org.mockito.internal.matchers.Equals;
 import org.mockito.internal.matchers.InstanceOf;
+import org.mockito.internal.matchers.VarargMatcher;
 import org.mockito.invocation.Invocation;
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
@@ -186,6 +190,27 @@
         recordAction.assertContainsExactly(ANY, ANY);
     }
 
+    @Test
+    public void shouldMatchAnyVarargEvenIfMatcherIsWrappedInHamcrestMatcher() {
+        // given
+        invocation = varargs("1", "2");
+        HamcrestArgumentMatcher argumentMatcher = new HamcrestArgumentMatcher(new IntMatcher());
+        matchers = asList(argumentMatcher);
+
+        // when
+        getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+
+        // then
+        recordAction.assertContainsExactly(argumentMatcher, argumentMatcher);
+    }
+
+    class IntMatcher extends BaseMatcher<Integer> implements VarargMatcher {
+        public boolean matches(Object o) {
+            return true;
+        }
+        public void describeTo(Description description) {}
+    }
+
     private Invocation mixedVarargs(Object a, String... s) {
         mock.mixedVarargs(a, s);
         return getLastInvocation();
diff --git a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java b/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
index c4a8b53..7d5968d 100644
--- a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
+++ b/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
@@ -32,12 +32,14 @@
         throw new RuntimeException("foo");
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void detects_invalid_mockito_usage_on_success() throws Throwable {
         rule.expectFailure(UnfinishedStubbingException.class);
         when(mock.simpleMethod());
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void does_not_check_invalid_mockito_usage_on_failure() throws Throwable {
         //This intended behavior is questionable
diff --git a/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java b/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
index 8d11dc2..af1d3a1 100644
--- a/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
+++ b/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
@@ -4,9 +4,6 @@
  */
 package org.mockito.internal.junit;
 
-import java.util.Arrays;
-import java.util.Collections;
-
 import org.junit.Test;
 import org.mockito.internal.invocation.InvocationBuilder;
 import org.mockito.internal.stubbing.StubbedInvocationMatcher;
@@ -14,6 +11,9 @@
 import org.mockito.stubbing.Stubbing;
 import org.mockitoutil.TestBase;
 
+import java.util.Arrays;
+import java.util.Collections;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
@@ -38,8 +38,8 @@
     public void unused_stubbings() throws Exception {
         //given
         UnusedStubbings stubbings = new UnusedStubbings(Arrays.asList(
-            new StubbedInvocationMatcher(new InvocationBuilder().toInvocationMatcher(), doesNothing()),
-            new StubbedInvocationMatcher(new InvocationBuilder().toInvocationMatcher(), doesNothing())
+            new StubbedInvocationMatcher(doesNothing(), new InvocationBuilder().toInvocationMatcher(), null),
+            new StubbedInvocationMatcher(doesNothing(), new InvocationBuilder().toInvocationMatcher(), null)
         ));
 
 
diff --git a/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java b/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
new file mode 100644
index 0000000..ac963c4
--- /dev/null
+++ b/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.listeners;
+
+import org.assertj.core.util.Lists;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
+import org.mockitoutil.TestBase;
+
+import java.util.Collection;
+import java.util.List;
+
+import static org.assertj.core.util.Lists.emptyList;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
+
+public class StubbingLookupNotifierTest extends TestBase {
+
+    Invocation invocation = mock(Invocation.class);
+    Stubbing stubbingFound = mock(Stubbing.class);
+    Collection<Stubbing> allStubbings = mock(Collection.class);
+    CreationSettings creationSettings = mock(CreationSettings.class);
+
+    @Test
+    public void does_not_do_anything_when_list_is_empty() {
+        // given
+        doReturn(emptyList()).when(creationSettings).getStubbingLookupListeners();
+
+        // when
+        notifyStubbedAnswerLookup(invocation, stubbingFound, allStubbings, creationSettings);
+
+        // then expect nothing to happen
+    }
+
+    @Test
+    public void call_on_stubbing_lookup_method_of_listeners_with_correct_event() {
+        // given
+        StubbingLookupListener listener1 = mock(StubbingLookupListener.class);
+        StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
+        List<StubbingLookupListener> listeners = Lists.newArrayList(listener1, listener2);
+        doReturn(listeners).when(creationSettings).getStubbingLookupListeners();
+
+        // when
+        notifyStubbedAnswerLookup(invocation, stubbingFound, allStubbings, creationSettings);
+
+        // then
+        verify(listener1).onStubbingLookup(argThat(new EventArgumentMatcher()));
+        verify(listener2).onStubbingLookup(argThat(new EventArgumentMatcher()));
+    }
+
+    class EventArgumentMatcher implements ArgumentMatcher<StubbingLookupNotifier.Event> {
+
+        @Override
+        public boolean matches(StubbingLookupNotifier.Event argument) {
+            return invocation == argument.getInvocation() &&
+                stubbingFound == argument.getStubbingFound() &&
+                allStubbings == argument.getAllStubbings() &&
+                creationSettings == argument.getMockSettings();
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java b/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
index 5535eec..673ca10 100644
--- a/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
+++ b/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
@@ -34,6 +34,7 @@
         assertNotNull(p.pullVerificationMode());
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldKnowWhenVerificationHasStarted() throws Exception {
         //given
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
index de5eb13..52e481d 100644
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
@@ -46,7 +46,7 @@
     public void should_finish_stubbing_when_wrong_throwable_is_set() throws Exception {
         state.stubbingStarted();
         try {
-            invocationContainerImpl.addAnswer(new ThrowsException(new Exception()));
+            invocationContainerImpl.addAnswer(new ThrowsException(new Exception()), null);
             fail();
         } catch (MockitoException e) {
             state.validateState();
@@ -56,18 +56,18 @@
     @Test
     public void should_finish_stubbing_on_adding_return_value() throws Exception {
         state.stubbingStarted();
-        invocationContainerImpl.addAnswer(new Returns("test"));
+        invocationContainerImpl.addAnswer(new Returns("test"), null);
         state.validateState();
     }
 
     @Test
     public void should_get_results_for_methods() throws Throwable {
         invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
-        invocationContainerImpl.addAnswer(new Returns("simpleMethod"));
+        invocationContainerImpl.addAnswer(new Returns("simpleMethod"), null);
 
         Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
         invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
-        invocationContainerImpl.addAnswer(new ThrowsException(new MyException()));
+        invocationContainerImpl.addAnswer(new ThrowsException(new MyException()), null);
 
         assertEquals("simpleMethod", invocationContainerImpl.answerTo(simpleMethod));
 
@@ -80,11 +80,11 @@
     @Test
     public void should_get_results_for_methods_stub_only() throws Throwable {
         invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
-        invocationContainerImplStubOnly.addAnswer(new Returns("simpleMethod"));
+        invocationContainerImplStubOnly.addAnswer(new Returns("simpleMethod"), null);
 
         Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
         invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
-        invocationContainerImplStubOnly.addAnswer(new ThrowsException(new MyException()));
+        invocationContainerImplStubOnly.addAnswer(new ThrowsException(new MyException()), null);
 
         assertEquals("simpleMethod", invocationContainerImplStubOnly.answerTo(simpleMethod));
 
@@ -97,7 +97,7 @@
     @Test
     public void should_validate_throwable() throws Throwable {
         try {
-            invocationContainerImpl.addAnswer(new ThrowsException(null));
+            invocationContainerImpl.addAnswer(new ThrowsException(null), null);
             fail();
         } catch (MockitoException e) {}
     }
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
index 176372f..c63d6e9 100644
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
@@ -4,12 +4,6 @@
  */
 package org.mockito.internal.stubbing;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.LinkedList;
-import java.util.concurrent.CountDownLatch;
 import org.junit.Test;
 import org.mockito.internal.creation.MockSettingsImpl;
 import org.mockito.internal.invocation.InvocationBuilder;
@@ -19,6 +13,13 @@
 import org.mockito.invocation.Invocation;
 import org.mockito.mock.MockCreationSettings;
 
+import java.util.LinkedList;
+import java.util.concurrent.CountDownLatch;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 /**
  * Author: Szczepan Faber
  */
@@ -54,7 +55,7 @@
                         throw new RuntimeException(e);
                     }
                     c.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
-                    c.addAnswer(new Returns("foo"));
+                    c.addAnswer(new Returns("foo"), null);
                     c.findAnswerFor(invocation);
                 }
             };
@@ -98,7 +99,7 @@
         container.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
         assertTrue(container.hasInvocationForPotentialStubbing());
 
-        container.addAnswer(new ReturnsEmptyValues());
+        container.addAnswer(new ReturnsEmptyValues(), null);
         assertFalse(container.hasInvocationForPotentialStubbing());
     }
 
@@ -107,7 +108,7 @@
         containerStubOnly.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
         assertTrue(containerStubOnly.hasInvocationForPotentialStubbing());
 
-        containerStubOnly.addAnswer(new ReturnsEmptyValues());
+        containerStubOnly.addAnswer(new ReturnsEmptyValues(), null);
         assertFalse(containerStubOnly.hasInvocationForPotentialStubbing());
     }
 }
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
index 8b553aa..2e71102 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
@@ -10,7 +10,9 @@
 import org.junit.Test;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
 
+import static junit.framework.TestCase.fail;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
@@ -19,7 +21,7 @@
     @Test
     public void should_raise_wanted_throwable() throws Throwable {
         try {
-            new ThrowsException(new IllegalStateException("my dear throwable")).answer(new InvocationBuilder().method("canThrowException").toInvocation());
+            new ThrowsException(new IllegalStateException("my dear throwable")).answer(createMethodInvocation());
             Assertions.fail("should have raised wanted exception");
         } catch (Throwable throwable) {
             assertThat(throwable).isInstanceOf(IllegalStateException.class).hasMessage("my dear throwable");
@@ -29,7 +31,7 @@
     @Test
     public void should_throw_mock_exception_without_stacktrace() throws Exception {
         try {
-            new ThrowsException(mock(Exception.class)).answer(new InvocationBuilder().method("canThrowException").toInvocation());
+            new ThrowsException(mock(Exception.class)).answer(createMethodInvocation());
             Assertions.fail("should have raised wanted exception");
         } catch (Throwable throwable) {
             assertThat(throwable.getStackTrace()).describedAs("no stack trace, it's mock").isNull();
@@ -46,7 +48,7 @@
         try {
 
             // when
-            new ThrowsException(throwableToRaise).answer(new InvocationBuilder().method("canThrowException").toInvocation());
+            new ThrowsException(throwableToRaise).answer(createMethodInvocation());
             Assertions.fail("should have raised wanted exception");
         } catch (Throwable throwable) {
             // then
@@ -59,24 +61,42 @@
     @Test
     public void should_invalidate_null_throwable() throws Throwable {
         try {
-            new ThrowsException(null).validateFor(new InvocationBuilder().toInvocation());
+            Invocation invocation = createMethodInvocation();
+            new ThrowsException(null).validateFor(invocation);
             Assertions.fail("should have raised a MockitoException");
         } catch (MockitoException expected) {}
     }
 
     @Test
+    public void should_throw_illegal_state_exception_if_null_answer() throws Throwable {
+        Invocation invocation = createMethodInvocation();
+        try {
+            new ThrowsException(null).answer(invocation);
+            fail();
+        } catch (IllegalStateException expected) {
+        }
+    }
+
+    @Test
     public void should_pass_proper_checked_exception() throws Throwable {
-        new ThrowsException(new CharacterCodingException()).validateFor(new InvocationBuilder().method("canThrowException").toInvocation());
+        new ThrowsException(new CharacterCodingException()).validateFor(createMethodInvocation());
     }
 
     @Test(expected = MockitoException.class)
     public void should_fail_invalid_checked_exception() throws Throwable {
-        new ThrowsException(new IOException()).validateFor(new InvocationBuilder().method("canThrowException").toInvocation());
+        new ThrowsException(new IOException()).validateFor(createMethodInvocation());
     }
 
     @Test
     public void should_pass_RuntimeExceptions() throws Throwable {
-        new ThrowsException(new Error()).validateFor(new InvocationBuilder().method("canThrowException").toInvocation());
-        new ThrowsException(new RuntimeException()).validateFor(new InvocationBuilder().method("canThrowException").toInvocation());
+        new ThrowsException(new Error()).validateFor(createMethodInvocation());
+        new ThrowsException(new RuntimeException()).validateFor(createMethodInvocation());
+    }
+
+    /** Creates Invocation of a "canThrowException" method call. */
+    private static Invocation createMethodInvocation() {
+        return new InvocationBuilder()
+            .method("canThrowException")
+            .toInvocation();
     }
 }
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
index 945cf08..68fbaf5 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
@@ -74,6 +74,7 @@
         assertTrue(result != (Object) 0);
     }
 
+    @SuppressWarnings("SelfComparison")
     @Test
     public void should_return_zero_if_mock_is_compared_to_itself() {
         //given
diff --git a/src/test/java/org/mockito/internal/util/PrimitivesTest.java b/src/test/java/org/mockito/internal/util/PrimitivesTest.java
index 2896bd4..34dd362 100644
--- a/src/test/java/org/mockito/internal/util/PrimitivesTest.java
+++ b/src/test/java/org/mockito/internal/util/PrimitivesTest.java
@@ -69,21 +69,21 @@
 
     @Test
     public void should_check_that_value_type_is_assignable_to_wrapper_reference() {
-        assertThat(Primitives.isAssignableFromWrapper(int.class, Integer.class));
-        assertThat(Primitives.isAssignableFromWrapper(Integer.class, Integer.class));
-        assertThat(Primitives.isAssignableFromWrapper(long.class, Long.class));
-        assertThat(Primitives.isAssignableFromWrapper(Long.class, Long.class));
-        assertThat(Primitives.isAssignableFromWrapper(double.class, Double.class));
-        assertThat(Primitives.isAssignableFromWrapper(Double.class, Double.class));
-        assertThat(Primitives.isAssignableFromWrapper(float.class, Float.class));
-        assertThat(Primitives.isAssignableFromWrapper(Float.class, Float.class));
-        assertThat(Primitives.isAssignableFromWrapper(char.class, Character.class));
-        assertThat(Primitives.isAssignableFromWrapper(Character.class, Character.class));
-        assertThat(Primitives.isAssignableFromWrapper(short.class, Short.class));
-        assertThat(Primitives.isAssignableFromWrapper(Short.class, Short.class));
-        assertThat(Primitives.isAssignableFromWrapper(byte.class, Byte.class));
-        assertThat(Primitives.isAssignableFromWrapper(Byte.class, Byte.class));
-        assertThat(Primitives.isAssignableFromWrapper(boolean.class, Boolean.class));
-        assertThat(Primitives.isAssignableFromWrapper(Boolean.class, Boolean.class));
+        assertThat(Primitives.isAssignableFromWrapper(int.class, Integer.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Integer.class, Integer.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(long.class, Long.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Long.class, Long.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(double.class, Double.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Double.class, Double.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(float.class, Float.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Float.class, Float.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(char.class, Character.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Character.class, Character.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(short.class, Short.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Short.class, Short.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(byte.class, Byte.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Byte.class, Byte.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(boolean.class, Boolean.class)).isTrue();
+        assertThat(Primitives.isAssignableFromWrapper(Boolean.class, Boolean.class)).isTrue();
     }
 }
diff --git a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
index af9d3cb..61b2f2e 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
@@ -5,10 +5,6 @@
 
 package org.mockito.internal.verification.checkers;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.List;
 import org.hamcrest.BaseMatcher;
 import org.hamcrest.Description;
@@ -28,6 +24,10 @@
 import org.mockito.junit.MockitoJUnitRunner;
 import org.mockitousage.IMethods;
 
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.assertj.core.api.Assertions.assertThat;
+
 @RunWith(MockitoJUnitRunner.class)
 public class NumberOfInvocationsCheckerTest {
 
@@ -58,7 +58,7 @@
     }
 
     @Test
-    public void shouldReportWithLastInvocationStackTrace() throws Exception {
+    public void shouldReportAllInvocationsStackTrace() throws Exception {
         wanted = buildSimpleMethod().toInvocationMatcher();
         invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
 
@@ -66,7 +66,7 @@
         exception.expectMessage("mock.simpleMethod()");
         exception.expectMessage("Wanted 100 times");
         exception.expectMessage("But was 2 times");
-        exception.expectMessage(containsTimes("-> at", 2));
+        exception.expectMessage(containsTimes("-> at", 3));
 
         NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100);
     }
@@ -86,7 +86,7 @@
     }
 
     @Test
-    public void shouldReportWithFirstUndesiredInvocationStackTrace() throws Exception {
+    public void shouldReportWithAllInvocationsStackTrace() throws Exception {
         Invocation first = buildSimpleMethod().toInvocation();
         Invocation second = buildSimpleMethod().toInvocation();
         Invocation third = buildSimpleMethod().toInvocation();
@@ -95,6 +95,8 @@
         wanted = buildSimpleMethod().toInvocationMatcher();
 
         exception.expect(TooManyActualInvocations.class);
+        exception.expectMessage("" + first.getLocation());
+        exception.expectMessage("" + second.getLocation());
         exception.expectMessage("" + third.getLocation());
         NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 2);
     }
diff --git a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
index 2e72033..bc031ac 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
@@ -5,11 +5,6 @@
 
 package org.mockito.internal.verification.checkers;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
 import java.util.List;
 
 import org.hamcrest.BaseMatcher;
@@ -27,6 +22,11 @@
 import org.mockito.invocation.Invocation;
 import org.mockitousage.IMethods;
 
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
 public class NumberOfInvocationsInOrderCheckerTest {
 
     private InvocationMatcher wanted;
@@ -102,7 +102,7 @@
     }
 
     @Test
-    public void shouldReportWithLastInvocationStackTrace() throws Exception {
+    public void shouldReportWithAllInvocationsStackTrace() throws Exception {
         wanted = buildSimpleMethod().toInvocationMatcher();
         invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
 
@@ -110,7 +110,7 @@
         exception.expectMessage("mock.simpleMethod()");
         exception.expectMessage("Wanted 100 times");
         exception.expectMessage("But was 2 times");
-        exception.expectMessage(containsTimes("-> at", 2));
+        exception.expectMessage(containsTimes("-> at", 3));
 
         NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100, context);
 
@@ -168,7 +168,7 @@
         exception.expect(VerificationInOrderFailure.class);
         exception.expectMessage("mock.simpleMethod()");
         exception.expectMessage("Wanted 0 times");
-        exception.expectMessage("But was 1 time. Undesired invocation");
+        exception.expectMessage("But was 1 time:");
         exception.expectMessage("" + first.getLocation());
 
         NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0, context);
diff --git a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java b/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
index 5d2af03..98ab7d2 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
@@ -90,6 +90,7 @@
         } catch (MockitoException e) {}
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldAllowCreatingSpiesWithCorrectType() {
         List list = new LinkedList();
diff --git a/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java b/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
index 5231a1b..31cdd04 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
@@ -19,7 +19,6 @@
 
 import java.io.ByteArrayOutputStream;
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Observable;
@@ -254,19 +253,19 @@
     @Test
     public void should_serialize_with_real_object_spy() throws Exception {
         // given
-        List<Object> list = new ArrayList<Object>();
-        List<Object> spy = mock(ArrayList.class, withSettings()
+        SerializableSample list = new SerializableSample();
+        SerializableSample spy = mock(SerializableSample.class, withSettings()
                         .spiedInstance(list)
                         .defaultAnswer(CALLS_REAL_METHODS)
                         .serializable());
-        when(spy.size()).thenReturn(100);
+        when(spy.foo()).thenReturn("foo");
 
         // when
         ByteArrayOutputStream serialized = serializeMock(spy);
 
         // then
-        List<?> readObject = deserializeMock(serialized, List.class);
-        assertEquals(100, readObject.size());
+        SerializableSample readObject = deserializeMock(serialized, SerializableSample.class);
+        assertEquals("foo", readObject.foo());
     }
 
     @Test
@@ -313,14 +312,10 @@
                 .isInstanceOf(IMethods.class);
     }
 
-
-
     static class NotSerializableAndNoDefaultConstructor {
         NotSerializableAndNoDefaultConstructor(Observable o) { super(); }
     }
 
-
-
     static class SerializableAndNoDefaultConstructor implements Serializable {
         SerializableAndNoDefaultConstructor(Observable o) { super(); }
     }
@@ -337,4 +332,11 @@
 
         serializeAndBack(testClass.serializableAndNoDefaultConstructor);
     }
+
+    public static class SerializableSample implements Serializable {
+
+        public String foo() {
+            return null;
+        }
+    }
 }
diff --git a/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java b/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
index 6445aa0..02bcc3d 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
@@ -5,6 +5,7 @@
 
 package org.mockitousage.basicapi;
 
+import net.bytebuddy.ClassFileVersion;
 import org.assertj.core.api.Assertions;
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -20,13 +21,12 @@
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectStreamException;
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Observable;
 
 import static org.junit.Assert.*;
-import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
 import static org.mockito.Mockito.*;
 import static org.mockitoutil.SimpleSerializationUtil.*;
 
@@ -275,19 +275,19 @@
     @Test
     public void should_serialize_with_real_object_spy() throws Exception {
         // given
-        List<Object> list = new ArrayList<Object>();
-        List<Object> spy = mock(ArrayList.class, withSettings()
-                .spiedInstance(list)
+        SerializableClass sample = new SerializableClass();
+        SerializableClass spy = mock(SerializableClass.class, withSettings()
+                .spiedInstance(sample)
                 .defaultAnswer(CALLS_REAL_METHODS)
                 .serializable());
-        when(spy.size()).thenReturn(100);
+        when(spy.foo()).thenReturn("foo");
 
         // when
         ByteArrayOutputStream serialized = serializeMock(spy);
 
         // then
-        List<?> readObject = deserializeMock(serialized, List.class);
-        assertEquals(100, readObject.size());
+        SerializableClass readObject = deserializeMock(serialized, SerializableClass.class);
+        assertEquals("foo", readObject.foo());
     }
 
     @Test
@@ -346,8 +346,6 @@
                 .isInstanceOf(IMethods.class);
     }
 
-
-
     static class SerializableAndNoDefaultConstructor implements Serializable {
         SerializableAndNoDefaultConstructor(Observable o) { super(); }
     }
@@ -385,7 +383,7 @@
 
     @Test
     public void BUG_ISSUE_399_try_some_mocks_with_current_answers() throws Exception {
-        assumeFalse(System.getProperty("java.version").startsWith("1.6")); // Bug in last public HotSpot 1.6
+        assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V7));
 
         IMethods iMethods = mock(IMethods.class, withSettings().serializable().defaultAnswer(RETURNS_DEEP_STUBS));
 
@@ -393,4 +391,11 @@
 
         serializeAndBack(iMethods);
     }
+
+    public static class SerializableClass implements Serializable {
+
+        public String foo() {
+            return null;
+        }
+    }
 }
diff --git a/src/test/java/org/mockitousage/basicapi/ResetTest.java b/src/test/java/org/mockitousage/basicapi/ResetTest.java
index 150945f..ef199a5 100644
--- a/src/test/java/org/mockitousage/basicapi/ResetTest.java
+++ b/src/test/java/org/mockitousage/basicapi/ResetTest.java
@@ -26,7 +26,6 @@
 
     @Test
     public void shouldResetOngoingStubbingSoThatMoreMeaningfulExceptionsAreRaised() {
-        mock(IMethods.class);
         mock.booleanReturningMethod();
         reset(mock);
         try {
@@ -95,6 +94,7 @@
         verifyNoMoreInteractions(mock, mockTwo);
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldValidateStateWhenResetting() {
         //invalid verify:
diff --git a/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java b/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
index b4f38bf..632c8c9 100644
--- a/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
+++ b/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
@@ -29,9 +29,10 @@
         //then
         try {
             verify(mockFun).doFun("hello");
-            fail();
         } catch(AssertionError r) {
             //it's ok, we just want to reproduce the bug
+            return;
         }
+        fail();
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java b/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
new file mode 100644
index 0000000..5e3193e
--- /dev/null
+++ b/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2017 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.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+
+/**
+ * These tests check that ThrowsException#answer throws an instance returned
+ * by Throwable#fillInStackTrace of the provided throwable.
+ *
+ * <p>A well-behaved Throwable implementation must always return a reference to this
+ * from #fillInStackTrace according to the method contract.
+ * However, Mockito throws the exception returned from #fillInStackTrace for backwards compatibility
+ * (or the provided exception if the method returns null).
+ *
+ * @see Throwable#fillInStackTrace()
+ * @see <a href="https://github.com/mockito/mockito/issues/866">#866</a>
+ */
+public class FillInStackTraceScenariosTest extends TestBase {
+
+    @Mock IMethods mock;
+
+    private class SomeException extends RuntimeException {}
+
+    class NullStackTraceException extends RuntimeException {
+        public Exception fillInStackTrace() {
+            return null;
+        }
+    }
+
+    class NewStackTraceException extends RuntimeException {
+        public Exception fillInStackTrace() {
+            return new SomeException();
+        }
+    }
+
+    //issue 866
+    @Test
+    public void avoids_NPE() {
+        when(mock.simpleMethod()).thenThrow(new NullStackTraceException());
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch(NullStackTraceException e) {}
+    }
+
+    @Test
+    public void uses_return_value_from_fillInStackTrace() {
+        when(mock.simpleMethod()).thenThrow(new NewStackTraceException());
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch(SomeException e) {}
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/NPEWhenCustomExceptionStackTraceReturnNullTest.java b/src/test/java/org/mockitousage/bugs/NPEWhenCustomExceptionStackTraceReturnNullTest.java
deleted file mode 100644
index 92a1305..0000000
--- a/src/test/java/org/mockitousage/bugs/NPEWhenCustomExceptionStackTraceReturnNullTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2017 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.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.when;
-
-public class NPEWhenCustomExceptionStackTraceReturnNullTest extends TestBase {
-
-    @Mock
-    IMethods mock;
-
-    class NullStackTraceException extends RuntimeException {
-        @Override
-        public Exception fillInStackTrace() {
-            return null;
-        }
-    }
-
-    //issue 866
-    @Test
-    public void shouldNotThrowNPE() {
-        when(mock.simpleMethod()).thenThrow(new NullStackTraceException());
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch(NullStackTraceException e) {}
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java b/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
index 9a96741..2b0cbff 100644
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
+++ b/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
@@ -10,8 +10,13 @@
 import org.mockitoutil.TestBase;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.anyObject;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.anyVararg;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 //see issue 62
 public class VarargsNotPlayingWithAnyObjectTest extends TestBase {
@@ -35,16 +40,10 @@
         verify(mock, never()).run(anyString(), eq("f"));
     }
 
-    //we cannot use anyObject() for entire varargs because it makes the verification pick up extra invocations
-    //see other tests in this package
     @Test
-    public void shouldNotAllowUsingAnyObjectForVarArgs() {
+    public void shouldAllowUsingAnyObjectForVarArgs() {
         mock.run("a", "b");
-
-        try {
-            verify(mock).run((String[]) anyObject());
-            fail();
-        } catch (AssertionError e) {}
+        verify(mock).run((String[]) anyObject());
     }
 
     @Test
diff --git a/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java b/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
index 8b0332d..fe626b0 100644
--- a/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
+++ b/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
@@ -248,6 +248,7 @@
         }
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void mocking_interfaces_with_constructor() {
         //at the moment this is allowed however we can be more strict if needed
diff --git a/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java b/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
index b03d5d7..0eb3d7d 100644
--- a/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
+++ b/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
@@ -16,6 +16,7 @@
 
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.when;
 
 /**
@@ -86,10 +87,28 @@
     }
 
     @Test
+    public void unused_and_lenient_stubbings() throws Exception {
+        when(mock1.simpleMethod(1)).thenReturn("1");
+        when(mock1.simpleMethod(2)).thenReturn("2");
+        lenient().when(mock2.simpleMethod(3)).thenReturn("3");
+
+        mock1.simpleMethod(1);
+
+        //when
+        UnusedStubbings stubbings = finder.getUnusedStubbings((List) asList(mock1, mock2));
+
+        //then
+        assertEquals(1, stubbings.size());
+        assertEquals("[mock1.simpleMethod(2); stubbed with: [Returns: 2]]",
+                stubbings.toString());
+    }
+
+    @Test
     public void some_unused_stubbings_by_location() throws Exception {
         when(mock1.simpleMethod(1)).thenReturn("1");
         when(mock2.simpleMethod(2)).thenReturn("2");
         when(mock2.simpleMethod(3)).thenReturn("3");
+        lenient().when(mock2.differentMethod()).thenReturn("4"); //will not be included in results
 
         mock2.simpleMethod(2);
 
diff --git a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
index f4e3e95..b802013 100644
--- a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
@@ -157,6 +157,7 @@
         mock2.booleanObjectReturningMethod();
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test public void rule_validates_mockito_usage() throws Throwable {
         //expect
         rule.expectFailure(UnfinishedVerificationException.class);
diff --git a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
index 284b197..f22d7ac 100644
--- a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
@@ -104,6 +104,8 @@
     @RunWith(MockitoJUnitRunner.Silent.class)
     public static class UsesFrameworkIncorrectly {
         @Mock List<?> list;
+
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
         @Test public void unfinished_stubbing_test_method() {
             when(list.get(0)); //unfinished stubbing
         }
diff --git a/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
index bc7fd2b..7d8d537 100644
--- a/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
@@ -119,6 +119,7 @@
     @RunWith(TestableJUnitRunner.class)
     public static class InvalidMockitoUsage {
         @Mock IMethods mock;
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
         @Test public void test() throws Exception {
             when(mock.simpleMethod()); // <-- unfinished stubbing
         }
diff --git a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
index ad27b48..46773b8 100644
--- a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
@@ -5,15 +5,16 @@
 
 package org.mockitousage.matchers;
 
+import org.assertj.core.api.ThrowableAssert;
 import org.junit.Test;
 import org.mockito.Mock;
+import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
 import java.util.*;
-
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -44,16 +45,21 @@
         verify(mock).simpleMethod(isA(List.class));
         verify(mock).simpleMethod(any(List.class));
 
-
         mock.simpleMethod((String) null);
-        try {
-            verify(mock).simpleMethod(isA(String.class));
-            fail();
-        } catch (AssertionError ignored) { }
-        try {
-            verify(mock).simpleMethod(any(String.class));
-            fail();
-        } catch (AssertionError ignored) { }
+
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock).simpleMethod(isA(String.class));
+            }
+        }).isInstanceOf(ArgumentsAreDifferent.class);
+
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock).simpleMethod(any(String.class));
+            }
+        }).isInstanceOf(ArgumentsAreDifferent.class);
     }
 
     @Test
diff --git a/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java b/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
index 09f0034..41e4a16 100644
--- a/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
+++ b/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
@@ -61,6 +61,7 @@
 //        when(mock.differentMethod()).thenReturn("");
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test(expected=NotAMockException.class)
     public void shouldScreamWhenWholeMethodPassedToVerify() {
         verify(mock.booleanReturningMethod());
@@ -71,16 +72,19 @@
         verifyNoMoreInteractions(mock.byteReturningMethod());
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=NotAMockException.class)
     public void shouldScreamWhenInOrderCreatedWithDodgyMock() {
         inOrder("not a mock");
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=NullInsteadOfMockException.class)
     public void shouldScreamWhenInOrderCreatedWithNulls() {
         inOrder(mock, null);
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test(expected=NullInsteadOfMockException.class)
     public void shouldScreamNullPassedToVerify() {
         verify(null);
diff --git a/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java b/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
index 7bf1896..267e93c 100644
--- a/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
+++ b/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
@@ -83,6 +83,7 @@
     }
 
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldSayUnfinishedVerificationButNotInvalidUseOfMatchers() {
         assumeTrue("Does not apply for inline mocks", withFinal.getClass() != WithFinal.class);
diff --git a/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java b/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
index 0fcb41c..9ebc690 100644
--- a/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
+++ b/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
@@ -23,6 +23,7 @@
 
     @Mock IMethods mock;
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldValidateExplicitly() {
         verify(mock);
@@ -32,6 +33,7 @@
         } catch (UnfinishedVerificationException e) {}
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldDetectUnfinishedStubbing() {
         when(mock.simpleMethod());
diff --git a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
index ff3ca09..2197300 100644
--- a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
+++ b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
@@ -37,6 +37,7 @@
         verifyZeroInteractions();
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=MockitoException.class)
     public void shouldNotCreateInOrderObjectWithoutMocks() {
         inOrder();
@@ -82,6 +83,7 @@
         assumeFalse("Inlining mock allows mocking final classes", mock(FinalClass.class).getClass() == FinalClass.class);
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test(expected=MockitoException.class)
     public void shouldNotAllowMockingPrimitives() throws Exception {
         mock(Integer.TYPE);
@@ -104,6 +106,7 @@
         verifyZeroInteractions(inter);
     }
 
+    @Test
     public void shouldNotMockObjectMethodsOnClass() throws Exception {
         Object clazz = mock(ObjectLikeInterface.class);
 
diff --git a/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java b/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
index b06d073..b740508 100644
--- a/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
+++ b/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
@@ -16,6 +16,7 @@
 
     class Bar {}
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldMockPackageProtectedClasses() {
         mock(PackageProtected.class);
diff --git a/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java b/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
index 1f12cdf..3294614 100644
--- a/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
+++ b/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
@@ -59,31 +59,56 @@
         // then revert to the default RETURNS_DEEP_STUBS and the code will raise a ClassCastException
     }
 
-
     static class SampleClass implements Serializable {
-        SampleClass2 getSample() { return new SampleClass2(); }
+
+        SampleClass2 getSample() {
+            return new SampleClass2();
+        }
     }
 
     static class SampleClass2 implements Serializable {
-        boolean isFalse() { return false; }
-        int number() { return 100; }
+
+        boolean isFalse() {
+            return false;
+        }
+
+        int number() {
+            return 100;
+        }
     }
 
     static class Container<E> implements Iterable<E>, Serializable {
+
         private E e;
-        public Container(E e) { this.e = e; }
-        public E get() { return e; }
+
+        public Container(E e) {
+            this.e = e;
+        }
+
+        public E get() {
+            return e;
+        }
 
         public Iterator<E> iterator() {
             return new Iterator<E>() {
-                public boolean hasNext() { return true; }
-                public E next() { return e; }
-                public void remove() { }
+                public boolean hasNext() {
+                    return true;
+                }
+
+                public E next() {
+                    return e;
+                }
+
+                public void remove() {
+                }
             };
         }
     }
 
     static class ListContainer extends Container<List<String>> {
-        public ListContainer(List<String> list) { super(list); }
+
+        public ListContainer(List<String> list) {
+            super(list);
+        }
     }
 }
diff --git a/src/test/java/org/mockitousage/session/MockitoSessionTest.java b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
index 960d888..a87928c 100644
--- a/src/test/java/org/mockitousage/session/MockitoSessionTest.java
+++ b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
@@ -151,6 +151,7 @@
             mockito.finishMocking();
         }
 
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
         @Test public void unfinished_stubbing() {
             when(mock.simpleMethod());
         }
@@ -165,6 +166,7 @@
             mockito.finishMocking();
         }
 
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
         @Test public void unfinished_stubbing_with_other_failure() {
             when(mock.simpleMethod());
             assertTrue(false);
@@ -214,6 +216,7 @@
             mockito.finishMocking(new RuntimeException("Boo!"));
         }
 
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
         @Test public void invalid_mockito_usage() {
             verify(mock);
         }
diff --git a/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java b/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
index f67c623..8603ca0 100644
--- a/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
+++ b/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
@@ -40,6 +40,7 @@
         verify(spy).add("two");
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldBeAbleToMockObjectBecauseWhyNot() {
         spy(new Object());
diff --git a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java b/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
index bdefa14..e9a98c1 100644
--- a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
@@ -44,6 +44,7 @@
         }
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     private void unfinishedStubbingHere() {
         when(mock.simpleMethod());
     }
@@ -73,6 +74,7 @@
         }
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     private void unfinishedVerificationHere() {
         verify(mock);
     }
diff --git a/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java b/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
index a09ee71..e1bd9af 100644
--- a/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
@@ -32,6 +32,7 @@
         super.makeStackTracesClean();
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void makeSureStateIsValidatedInTheVeryFirstTestThanksToTheRunner() {
         //mess up the state:
@@ -137,6 +138,7 @@
         m.simpleMethod();
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldPointOutUnfinishedStubbing() {
         when(mock.simpleMethod());
@@ -167,26 +169,31 @@
         argument.getValue();
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldScreamWhenNullPassedInsteadOfAnInterface() {
         mock(IMethods.class, withSettings().extraInterfaces(List.class, null));
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldScreamWhenNonInterfacePassed() {
         mock(IMethods.class, withSettings().extraInterfaces(LinkedList.class));
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldScreamWhenExtraIsTheSame() {
         mock(IMethods.class, withSettings().extraInterfaces(IMethods.class));
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldScreamWhenExtraInterfacesEmpty() {
         mock(IMethods.class, withSettings().extraInterfaces());
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldScreamWhenExtraInterfacesIsANullArray() {
         mock(IMethods.class, withSettings().extraInterfaces((Class<?>[]) null));
diff --git a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
index 23f6033..6186130 100644
--- a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
@@ -72,6 +72,7 @@
         }
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldFilterStacktraceOnMockitoException() {
         verify(mock);
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
new file mode 100644
index 0000000..2dce3e0
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.strictness;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoSession;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertNull;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.withSettings;
+
+//TODO 792 also move other Strictness tests to this package (unless they already have good package)
+public class StrictnessPerMockTest {
+
+    MockitoSession mockito;
+    @Mock IMethods strictStubsMock;
+    IMethods lenientMock;
+
+    @Before
+    public void before() {
+        mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+        assertNull(lenientMock);
+        lenientMock = mock(IMethods.class, withSettings().lenient());
+    }
+
+    @Test
+    public void knows_if_mock_is_lenient() {
+        assertTrue(mockingDetails(lenientMock).getMockCreationSettings().isLenient());
+        assertFalse(mockingDetails(strictStubsMock).getMockCreationSettings().isLenient());
+    }
+
+    @Test
+    public void potential_stubbing_problem() {
+        //when
+        given(lenientMock.simpleMethod(100)).willReturn("100");
+        given(strictStubsMock.simpleMethod(100)).willReturn("100");
+
+        //then on lenient mock (created by hand), we can call the stubbed method with different arg:
+        lenientMock.simpleMethod(200);
+
+        //and on strict stub mock (created by session), we cannot call stubbed method with different arg:
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                strictStubsMock.simpleMethod(200);
+            }
+        }).isInstanceOf(PotentialStubbingProblem.class);
+    }
+
+    @Test
+    public void unnecessary_stubbing() {
+        //when
+        given(lenientMock.simpleMethod(100)).willReturn("100");
+        given(strictStubsMock.simpleMethod(100)).willReturn("100");
+
+        //then unnecessary stubbing flags method only on the strict stub mock:
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mockito.finishMocking();
+            }
+        }).isInstanceOf(UnnecessaryStubbingException.class)
+            .hasMessageContaining("1. -> ")
+            //good enough to prove that we're flagging just one unnecessary stubbing:
+            //TODO 792: let's make UnnecessaryStubbingException exception contain the Invocation instance
+            //so that we can write clean assertion rather than depending on string
+            .isNot(TestBase.hasMessageContaining("2. ->"));
+    }
+
+    @Test
+    public void verify_no_more_invocations() {
+        //when
+        given(lenientMock.simpleMethod(100)).willReturn("100");
+        given(strictStubsMock.simpleMethod(100)).willReturn("100");
+
+        //and:
+        strictStubsMock.simpleMethod(100);
+        lenientMock.simpleMethod(100);
+
+        //then 'verifyNoMoreInteractions' ignores strict stub (implicitly verified) but flags the lenient mock
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                verifyNoMoreInteractions(strictStubsMock, lenientMock);
+            }
+        }).isInstanceOf(NoInteractionsWanted.class)
+            .hasMessageContaining("But found this interaction on mock 'iMethods'")
+            //TODO 792: let's make NoInteractionsWanted exception contain the Invocation instances
+            //so that we can write clean assertion rather than depending on string
+            .hasMessageContaining("Actually, above is the only interaction with this mock");
+    }
+
+    @After
+    public void after() {
+        mockito.finishMocking();
+    }
+}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
new file mode 100644
index 0000000..3838bee
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.strictness;
+
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.AdditionalAnswers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoSession;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+public class StrictnessPerStubbingTest {
+
+    MockitoSession mockito;
+    @Mock IMethods mock;
+
+    @Before
+    public void before() {
+        mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+    }
+
+    @Test
+    public void potential_stubbing_problem() {
+        //when
+        when(mock.simpleMethod("1")).thenReturn("1");
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+
+        //then on lenient stubbing, we can call it with different argument:
+        mock.differentMethod("200");
+
+        //but on strict stubbing, we cannot:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mock.simpleMethod("100");
+            }
+        }).isInstanceOf(PotentialStubbingProblem.class);
+    }
+
+    @Test
+    public void doReturn_syntax() {
+        //when
+        lenient().doReturn("2").doReturn("3")
+            .when(mock).simpleMethod(1);
+
+        //then on lenient stubbing, we can call it with different argument:
+        mock.simpleMethod(200);
+
+        //and stubbing works, too:
+        assertEquals("2", mock.simpleMethod(1));
+        assertEquals("3", mock.simpleMethod(1));
+    }
+
+    @Test
+    public void doReturn_varargs_syntax() {
+        //when
+        lenient().doReturn("2", "3")
+            .when(mock).simpleMethod(1);
+
+        //then on lenient stubbing, we can call it with different argument with no exception:
+        mock.simpleMethod(200);
+
+        //and stubbing works, too:
+        assertEquals("2", mock.simpleMethod(1));
+        assertEquals("3", mock.simpleMethod(1));
+    }
+
+    @Test
+    public void doThrow_syntax() {
+        //when
+        lenient()
+            .doThrow(IllegalArgumentException.class)
+            .doThrow(IllegalStateException.class)
+            .when(mock).simpleMethod(1);
+
+        //then on lenient stubbing, we can call it with different argument with no exception:
+        mock.simpleMethod(200);
+
+        //and stubbing works, too:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() throws Throwable {
+                mock.simpleMethod(1);
+            }
+        }).isInstanceOf(IllegalArgumentException.class);
+
+        //testing consecutive call:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() throws Throwable {
+                mock.simpleMethod(1);
+            }
+        }).isInstanceOf(IllegalStateException.class);
+    }
+
+    @Test
+    public void doThrow_vararg_syntax() {
+        //when
+        lenient()
+            .doThrow(IllegalArgumentException.class, IllegalStateException.class)
+            .when(mock).simpleMethod(1);
+
+        //then on lenient stubbing, we can call it with different argument with no exception:
+        mock.simpleMethod(200);
+
+        //and stubbing works, too:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() throws Throwable {
+                mock.simpleMethod(1);
+            }
+        }).isInstanceOf(IllegalArgumentException.class);
+
+        //testing consecutive call:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() throws Throwable {
+                mock.simpleMethod(1);
+            }
+        }).isInstanceOf(IllegalStateException.class);
+    }
+
+    @Test
+    public void doThrow_instance_vararg_syntax() {
+        //when
+        lenient()
+            .doThrow(new IllegalArgumentException(), new IllegalStateException())
+            .when(mock).simpleMethod(1);
+
+        //then on lenient stubbing, we can call it with different argument with no exception:
+        mock.simpleMethod(200);
+
+        //and stubbing works, too:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() throws Throwable {
+                mock.simpleMethod(1);
+            }
+        }).isInstanceOf(IllegalArgumentException.class);
+
+        //testing consecutive call:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() throws Throwable {
+                mock.simpleMethod(1);
+            }
+        }).isInstanceOf(IllegalStateException.class);
+    }
+
+    static class Counter {
+        int increment(int x) {
+            return x + 1;
+        }
+        void scream(String message) {
+            throw new RuntimeException(message);
+        }
+    }
+
+    @Test
+    public void doCallRealMethod_syntax() {
+        //when
+        Counter mock = mock(Counter.class);
+        lenient().doCallRealMethod().when(mock).increment(1);
+
+        //then no exception and default return value if we call it with different arg:
+        assertEquals(0, mock.increment(0));
+
+        //and real method is called when using correct arg:
+        assertEquals(2, mock.increment(1));
+    }
+
+    @Test
+    public void doNothing_syntax() {
+        //when
+        final Counter spy = spy(Counter.class);
+        lenient().doNothing().when(spy).scream("1");
+
+        //then no stubbing exception and real method is called if we call stubbed method with different arg:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                spy.scream("2");
+            }
+        }).hasMessage("2");
+
+        //and we do nothing when stubbing called with correct arg:
+        spy.scream("1");
+    }
+
+    @Test
+    public void doAnswer_syntax() {
+        //when
+        lenient().doAnswer(AdditionalAnswers.returnsFirstArg()).when(mock).simpleMethod("1");
+
+        //then on lenient stubbing, we can call it with different argument:
+        mock.simpleMethod("200");
+
+        //and stubbing works, too:
+        assertEquals("1", mock.simpleMethod("1"));
+    }
+
+    @Test
+    public void unnecessary_stubbing() {
+        //when
+        when(mock.simpleMethod("1")).thenReturn("1");
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+
+        //then unnecessary stubbing flags method only on the strict stubbing:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mockito.finishMocking();
+            }
+        }).isInstanceOf(UnnecessaryStubbingException.class)
+            .hasMessageContaining("1. -> ")
+            //good enough to prove that we're flagging just one unnecessary stubbing:
+            //TODO 792: this assertion is duplicated with StrictnessPerMockTest
+            .isNot(TestBase.hasMessageContaining("2. ->"));
+    }
+
+    @Test
+    public void unnecessary_stubbing_with_doReturn() {
+        //when
+        lenient().doReturn("2").when(mock).differentMethod("2");
+
+        //then no exception is thrown:
+        mockito.finishMocking();
+    }
+
+    @Test
+    public void verify_no_more_invocations() {
+        //when
+        when(mock.simpleMethod("1")).thenReturn("1");
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+
+        //and:
+        mock.simpleMethod("1");
+        mock.differentMethod("200"); // <- different arg
+
+        //then 'verifyNoMoreInteractions' flags the lenient stubbing (called with different arg)
+        //and reports it with [?] in the exception message
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                verifyNoMoreInteractions(mock);
+            }
+        }).isInstanceOf(NoInteractionsWanted.class)
+            .hasMessageContaining("1. ->")
+            .hasMessageContaining("2. [?]->");
+            //TODO 792: assertion duplicated with StrictnessPerMockTest
+            // and we should use assertions based on content of the exception rather than the string
+    }
+
+    @After
+    public void after() {
+        mockito.finishMocking();
+    }
+}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
new file mode 100644
index 0000000..e42d340
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.strictness;
+
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
+public class StrictnessPerStubbingWithRunnerTest {
+
+    @Mock IMethods mock;
+
+    @Test
+    public void potential_stubbing_problem() {
+        //when
+        when(mock.simpleMethod("1")).thenReturn("1");
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+
+        //then on lenient stubbing, we can call it with different argument:
+        mock.differentMethod("200");
+
+        //but on strict stubbing, we cannot:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mock.simpleMethod("100");
+            }
+        }).isInstanceOf(PotentialStubbingProblem.class);
+
+        //let's use the strict stubbing so that it is not reported as failure by the runner:
+        mock.simpleMethod("1");
+    }
+
+    @Test
+    public void unnecessary_stubbing() {
+        //this unnecessary stubbing is not flagged by the runner:
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+    }
+}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java b/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
new file mode 100644
index 0000000..592cca9
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.strictness;
+
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+public class StrictnessWhenRuleStrictnessIsUpdatedTest {
+
+    @Mock IMethods mock;
+    @Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.LENIENT);
+
+    @Test
+    public void strictness_per_mock() {
+        //when
+        rule.strictness(Strictness.STRICT_STUBS);
+
+        //then previous mock is strict:
+        when(mock.simpleMethod(1)).thenReturn("1");
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mock.simpleMethod(2);
+            }
+        }).isInstanceOf(PotentialStubbingProblem.class);
+
+        //but the new mock is lenient, even though the rule is not:
+        final IMethods lenientMock = mock(IMethods.class, withSettings().lenient());
+        when(lenientMock.simpleMethod(1)).thenReturn("1");
+        lenientMock.simpleMethod(100);
+    }
+
+    @Test
+    public void strictness_per_stubbing() {
+        //when
+        rule.strictness(Strictness.STRICT_STUBS);
+
+        //then previous mock is strict:
+        when(mock.simpleMethod(1)).thenReturn("1");
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mock.simpleMethod(2);
+            }
+        }).isInstanceOf(PotentialStubbingProblem.class);
+
+        //but the new mock is lenient, even though the rule is not:
+        lenient().when(mock.simpleMethod(1)).thenReturn("1");
+        mock.simpleMethod(100);
+    }
+}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java b/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
new file mode 100644
index 0000000..3a323fb
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.strictness;
+
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+public class StrictnessWithRulesTest {
+
+    @Mock IMethods mock;
+    @Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+    @Test
+    public void potential_stubbing_problem() {
+        //when
+        when(mock.simpleMethod("1")).thenReturn("1");
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+
+        //then on lenient stubbing, we can call it with different argument:
+        mock.differentMethod("200");
+
+        //but on strict stubbing, we cannot:
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() throws Throwable {
+                mock.simpleMethod("100");
+            }
+        }).isInstanceOf(PotentialStubbingProblem.class);
+
+        //let's use the strict stubbing so that it is not reported as failure by the rule:
+        mock.simpleMethod("1");
+    }
+
+    @Test
+    public void unnecessary_stubbing() {
+        //this unnecessary stubbing is not flagged by the rule:
+        lenient().when(mock.differentMethod("2")).thenReturn("2");
+    }
+}
diff --git a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java b/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
index 4dd9d8f..c63cb6d 100644
--- a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
+++ b/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
@@ -93,6 +93,7 @@
         }
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void should_allow_mocking_when_to_string_is_final() throws Exception {
         mock(Foo.class);
@@ -114,4 +115,15 @@
             fail();
         } catch (CannotVerifyStubOnlyMock e) {}
     }
+
+    @SuppressWarnings("MockitoUsage")
+    @Test
+    public void test_stub_only_not_verifiable_fail_fast() {
+        IMethods localMock = mock(IMethods.class, withSettings().stubOnly());
+
+        try {
+            verify(localMock); // throws exception before method invocation
+            fail();
+        } catch (CannotVerifyStubOnlyMock e) {}
+    }
 }
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
index f8fa2b5..47c2172 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
@@ -42,6 +42,34 @@
     }
 
     @Test
+    public void should_return_consecutive_values_first_var_arg_null() throws Exception {
+        when(mock.simpleMethod()).thenReturn("one", (String) null);
+
+        assertEquals("one", mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+    }
+
+    @Test
+    public void should_return_consecutive_values_var_arg_null() throws Exception {
+        when(mock.simpleMethod()).thenReturn("one", (String[]) null);
+
+        assertEquals("one", mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+    }
+
+    @Test
+    public void should_return_consecutive_values_var_args_contain_null() throws Exception {
+        when(mock.simpleMethod()).thenReturn("one", "two", null);
+
+        assertEquals("one", mock.simpleMethod());
+        assertEquals("two", mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+    }
+
+    @Test
     public void should_return_consecutive_values_set_by_shorten_then_return_method() throws Exception {
         when(mock.simpleMethod()).thenReturn("one", "two", "three");
 
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
index 754b7dc..6bf2041 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
@@ -96,6 +96,7 @@
                 filterLineNo(logger.getLoggedInfo()));
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test(expected = MockitoException.class) public void unfinished_verification_without_throwable() throws Throwable {
         //when
         verify(mock);
@@ -103,6 +104,7 @@
         mockito.finishMocking();
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test public void unfinished_verification_with_throwable() throws Throwable {
         //when
         verify(mock);
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
index 885e78e..24c4854 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
@@ -111,7 +111,7 @@
         List<String> mock = mock(List.class, delegatesTo(new FakeList<String>()));
 
         mock.set(1, "1");
-        assertThat(mock.get(1).equals("1"));
+        assertThat(mock.get(1).equals("1")).isTrue();
     }
 
     @Test
@@ -119,7 +119,7 @@
         List<String> mock = mock(List.class, delegatesTo(new FakeList<String>()));
 
         List<String> subList = mock.subList(0, 0);
-        assertThat(subList.isEmpty());
+        assertThat(subList.isEmpty()).isTrue();
     }
 
     @Test
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
index 9f526bf..9353724 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
@@ -22,6 +22,9 @@
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.Map;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -49,13 +52,54 @@
     }
 
     @Test
+    public void throws_same_exception_consecutively() {
+        when(mock.add("")).thenThrow(new ExceptionOne());
+
+        //1st invocation
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                mock.add("");
+            }
+        }).isInstanceOf(ExceptionOne.class);
+
+        mock.add("1");
+
+        //2nd invocation
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                mock.add("");
+            }
+        }).isInstanceOf(ExceptionOne.class);
+    }
+
+    @Test
+    public void throws_same_exception_consecutively_with_doThrow() {
+        doThrow(new ExceptionOne()).when(mock).clear();
+
+        //1st invocation
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                mock.clear();
+            }
+        }).isInstanceOf(ExceptionOne.class);
+
+        mock.add("1");
+
+        //2nd invocation
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                mock.clear();
+            }
+        }).isInstanceOf(ExceptionOne.class);
+    }
+
+    @Test
     public void shouldStubWithThrowable() throws Exception {
         IllegalArgumentException expected = new IllegalArgumentException("thrown by mock");
         when(mock.add("throw")).thenThrow(expected);
 
         exception.expect(sameInstance(expected));
         mock.add("throw");
-
     }
 
     @Test
diff --git a/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java b/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
index 04cb32a..2756ef8 100644
--- a/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
@@ -8,17 +8,21 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoAssertionError;
 import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.MoreThanAllowedActualInvocations;
 import org.mockito.exceptions.verification.NoInteractionsWanted;
 import org.mockitoutil.TestBase;
 
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.atMost;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class AtMostXVerificationTest extends TestBase {
 
@@ -35,7 +39,7 @@
         try {
             verify(mock, atMost(1)).clear();
             fail();
-        } catch (MockitoAssertionError e) {}
+        } catch (MoreThanAllowedActualInvocations e) {}
     }
 
     @Test
@@ -46,7 +50,7 @@
         try {
             verify(mock, atMost(0)).add(anyString());
             fail();
-        } catch (MockitoAssertionError e) {}
+        } catch (MoreThanAllowedActualInvocations e) {}
     }
 
     @Test
@@ -67,7 +71,7 @@
         try {
             verify(mock, atMost(1)).clear();
             fail();
-        } catch (MockitoAssertionError e) {
+        } catch (MoreThanAllowedActualInvocations e) {
             assertEquals("\nWanted at most 1 time but was 2", e.getMessage());
         }
     }
diff --git a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
index ccf3570..b0e3179 100644
--- a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
+++ b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
@@ -264,7 +264,7 @@
         verifyZeroInteractions(mockOne);
     }
 
-    @SuppressWarnings("all")
+    @SuppressWarnings({"all", "CheckReturnValue", "MockitoUsage"})
     @Test(expected = MockitoException.class)
     public void shouldScreamWhenNullPassed() {
         inOrder((Object[])null);
diff --git a/src/test/java/org/mockitousage/verification/BasicVerificationTest.java b/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
index aa350cf..d9a74ff 100644
--- a/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
@@ -5,16 +5,19 @@
 
 package org.mockitousage.verification;
 
+import org.assertj.core.api.ThrowableAssert;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.exceptions.verification.NoInteractionsWanted;
 import org.mockito.exceptions.verification.TooManyActualInvocations;
 import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.*;
 
@@ -45,10 +48,13 @@
         mock.add("foo");
 
         verify(mock).clear();
-        try {
-            verify(mock).add("bar");
-            fail();
-        } catch (AssertionError expected) {}
+
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock).add("bar");
+            }
+        }).isInstanceOf(ArgumentsAreDifferent.class);
     }
 
     @Test
diff --git a/src/test/java/org/mockitousage/verification/DelayedExecution.java b/src/test/java/org/mockitousage/verification/DelayedExecution.java
deleted file mode 100644
index a34b546..0000000
--- a/src/test/java/org/mockitousage/verification/DelayedExecution.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static java.lang.System.currentTimeMillis;
-import static java.lang.Thread.MAX_PRIORITY;
-import static java.util.concurrent.Executors.newScheduledThreadPool;
-import static java.util.concurrent.TimeUnit.SECONDS;
-import static java.util.concurrent.locks.LockSupport.parkUntil;
-
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-
-class DelayedExecution {
-    private static final int CORE_POOL_SIZE = 3;
-    /**
-     * Defines the number of milliseconds we expecting a Thread might need to unpark, we use this to avoid "oversleeping" while awaiting the deadline for
-     */
-    private static final long MAX_EXPECTED_OVERSLEEP_MILLIS = 50;
-
-    private final ScheduledExecutorService executor;
-
-    public DelayedExecution() {
-        this.executor = newScheduledThreadPool(CORE_POOL_SIZE, maxPrioThreadFactory());
-    }
-
-    public void callAsync(long delay, TimeUnit timeUnit, Runnable r) {
-        long deadline = timeUnit.toMillis(delay) + currentTimeMillis();
-
-        executor.submit(delayedExecution(r, deadline));
-    }
-
-    public void close() throws InterruptedException {
-        executor.shutdownNow();
-
-        if (!executor.awaitTermination(5, SECONDS)) {
-            throw new IllegalStateException("This delayed execution did not terminated after 5 seconds");
-        }
-    }
-
-    private static Runnable delayedExecution(final Runnable r, final long deadline) {
-        return new Runnable() {
-            @Override
-            public void run() {
-                //we park the current Thread till 50ms before we want to execute the runnable
-                parkUntil(deadline - MAX_EXPECTED_OVERSLEEP_MILLIS);
-                //now we closing to the deadline by burning CPU-time in a loop
-                burnRemaining(deadline);
-
-                System.out.println("[DelayedExecution] exec delay = "+(currentTimeMillis() - deadline)+"ms");
-
-                r.run();
-            }
-
-            /**
-             * Loop in tight cycles until we reach the dead line. We do this cause sleep or park is very not precise,
-             * this can causes a Thread to under- or oversleep, sometimes by +50ms.
-             */
-            private void burnRemaining(final long deadline) {
-                long remaining;
-                do {
-                    remaining = deadline - currentTimeMillis();
-                } while (remaining > 0);
-            }
-        };
-    }
-
-    private static ThreadFactory maxPrioThreadFactory() {
-        return new ThreadFactory() {
-            @Override
-            public Thread newThread(Runnable r) {
-                Thread t = new Thread(r);
-                t.setDaemon(true);  // allows the JVM to exit when clients forget to call DelayedExecution.close()
-                t.setPriority(MAX_PRIORITY);
-                return t;
-            }
-        };
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
index 4e5f464..8e1bf06 100644
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
+++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
@@ -155,7 +155,7 @@
 
             String expectedCause =
                 "\n" +
-                "But was 2 times. Undesired invocation:" +
+                "But was 2 times:" +
                 "\n" +
                 "-> at";
             assertThat(e).hasMessageContaining(expectedCause);
diff --git a/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java b/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
index 0dffbfa..271d95c 100644
--- a/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
+++ b/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
@@ -107,6 +107,7 @@
         } catch(VerificationInOrderFailure e) {}
     }
 
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldValidateState() throws Exception {
         //when
diff --git a/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java b/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java
deleted file mode 100644
index f0e42ee..0000000
--- a/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-package org.mockitousage.verification;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.junit.MockitoRule;
-import org.mockitousage.IMethods;
-import org.mockitoutil.RetryRule;
-import org.mockitoutil.Stopwatch;
-
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static org.junit.Assert.assertEquals;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.junit.rules.ExpectedException.none;
-import static org.mockito.Mockito.after;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.junit.MockitoJUnit.rule;
-import static org.mockitoutil.Stopwatch.createNotStarted;
-
-public class VerificationAfterDelayTest {
-
-    @Rule
-    public MockitoRule mockito = rule();
-
-    @Rule
-    public RetryRule retryRule = RetryRule.attempts(4);
-
-    @Rule
-    public ExpectedException exception = none();
-
-    @Mock
-    private IMethods mock;
-
-    @Captor
-    private ArgumentCaptor<Character> captor;
-
-    private Stopwatch stopWatch;
-
-    private DelayedExecution delayedExecution;
-
-    private Runnable callMock = new Runnable() {
-        @Override
-        public void run() {
-            mock.oneArg('1');
-        }
-    };
-
-    @Before
-    public void setUp() {
-        delayedExecution = new DelayedExecution();
-        stopWatch = createNotStarted();
-    }
-
-    @After
-    public void tearDown() throws InterruptedException {
-        delayedExecution.close();
-    }
-
-    @Test
-    public void shouldVerifyNormallyWithSpecificTimes() throws Exception {
-        // given
-        delayedExecution.callAsync(30, MILLISECONDS, callMock );
-
-        // then
-        verify(mock, after(100).times(1)).oneArg('1');
-    }
-
-    @Test
-    public void shouldVerifyNormallyWithAtLeast() throws Exception {
-        // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock );
-
-        // then
-        verify(mock, after(100).atLeast(1)).oneArg('1');
-    }
-
-    @Test
-    public void shouldFailVerificationWithWrongTimes() throws Exception {
-        // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock );
-
-        // then
-        verify(mock, times(0)).oneArg('1');
-        exception.expect(MockitoAssertionError.class);
-        verify(mock, after(100).times(2)).oneArg('1');
-    }
-
-    @Test
-    public void shouldWaitTheFullTimeIfTheTestCouldPass() throws Exception {
-        // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock );
-
-        // then
-        stopWatch.start();
-
-        try {
-            verify(mock, after(100).atLeast(2)).oneArg('1');
-            fail("Expected behavior was to throw an exception, and never reach this line");
-        } catch (MockitoAssertionError ignored) {
-        }
-
-        stopWatch.assertElapsedTimeIsMoreThan(100, MILLISECONDS);
-    }
-
-    @Test
-    public void shouldStopEarlyIfTestIsDefinitelyFailed() throws Exception {
-        // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock );
-
-        // then
-        exception.expect(MockitoAssertionError.class);
-        verify(mock, after(10000).never()).oneArg('1');
-    }
-
-    /**
-     * Test for issue #345.
-     */
-    @Test
-    public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtMostVerification() {
-        // given
-        int n = 3;
-
-        // when
-        exerciseMockNTimes(n);
-
-        stopWatch.start();
-        // then
-        verify(mock, after(200).atMost(n)).oneArg((char) captor.capture());
-
-        stopWatch.assertElapsedTimeIsMoreThan(200, MILLISECONDS);
-        assertThat(captor.getAllValues()).containsExactly('0', '1', '2');
-    }
-
-    @Test
-    public void shouldReturnListOfArgumentsWithSameSizeAsGivenInTimesVerification() {
-        // given
-        int n = 3;
-
-        // when
-        exerciseMockNTimes(n);
-
-        //Then
-        verify(mock, after(200).times(n)).oneArg((char) captor.capture());
-        assertEquals(n, captor.getAllValues().size());
-        assertEquals('0', (char) captor.getAllValues().get(0));
-        assertEquals('1', (char) captor.getAllValues().get(1));
-        assertEquals('2', (char) captor.getAllValues().get(2));
-    }
-
-    @Test
-    public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtLeastVerification() {
-        // given
-        int n = 3;
-
-        // when
-        exerciseMockNTimes(n);
-
-        //Then
-        verify(mock, after(200).atLeast(n)).oneArg((char) captor.capture());
-        assertEquals(n, captor.getAllValues().size());
-        assertEquals('0', (char) captor.getAllValues().get(0));
-        assertEquals('1', (char) captor.getAllValues().get(1));
-        assertEquals('2', (char) captor.getAllValues().get(2));
-    }
-
-    private void exerciseMockNTimes(int n) {
-        for (int i = 0; i < n; i++) {
-            mock.oneArg((char) ('0' + i));
-        }
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java b/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
new file mode 100644
index 0000000..1f11319
--- /dev/null
+++ b/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.verification;
+
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoRule;
+import org.mockitousage.IMethods;
+import org.mockitoutil.Stopwatch;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.after;
+import static org.mockito.Mockito.verify;
+import static org.mockito.junit.MockitoJUnit.rule;
+import static org.mockitoutil.Stopwatch.createNotStarted;
+
+public class VerificationWithAfterAndCaptorTest {
+
+    @Rule public MockitoRule mockito = rule();
+
+    @Mock private IMethods mock;
+
+    @Captor private ArgumentCaptor<Character> captor;
+
+    private Stopwatch watch = createNotStarted();
+
+    /**
+     * Test for issue #345.
+     */
+    @Test
+    public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtMostVerification() {
+        // given
+        int n = 3;
+
+        // when
+        exerciseMockNTimes(n);
+
+        watch.start();
+
+        // then
+        verify(mock, after(200).atMost(n)).oneArg((char) captor.capture());
+
+        watch.assertElapsedTimeIsMoreThan(200, MILLISECONDS);
+        assertThat(captor.getAllValues()).containsExactly('0', '1', '2');
+    }
+
+    @Test
+    @Ignore("TODO review after #936")
+    public void shouldReturnListOfArgumentsWithSameSizeAsGivenInTimesVerification() {
+        // given
+        int n = 3;
+
+        // when
+        exerciseMockNTimes(n);
+
+        //Then
+        verify(mock, after(200).times(n)).oneArg((char) captor.capture());
+        assertEquals(n, captor.getAllValues().size());
+        assertEquals('0', (char) captor.getAllValues().get(0));
+        assertEquals('1', (char) captor.getAllValues().get(1));
+        assertEquals('2', (char) captor.getAllValues().get(2));
+    }
+
+    @Test
+    @Ignore("TODO review after #936")
+    public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtLeastVerification() {
+        // given
+        int n = 3;
+
+        // when
+        exerciseMockNTimes(n);
+
+        //Then
+        verify(mock, after(200).atLeast(n)).oneArg((char) captor.capture());
+        assertEquals(n, captor.getAllValues().size());
+        assertEquals('0', (char) captor.getAllValues().get(0));
+        assertEquals('1', (char) captor.getAllValues().get(1));
+        assertEquals('2', (char) captor.getAllValues().get(2));
+    }
+
+    private void exerciseMockNTimes(int n) {
+        for (int i = 0; i < n; i++) {
+            mock.oneArg((char) ('0' + i));
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java b/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java
new file mode 100644
index 0000000..f437c03
--- /dev/null
+++ b/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockitousage.verification;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.After;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.MoreThanAllowedActualInvocations;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.TooManyActualInvocations;
+import org.mockito.junit.MockitoRule;
+import org.mockitousage.IMethods;
+import org.mockitoutil.Stopwatch;
+import org.mockitoutil.async.AsyncTesting;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.after;
+import static org.mockito.Mockito.verify;
+import static org.mockito.junit.MockitoJUnit.rule;
+import static org.mockitoutil.Stopwatch.createNotStarted;
+
+public class VerificationWithAfterTest {
+
+    @Rule public MockitoRule mockito = rule();
+
+    @Mock private IMethods mock;
+
+    private Runnable callMock = new Runnable() {
+        public void run() {
+            mock.oneArg('1');
+        }
+    };
+
+    private AsyncTesting async = new AsyncTesting();
+    private Stopwatch watch = createNotStarted();
+
+    @After public void tearDown() {
+        async.cleanUp();
+    }
+
+    @Test
+    public void should_verify_with_after() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(1000, callMock);
+
+        // then
+        verify(mock, after(300)).oneArg('1');
+    }
+
+    @Test
+    public void should_verify_with_after_and_fail() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(40, callMock);
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(300)).oneArg('1');
+            }
+        }).isInstanceOf(TooManyActualInvocations.class);
+    }
+
+    @Test
+    public void should_verify_with_time_x() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(50, callMock);
+        async.runAfter(600, callMock);
+
+        // then
+        verify(mock, after(300).times(2)).oneArg('1');
+    }
+
+    @Test
+    public void should_verify_with_time_x_and_fail() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(40, callMock);
+        async.runAfter(80, callMock);
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(300).times(2)).oneArg('1');
+            }
+        }).isInstanceOf(TooManyActualInvocations.class);
+    }
+
+    @Test
+    public void should_verify_with_at_least() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(50, callMock);
+
+        // then
+        verify(mock, after(300).atLeastOnce()).oneArg('1');
+    }
+
+    @Test
+    public void should_verify_with_at_least_and_fail() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(50, callMock);
+        async.runAfter(600, callMock);
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(300).atLeast(3)).oneArg('1');
+            }
+        }).isInstanceOf(AssertionError.class).hasMessageContaining("Wanted *at least* 3 times"); //TODO specific exception
+    }
+
+    @Test
+    public void should_verify_with_at_most() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(50, callMock);
+        async.runAfter(600, callMock);
+
+        // then
+        verify(mock, after(300).atMost(2)).oneArg('1');
+    }
+
+    @Test
+    public void should_verify_with_at_most_and_fail() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(50, callMock);
+        async.runAfter(600, callMock);
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(300).atMost(1)).oneArg('1');
+            }
+        }).isInstanceOf(AssertionError.class).hasMessageContaining("Wanted at most 1 time but was 2"); //TODO specific exception
+    }
+
+    @Test
+    public void should_verify_with_never() {
+        // given
+        async.runAfter(500, callMock);
+
+        // then
+        verify(mock, after(50).never()).oneArg('1');
+    }
+
+    @Test
+    public void should_verify_with_never_and_fail() {
+        // given
+        async.runAfter(10, callMock);
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(300).never()).oneArg('1');
+            }
+        }).isInstanceOf(MoreThanAllowedActualInvocations.class).hasMessageContaining("Wanted at most 0 times but was 1");
+    }
+
+    @Test
+    public void should_verify_with_only() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(600, callMock);
+
+        // then
+        verify(mock, after(300).only()).oneArg('1');
+    }
+
+    @Test
+    public void should_verify_with_only_and_fail() {
+        // given
+        async.runAfter(10, callMock);
+        async.runAfter(50, callMock);
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(300).only()).oneArg('1');
+            }
+        }).isInstanceOf(AssertionError.class).hasMessageContaining("No interactions wanted here"); //TODO specific exception
+    }
+
+    @Test
+    public void should_fail_early_when_at_most_is_used() {
+        watch.start();
+
+        // when
+        async.runAfter(50, callMock);
+        async.runAfter(100, callMock);
+
+        // then
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                verify(mock, after(10000).atMost(1)).oneArg('1');
+            }
+        }).isInstanceOf(MoreThanAllowedActualInvocations.class);
+
+        // using generous number to avoid timing issues
+        watch.assertElapsedTimeIsLessThan(2000, MILLISECONDS);
+    }
+
+    @Test
+    public void should_fail_early_when_never_is_used() {
+        watch.start();
+
+        // when
+        async.runAfter(50, callMock);
+
+        // then
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                verify(mock, after(10000).never()).oneArg('1');
+            }
+        }).isInstanceOf(MoreThanAllowedActualInvocations.class);
+
+        // using generous number to avoid timing issues
+        watch.assertElapsedTimeIsLessThan(2000, MILLISECONDS);
+    }
+
+    @Test
+    @Ignore //TODO nice to have
+    public void should_fail_early_when_only_is_used() {
+        watch.start();
+
+        // when
+        async.runAfter(50, callMock);
+        async.runAfter(100, callMock);
+
+        // then
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                verify(mock, after(10000).only()).oneArg('1');
+            }
+        }).isInstanceOf(NoInteractionsWanted.class);
+
+        // using generous number to avoid timing issues
+        watch.assertElapsedTimeIsLessThan(2000, MILLISECONDS);
+    }
+
+    @Test
+    @Ignore //TODO nice to have
+    public void should_fail_early_when_time_x_is_used() {
+        watch.start();
+
+        // when
+        async.runAfter(50, callMock);
+        async.runAfter(100, callMock);
+
+        // then
+        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                verify(mock, after(10000).times(1)).oneArg('1');
+            }
+        }).isInstanceOf(NoInteractionsWanted.class);
+
+        // using generous number to avoid timing issues
+        watch.assertElapsedTimeIsLessThan(2000, MILLISECONDS);
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java b/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java
index 798e0e8..1a3b345 100644
--- a/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java
+++ b/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java
@@ -5,161 +5,198 @@
 
 package org.mockitousage.verification;
 
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
 import org.mockito.exceptions.verification.TooLittleActualInvocations;
 import org.mockito.junit.MockitoRule;
 import org.mockitousage.IMethods;
-import org.mockitoutil.RetryRule;
+import org.mockitoutil.Stopwatch;
+import org.mockitoutil.async.AsyncTesting;
 
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static org.junit.rules.ExpectedException.none;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.never;
+import java.util.concurrent.TimeUnit;
+
+import static org.mockito.Mockito.after;
 import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.junit.MockitoJUnit.rule;
+import static org.mockitoutil.Stopwatch.createNotStarted;
 
 public class VerificationWithTimeoutTest {
 
-    @Rule
-    public MockitoRule mockito = rule();
+    @Rule public MockitoRule mockito = rule();
 
-    @Rule
-    public RetryRule retryRule = RetryRule.attempts(4);
+    private Stopwatch watch = createNotStarted();
 
-    @Rule
-    public ExpectedException exception = none();
+    @Mock private IMethods mock;
 
-    @Mock
-    private IMethods mock;
-
-    private DelayedExecution delayedExecution;
+    private AsyncTesting async;
 
     @Before
     public void setUp() {
-        delayedExecution = new DelayedExecution();
+        async = new AsyncTesting();
     }
 
     @After
-    public void tearDown() throws InterruptedException {
-        delayedExecution.close();
+    public void tearDown() {
+        async.cleanUp();
     }
 
     @Test
-    public void shouldVerifyWithTimeout() throws Exception {
+    public void should_verify_with_timeout() {
         // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock('c'));
+        async.runAfter(50, callMock('c'));
+        async.runAfter(500, callMock('c'));
 
         // then
-        verify(mock, timeout(100)).oneArg('c');
-        verify(mock, timeout(100).atLeastOnce()).oneArg('c');
-        verify(mock, timeout(100).times(1)).oneArg('c');
-        verify(mock).oneArg('c');
-        verify(mock, times(1)).oneArg('c');
+        verify(mock, timeout(200).only()).oneArg('c');
+        verify(mock).oneArg('c'); //sanity check
     }
 
     @Test
-    public void shouldFailVerificationWithTimeout() throws Exception {
+    public void should_verify_with_timeout_and_fail() {
         // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock('c'));
+        async.runAfter(200, callMock('c'));
 
         // then
-        verify(mock, never()).oneArg('c');
-        exception.expect(MockitoAssertionError.class);
-        verify(mock, timeout(20).atLeastOnce()).oneArg('c');
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, timeout(50).only()).oneArg('c');
+            }
+        }).isInstanceOf(AssertionError.class).hasMessageContaining("Wanted but not invoked");
+        //TODO let's have a specific exception vs. generic assertion error + message
     }
 
     @Test
-    public void shouldAllowMixingOtherModesWithTimeout() throws Exception {
+    @Ignore //TODO nice to have
+    public void should_verify_with_timeout_and_fail_early() {
         // when
-        delayedExecution.callAsync(10, MILLISECONDS, callMock('c'));
-        delayedExecution.callAsync(10, MILLISECONDS, callMock('c'));
+        callMock('c');
+        callMock('c');
+
+        watch.start();
 
         // then
-        verify(mock, timeout(100).atLeast(1)).oneArg('c');
-        verify(mock, timeout(100).times(2)).oneArg('c');
-        verifyNoMoreInteractions(mock);
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, timeout(2000)).oneArg('c');
+            }
+        }).isInstanceOf(AssertionError.class).hasMessageContaining("Wanted but not invoked");
+
+        watch.assertElapsedTimeIsLessThan(1000, TimeUnit.MILLISECONDS);
     }
 
     @Test
-    public void shouldAllowMixingOtherModesWithTimeoutAndFail() throws Exception {
+    public void should_verify_with_times_x() {
         // when
-        delayedExecution.callAsync(10, MILLISECONDS, callMock('c'));
-        delayedExecution.callAsync(10, MILLISECONDS, callMock('c'));
+        async.runAfter(50, callMock('c'));
+        async.runAfter(100, callMock('c'));
+        async.runAfter(600, callMock('c'));
 
         // then
-        verify(mock, timeout(100).atLeast(1)).oneArg('c');
-        exception.expect(TooLittleActualInvocations.class);
-        verify(mock, timeout(100).times(3)).oneArg('c');
+        verify(mock, timeout(300).times(2)).oneArg('c');
     }
 
     @Test
-    public void shouldAllowMixingOnlyWithTimeout() throws Exception {
+    public void should_verify_with_times_x_and_fail() {
         // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock('c'));
+        async.runAfter(10, callMock('c'));
+        async.runAfter(200, callMock('c'));
 
         // then
-        verify(mock, never()).oneArg('c');
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, timeout(100).times(2)).oneArg('c');
+            }
+        }).isInstanceOf(TooLittleActualInvocations.class);
+    }
+
+    @Test
+    public void should_verify_with_at_least() {
+        // when
+        async.runAfter(10, callMock('c'));
+        async.runAfter(50, callMock('c'));
+
+        // then
+        verify(mock, timeout(200).atLeast(2)).oneArg('c');
+    }
+
+    @Test
+    public void should_verify_with_at_least_once() {
+        // when
+        async.runAfter(10, callMock('c'));
+        async.runAfter(50, callMock('c'));
+
+        // then
+        verify(mock, timeout(200).atLeastOnce()).oneArg('c');
+    }
+
+    @Test
+    public void should_verify_with_at_least_and_fail() {
+        // when
+        async.runAfter(10, callMock('c'));
+        async.runAfter(50, callMock('c'));
+
+        // then
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            public void call() {
+                verify(mock, timeout(100).atLeast(3)).oneArg('c');
+            }
+        }).isInstanceOf(TooLittleActualInvocations.class);
+    }
+
+    @Test
+    public void should_verify_with_only() {
+        // when
+        async.runAfter(10, callMock('c'));
+        async.runAfter(300, callMock('c'));
+
+        // then
         verify(mock, timeout(100).only()).oneArg('c');
     }
 
     @Test
-    public void shouldAllowMixingOnlyWithTimeoutAndFail() throws Exception {
+    @Ignore("not testable, probably timeout().only() does not make sense")
+    public void should_verify_with_only_and_fail() {
         // when
-        delayedExecution.callAsync(30, MILLISECONDS, callMock('c'));
-
-        // and when
-        mock.oneArg('x');
+        async.runAfter(10, callMock('c'));
+        async.runAfter(50, callMock('c'));
 
         // then
-        verify(mock, never()).oneArg('c');
-        exception.expect(NoInteractionsWanted.class);
-        verify(mock, timeout(100).only()).oneArg('c');
-    }
-
-    /**
-     * This test is JUnit-specific because the code behaves different if JUnit
-     * is used.
-     */
-    @Test
-    public void canIgnoreInvocationsWithJunit() throws InterruptedException {
-        // when
-        delayedExecution.callAsync(10, MILLISECONDS, callMock('1'));
-
-        // then
-        verify(mock, timeout(50)).oneArg('1');
-
-        // when
-        delayedExecution.callAsync(10, MILLISECONDS, callMock('2'));
-        delayedExecution.callAsync(20, MILLISECONDS, callMock('3'));
-
-        // then
-        verify(mock, timeout(50)).oneArg('3');
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, after(200).only()).oneArg('c');
+            }
+        }).isInstanceOf(AssertionError.class);
     }
 
     @Test
-    public void shouldAllowTimeoutVerificationInOrder() throws Exception {
+    @Ignore //TODO nice to have
+    public void should_verify_with_only_and_fail_early() {
         // when
-        delayedExecution.callAsync(50, MILLISECONDS, callMock('1'));
+        callMock('c');
+        callMock('c');
 
-        // and when
-        mock.oneArg('x');
+        watch.start();
 
         // then
-        InOrder inOrder = inOrder(mock);
-        inOrder.verify(mock).oneArg('x');
-        inOrder.verify(mock, never()).oneArg('1');
-        inOrder.verify(mock, timeout(100)).oneArg('1');
+        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
+            @Override
+            public void call() {
+                verify(mock, timeout(2000).only()).oneArg('c');
+            }
+        }).isInstanceOf(AssertionError.class).hasMessageContaining("Wanted but not invoked"); //TODO specific exception
+
+        watch.assertElapsedTimeIsLessThan(1000, TimeUnit.MILLISECONDS);
     }
 
     private Runnable callMock(final char c) {
diff --git a/src/test/java/org/mockitoutil/Stopwatch.java b/src/test/java/org/mockitoutil/Stopwatch.java
index 6cde867..c2140dd 100644
--- a/src/test/java/org/mockitoutil/Stopwatch.java
+++ b/src/test/java/org/mockitoutil/Stopwatch.java
@@ -4,13 +4,14 @@
  */
 package org.mockitoutil;
 
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+import java.util.concurrent.TimeUnit;
+
 import static java.lang.String.format;
 import static java.lang.System.nanoTime;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
-import java.util.concurrent.TimeUnit;
-import org.mockito.exceptions.base.MockitoAssertionError;
-
 /**
  * This class can be uses as stopwatch to assert that a given time is elapsed or not.
  */
@@ -66,4 +67,16 @@
     private static void fail(String message, long expectedNanos, long elapsedNanos) {
         throw new MockitoAssertionError(format(message, NANOSECONDS.toMillis(expectedNanos), NANOSECONDS.toMillis(elapsedNanos)));
     }
+
+    /**
+     * Waits for specific amount of millis using 'Thread.sleep()'.
+     * Rethrows InterruptedException.
+     */
+    public void waitFor(int millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
 }
diff --git a/src/test/java/org/mockitoutil/TestBase.java b/src/test/java/org/mockitoutil/TestBase.java
index ca3d7b8..98066eb 100644
--- a/src/test/java/org/mockitoutil/TestBase.java
+++ b/src/test/java/org/mockitoutil/TestBase.java
@@ -5,6 +5,7 @@
 
 package org.mockitoutil;
 
+import org.assertj.core.api.Condition;
 import org.junit.After;
 import org.junit.Before;
 import org.mockito.MockitoAnnotations;
@@ -31,6 +32,18 @@
  */
 public class TestBase {
 
+    /**
+     * Condition to be used with AssertJ
+     */
+    public static Condition<Throwable> hasMessageContaining(final String substring) {
+        return new Condition<Throwable>() {
+            @Override
+            public boolean matches(Throwable e) {
+                return e.getMessage().contains(substring);
+            }
+        };
+    }
+
     @After
     public void cleanUpConfigInAnyCase() {
         ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
diff --git a/src/test/java/org/mockitoutil/async/AsyncTesting.java b/src/test/java/org/mockitoutil/async/AsyncTesting.java
new file mode 100644
index 0000000..3b11e10
--- /dev/null
+++ b/src/test/java/org/mockitoutil/async/AsyncTesting.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil.async;
+
+import java.util.LinkedList;
+
+/**
+ * Streamlines testing async code for Mockito tests.
+ *
+ * Instances of this class are NOT thread safe (intentionally, they are not required to be thread safe)
+ */
+public class AsyncTesting {
+
+    //Sanity limit of threas. Increase it if justified.
+    private final static int MAX_THREADS = 3;
+
+    private final LinkedList<Exception> problems = new LinkedList<Exception>();
+    private final LinkedList<Thread> threads = new LinkedList<Thread>();
+    private boolean stopping;
+
+    /**
+     * Schedules execution of runnable with some delay.
+     * Starts thread immediately and returns.
+     * The thread will execute the runnable after given delay in millis.
+     *
+     * @param delayMillis - the delay in millis
+     * @param runnable - to be executed in a thread after delay
+     */
+    public void runAfter(final int delayMillis, final Runnable runnable) {
+        if (threads.size() == MAX_THREADS) {
+            throw new RuntimeException("Please don't schedule any more threads. Figure out how to test the code with minimum amount of threads");
+        }
+        Thread t = new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(delayMillis);
+                    runnable.run();
+                } catch (Exception e) {
+                    boolean cleanStop = e instanceof InterruptedException && stopping;
+                    if (!cleanStop) {
+                        problems.add(e);
+                    }
+                }
+            }
+        };
+        System.out.println("[AsyncTesting] Starting thread that will execute the runnable after " + delayMillis + " millis. Threads so far: " + threads.size());
+        threads.add(t);
+        t.start();
+    }
+
+    /**
+     * Interrupts and waits for all threads to complete (using 'join()').
+     * Rethrows exceptions accumulated by the execution of threads.
+     */
+    public void cleanUp() {
+        stopping = true;
+        System.out.println("[AsyncTesting] Interrupting and waiting for " + threads.size() + " threads to complete...");
+        while(!threads.isEmpty()) {
+            Thread t = threads.removeFirst();
+            try {
+                t.interrupt();
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        if (!problems.isEmpty()) {
+            throw new RuntimeException("Caught " + problems.size() + " exception(s). First one is included as cause", problems.getFirst());
+        }
+    }
+}
diff --git a/src/test/java/org/mockitoutil/async/AsyncTestingTest.java b/src/test/java/org/mockitoutil/async/AsyncTestingTest.java
new file mode 100644
index 0000000..4aacfe5
--- /dev/null
+++ b/src/test/java/org/mockitoutil/async/AsyncTestingTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil.async;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockitoutil.Stopwatch;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assert.assertEquals;
+import static org.mockitoutil.Stopwatch.createNotStarted;
+
+public class AsyncTestingTest {
+
+    private AsyncTesting async = new AsyncTesting();
+    private Stopwatch watch = createNotStarted();
+
+    @After
+    public void after() {
+        async.cleanUp();
+    }
+
+    @Test
+    public void sanity_test() {
+        //given
+        watch.start();
+        final AtomicInteger value = new AtomicInteger(0);
+
+        //when
+        async.runAfter(200, new Runnable() {
+            public void run() {
+                value.incrementAndGet();
+            }
+        });
+
+        //then the runnable is truly async and has not ran yet:
+        assertEquals(0, value.get());
+
+        //after some wait...
+        watch.waitFor(300);
+
+        //we actually waited for some time
+        watch.assertElapsedTimeIsMoreThan(200, MILLISECONDS);
+
+        //and the async has actually ran:
+        assertEquals(1, value.get());
+    }
+}
diff --git a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java b/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java
index 600b9bc..5a66ab1 100644
--- a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java
+++ b/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java
@@ -4,18 +4,19 @@
  */
 package org.mockito.android.internal.creation;
 
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.io.File;
 import net.bytebuddy.android.AndroidClassLoadingStrategy;
 import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.creation.bytebuddy.SubclassLoader;
 
+import java.io.File;
+
+import static org.mockito.internal.util.StringUtil.join;
+
 class AndroidLoadingStrategy implements SubclassLoader {
 
     @Override
-    public ClassLoadingStrategy<ClassLoader> getStrategy(Class<?> mockFeatures) {
+    public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
         File target = AndroidTempFileLocator.target;
         if (target == null) {
             throw new MockitoException(join(
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java b/subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java
index 0f2ea78..80c9de8 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java
+++ b/subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java
@@ -9,6 +9,7 @@
 
 public class FinalClassMockingTest {
 
+    @SuppressWarnings("CheckReturnValue")
     @Test
     public void no_exception_while_mocking_final_class() throws Exception {
         Mockito.mock(FinalClass.class);