diff --git a/.dependabot/config.yml b/.dependabot/config.yml
deleted file mode 100644
index 16be16a270..0000000000
--- a/.dependabot/config.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-version: 1
-
-update_configs:
-  - package_manager: "java:gradle"
-    directory: "/"
-    update_schedule: "daily"
-    # Redundant - default repository branch by default
-    target_branch: "release/3.x"
diff --git a/.editorconfig b/.editorconfig
index 925d8821f4..5f7264121b 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -6,9 +6,41 @@ insert_final_newline = true
 trim_trailing_whitespace = true
 indent_style = space
 indent_size = 4
+charset = utf-8
 
 [{*.yml,*.yaml}]
 indent_size = 2
 ij_continuation_indent_size = 2
 ij_yaml_keep_indents_on_empty_lines = false
 ij_yaml_keep_line_breaks = true
+ij_any_block_comment_at_first_column = false
+ij_java_line_comment_at_first_column = false
+ij_java_line_comment_add_space = true
+
+[*.java]
+ij_java_align_multiline_throws_list = true
+ij_java_align_multiline_annotation_parameters = true
+ij_java_annotation_parameter_wrap = off
+ij_java_blank_lines_after_imports = 1
+ij_java_blank_lines_before_imports = 1
+ij_java_class_count_to_use_import_on_demand = 100
+ij_java_names_count_to_use_import_on_demand = 100
+ij_java_imports_layout = static java.**,static javax.**,$*,|,java.**,javax.**,*
+ij_java_insert_inner_class_imports = true
+ij_java_layout_static_imports_separately = true
+ij_java_method_call_chain_wrap = off
+ij_java_throws_list_wrap = off
+ij_java_block_comment_at_first_column = false
+ij_java_line_comment_at_first_column = false
+ij_java_line_comment_add_space = true
+
+[{*.kt,*.kts}]
+ij_kotlin_block_comment_at_first_column = false
+ij_kotlin_line_comment_at_first_column = false
+ij_kotlin_line_comment_add_space = true
+
+[*.gradle]
+ij_groovy_block_comment_at_first_column = false
+ij_groovy_line_comment_at_first_column = false
+ij_groovy_line_comment_add_space = true
+
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 1cdaaa1fac..967177cc4d 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -6,19 +6,15 @@
 
 **If looking for support**
 
-* Search / Ask question on [stackoverflow](http://stackoverflow.com/questions/tagged/mockito)
-* Go to the [mockito mailing-list](http://groups.google.com/group/mockito) (moderated)
-* Issues should always have a [Short, Self Contained, Correct (Compilable), Example](http://sscce.org) (same as any question on stackoverflow.com)
+* Search / Ask a question on [Stack Overflow / Questions tagged [mockito]](https://stackoverflow.com/questions/tagged/mockito)
+* Go to the [mockito mailing-list](https://groups.google.com/group/mockito) (moderated)
+* Issues should always have a [Short, Self Contained, Correct (Compilable), Example](http://sscce.org) (same as any question on [Stack Overflow](https://stackoverflow.com))
 
 # Contributing to Mockito
 
-Which branch : 
-* On mockito 3.x (or 2.x), make your pull request target `release/3.x` (or `release/2.x`)
-* On next mockito version make your pull request target `release/3.x`
-
 ## Pull request criteria
 
-* **At least one commit message** in the PR starts with `Fixes #id : ` where `id` is an [issue tracker](https://github.com/mockito/mockito/issues) id. This allows automated release notes generation. Also GitHub will track the issue and [close it](https://github.com/blog/1386-closing-issues-via-commit-messages) when the PR is merged.
+* **At least one commit message** in the PR ends with `Fixes #id` where `id` is an [issue tracker](https://github.com/mockito/mockito/issues) id. This allows automated release notes generation. Also GitHub will track the issue and [close it](https://github.com/blog/1386-closing-issues-via-commit-messages) when the PR is merged.
 * Use `@since` tags for new public APIs
 * Include tests
 * Document public APIs with examples
@@ -46,19 +42,31 @@ Things we pay attention in a PR :
 * On pull requests, please document the change, what it brings, what is the benefit.
 * **Clean commit history** in the topic branch in your fork of the repository, even during review. That means that commits are _rebased_ and _squashed_ if necessary, so that each commit clearly changes one things and there are no extraneous fix-ups.
 
-  For that matter it's possible to commit [_semantic_ changes](http://lemike-de.tumblr.com/post/79041908218/semantic-commits). _Tests are an asset, so is history_.
+  _Tests are an asset, so is history_.
+
+  _Example gratia_ (based on https://cbea.ms/git-commit/):
+
+  ```
+  Enable feature X to do Y
+
+  Include some background information here.
 
-  _Exemple gratia_:
+  Fixes #73
+  ```
 
   ```
-  Fixes #73 : The new feature
-  Fixes #73 : Refactors this part of Mockito to make feature possible
+  Fix bug B with feature A
+
+  Include some background information here.
+  Add example scenario/context.
+
+  Fixes #73
   ```
 
 * In the code, always test your feature / change, in unit tests and in our `acceptance test suite` located in `org.mockitousage`. Older tests will be migrated when a test is modified.
 * New test methods should follow a snake case convention (`ensure_that_stuff_is_doing_that`), this allows the test name to be fully expressive on intent while still readable.
 * When reporting errors to the users, if it's a user report report it gently and explain how a user should deal with it, see the `Reporter` class. However not all errors should go there, some unlikely technical errors don't need to be in the `Reporter` class.
-* Documentation !!! Always document with love the public API. Internals could use some love too. In all cases the code should _auto-document_ itself like any [well designed API](rebased and squashed if necessary, so that each commit clearly changes one things and there are no extraneous fix-ups).
+* Documentation !!! Always document with love the public API. Internals could use some love too. In all cases the code should _auto-document_ itself like any well-designed API.
 * We use (4) spaces instead of tabs. Make sure line ending is Unix style (LF). More on line ending on the [Github help](https://help.github.com/articles/dealing-with-line-endings/).
 
 
@@ -73,14 +81,14 @@ This section is not about some kind of fruitless tabs vs spaces debate. It's abo
 
 _This includes IntelliJ IDEA instructions, however we are sure there's similar settings in all major IDEs._
 
-But first of all, make sure that : 
+But first of all, make sure that :
 
 * Don't use tabs, only spaces
 * Character encoding is **UTF-8**
 * Line ending character is unix-style **`LF`**
 * New line is added at end of file: `IntelliJ setting > Editor > General > Ensure line feed at file end on save`
 
-For most editors, this should be automatically enforced by [EditorConfig](http://editorconfig.org/).
+For most editors, this should be automatically enforced by [EditorConfig](https://editorconfig.org/).
 Check if your editor has a built-in plugin or if you need to download one.
 IntelliJ has a built-in plugin, for Eclipse you need to download [this plugin](https://github.com/ncjones/editorconfig-eclipse#readme).
 
@@ -100,6 +108,7 @@ Imports must be sorted in the following order
 1. blank line
 1. `import java.*`
 1. `import javax.*`
+1. blank line
 1. `import all other imports`
 
 This order can be set in `IntelliJ setting > Editor > Code Style > Java > Imports > Import Layout`
@@ -108,8 +117,8 @@ Also make sure that
 * One blank lines before imports.
 * One blank lines after imports.
 * Never import with wildcard `*`
-   * Set `IntelliJ setting > Editor > Code Style > Java > Imports > Class count to use import with '*'` to `100`     
-   * Set `IntelliJ setting > Editor > Code Style > Java > Imports > Names count to use import static with '*'` to `100`     
+   * Set `IntelliJ setting > Editor > Code Style > Java > Imports > Class count to use import with '*'` to `100`
+   * Set `IntelliJ setting > Editor > Code Style > Java > Imports > Names count to use import static with '*'` to `100`
 
 ### Alignment
 
@@ -164,7 +173,7 @@ We found vertical alignment helping when reading the code, for that reason we wa
 
     ```java
     @Mock(answer = Answers.RETURNS_DEFAULTS,
-          serializable = true, 
+          serializable = true,
           extraInterfaces = { List.class, YetAnotherInterface.class })
     ```
 
@@ -188,3 +197,7 @@ We found vertical alignment helping when reading the code, for that reason we wa
     1. For parameter `Throws list` choose : `Do not wrap`
     2. For sub-parameter `Align when multiline` tick the checkbox
 
+## Gradle Tips
+
+1. It is possible to run `./gradlew dependencyUpdates` to find out of date dependencies, including tools. Note that this
+    may show beta or alpha dependencies.
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index 467f81e489..a8286ee4cb 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,10 +1,10 @@
 > Hey,
-> 
+>
 > First thanks for reporting, in order to help us to classify issue can you make sure the following check boxes are checked ?
-> 
+>
 > If this is about mockito usage, the better way is to reach out to
-> 
->  - stackoverflow : http://stackoverflow.com/questions/tagged/mockito
+>
+>  - stackoverflow : https://stackoverflow.com/questions/tagged/mockito
 >  - the mailing-list  : https://groups.google.com/forum/#!forum/mockito / mockito@googlegroups.com
 >    (Note mailing-list is moderated to avoid spam)
 >
@@ -20,6 +20,6 @@ check that
  - [ ] Provide versions (mockito / jdk / os / any other relevant information)
  - [ ] Provide a [Short, Self Contained, Correct (Compilable), Example](http://sscce.org) of the issue
        (same as any question on stackoverflow.com)
- - [ ] Read the [contributing guide](https://github.com/mockito/mockito/blob/release/3.x/.github/CONTRIBUTING.md)
+ - [ ] Read the [contributing guide](https://github.com/mockito/mockito/blob/main/.github/CONTRIBUTING.md)
 
 
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 5309c02649..6fbe6948a6 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,28 +1,13 @@
-> Hey, 
-> 
-> Thanks for the contribution, this is awesome.
-> As you may have read, project members have somehow an opinionated view on what and how should be
-> Mockito, e.g. we don't want mockito to be a feature bloat.
-> There may be a thorough review, with feedback -> code change loop.
-> 
-> Which branch : 
-> - On mockito 3.x, make your pull request target `release/3.x`
-> - On mockito 2.x, make your pull request target `release/2.x` (2.x is in maintenance mode)
->
-> _This block can be removed_
-> _Something wrong in the template fix it here `.github/PULL_REQUEST_TEMPLATE.md`
 
+## Checklist
 
-check list
-
- - [ ] Read the [contributing guide](https://github.com/mockito/mockito/blob/release/3.x/.github/CONTRIBUTING.md)
+ - [ ] Read the [contributing guide](https://github.com/mockito/mockito/blob/main/.github/CONTRIBUTING.md)
  - [ ] PR should be motivated, i.e. what does it fix, why, and if relevant how
  - [ ] If possible / relevant include an example in the description, that could help all readers
        including project members to get a better picture of the change
  - [ ] Avoid other runtime dependencies
  - [ ] Meaningful commit history ; intention is important please rebase your commit history so that each
        commit is meaningful and help the people that will explore a change in 2 years
- - [ ] The pull request follows coding style
+ - [ ] The pull request follows coding style (run `./gradlew spotlessApply` for auto-formatting)
  - [ ] Mention `Fixes #<issue number>` in the description _if relevant_
- - [ ] At least one commit should mention `Fixes #<issue number>` _if relevant_
-
+ - [ ] At least one commit should end with `Fixes #<issue number>` _if relevant_
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..1ef0730a67
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "gradle"
+    directory: "/"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000000..1a6cf82fdc
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,234 @@
+#
+# CI build that assembles artifacts and runs tests.
+# If validation is successful this workflow releases from the main dev branch.
+#
+# - skipping CI: add [skip ci] to the commit message
+# - skipping release: add [skip release] to the commit message
+#
+name: CI
+
+on:
+  push:
+    branches: ['main']
+    tags: [v*]
+  pull_request:
+    branches: ['**']
+
+permissions:
+  contents: read
+
+jobs:
+
+  #
+  # Main build job
+  #
+  build:
+    runs-on: ubuntu-latest
+    if: "! contains(toJSON(github.event.commits.*.message), '[skip ci]')"
+
+    # Definition of the build matrix
+    strategy:
+      matrix:
+        java: [11, 17, 21]
+        entry:
+          - { mock-maker: 'mock-maker-default', member-accessor: 'member-accessor-default' }
+          - { mock-maker: 'mock-maker-inline', member-accessor: 'member-accessor-module' }
+          - { mock-maker: 'mock-maker-subclass', member-accessor: 'member-accessor-module' }
+          - { mock-maker: 'mock-maker-subclass', member-accessor: 'member-accessor-reflection' }
+          - { mock-maker: 'mock-maker-inline', member-accessor: 'member-accessor-reflection' }
+
+    # All build steps
+    # SINGLE-MATRIX-JOB means that the step does not need to be executed on every job in the matrix
+    steps:
+
+    - name: 1. Check out code
+      uses: actions/checkout@v4 # https://github.com/actions/checkout
+      with:
+        fetch-depth: '0' # https://github.com/shipkit/shipkit-changelog#fetch-depth-on-ci
+
+    - name: 2. Set up Java for running Gradle build
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'zulu'
+        java-version: 17
+        cache: 'gradle'
+
+    - name: 3. Validate Gradle wrapper
+      if: matrix.java == 11 && matrix.entry.mock-maker == 'mock-maker-default' # SINGLE-MATRIX-JOB
+      uses: gradle/actions/wrapper-validation@v4 # https://github.com/gradle/wrapper-validation-action
+
+    - name: 4. Build and check reproducibility of artifacts (single job only)
+      if: matrix.java == 11 && matrix.entry.mock-maker == 'mock-maker-default' # SINGLE-MATRIX-JOB
+      run: ./check_reproducibility.sh
+
+    - name: 5. Spotless check (single job only). Run './gradlew spotlessApply' locally if this job fails.
+      if: matrix.java == 11 && matrix.entry.mock-maker == 'mock-maker-default' # SINGLE-MATRIX-JOB
+      run: >
+        ./gradlew
+        spotlessCheck
+        --stacktrace
+        --scan
+
+    - name: 6. Build on Java ${{ matrix.java }} with ${{ matrix.entry.mock-maker }} and ${{ matrix.entry.member-accessor }}
+      run: >
+        ./gradlew
+        -Pmockito.test.java=${{ matrix.java }}
+        build
+        --stacktrace
+        --scan
+      env:
+        MOCK_MAKER: ${{ matrix.entry.mock-maker }}
+        MEMBER_ACCESSOR: ${{ matrix.entry.member-accessor }}
+
+    - name: 7. Generate coverage report
+      run: >
+        ./gradlew
+        -Pmockito.test.java=${{ matrix.java }}
+        coverageReport
+        --stacktrace
+        --scan
+
+    - name: 8. Upload coverage report
+      uses: codecov/codecov-action@v5
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        files: mockito-core/build/reports/jacoco/mockitoCoverage/mockitoCoverage.xml
+        fail_ci_if_error: true
+
+  #
+  # Android build job
+  #
+  android:
+    runs-on: ubuntu-latest
+    if: "! contains(toJSON(github.event.commits.*.message), '[skip ci]')"
+    timeout-minutes: 30
+
+    # Definition of the build matrix
+    strategy:
+      matrix:
+        # Minimum supported and maximum available.
+        android-api: [ 26, 33 ]
+
+    # All build steps
+    steps:
+    - name: 1. Check out code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: '0' # https://github.com/shipkit/shipkit-changelog#fetch-depth-on-ci
+
+    - name: 2. Set up Java for running Gradle build
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'zulu'
+        java-version: 17
+        cache: 'gradle'
+
+    - name: 3. Enable KVM.
+      run: |
+        echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+        sudo udevadm control --reload-rules
+        sudo udevadm trigger --name-match=kvm
+
+    - name: 4. Run Android tests on Android API level ${{ matrix.android-api }}
+      uses: reactivecircus/android-emulator-runner@v2
+      with:
+        arch: x86_64
+        api-level: ${{ matrix.android-api }}
+        # Override default "-no-window -gpu swiftshader_indirect -no-snapshot -noaudio -no-boot-anim"
+        # See emulator manual for reference: https://developer.android.com/studio/run/emulator-commandline
+        emulator-options: >
+          -no-window
+          -gpu swiftshader_indirect
+          -no-snapshot
+          -noaudio
+          -no-boot-anim
+          -camera-back none
+          -camera-front none
+        # See logcat manual for reference: https://developer.android.com/studio/command-line/logcat
+        script: |
+          # Capture logcat output from "Launch Emulator" to a file.
+          adb logcat -d > emulator-startup.log
+          # Shorten the logcat output, by truncating at this point, the relevant part is yet to come.
+          # Best effort, could fail with "failed to clear the 'main' log",
+          # because something is locking logcat, so try a few times, and ignore errors each time.
+          adb logcat --clear || true
+          adb logcat --clear || true
+          adb logcat --clear || true
+          # Capture full logcat output to a file.
+          adb logcat > emulator.log & echo $! > logcat_file.pid
+          # Output instrumentation test logs to the GitHub Actions output.
+          adb logcat "*:S MonitoringInstr:V AndroidJUnitRunner:V TestRequestBuilder:V TestExecutor:V TestRunner:V" --format=color & echo $! > logcat_console.pid
+
+          echo 0 > gradle.exit # Set a default exit code.
+          # Run the actual tests (suppress build failures by saving the exit code).
+          ./gradlew :mockito-integration-tests:android-tests:connectedCheck --no-daemon --no-build-cache || echo $? > gradle.exit
+
+          # Stop capturing logcat output.
+          kill $(cat logcat_file.pid)    || echo "::warning file=.github/workflows/ci.yml::Logcat process $(cat logcat_file.pid) didn't exist."
+          kill $(cat logcat_console.pid) || echo "::warning file=.github/workflows/ci.yml::Logcat process $(cat logcat_console.pid) didn't exist."
+          # Make sure the step fails if the tests failed.
+          exit $(cat gradle.exit)
+
+    - name: 5. Upload artifact "android-tests-results-${{ matrix.android-api }}"
+      if: success() || failure()
+      uses: actions/upload-artifact@v4
+      with:
+        name: androidTest-results-${{ matrix.android-api }}
+        path: |
+          ${{ github.workspace }}/mockito-integration-tests/android-tests/build/reports/android-tests/connected/**
+          ${{ github.workspace }}/emulator.log
+          ${{ github.workspace }}/emulator-startup.log
+
+    # :mockito-integration-tests:android-tests:connectedCheck (which depends on :mockito-integration-tests:android-tests:createDebugAndroidTestCoverageReport) already generated coverage report.
+    - name: 6. Upload coverage report
+      uses: codecov/codecov-action@v5
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        files: mockito-integration-tests/android-tests/build/reports/coverage/android-tests/debug/connected/report.xml
+        fail_ci_if_error: true
+
+  #
+  # Release job, only for pushes to the main development branch
+  #
+  release:
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    needs: [build] # build job must pass before we can release
+
+    if: github.event_name == 'push'
+        && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v'))
+        && github.repository == 'mockito/mockito'
+        && !contains(toJSON(github.event.commits.*.message), '[skip release]')
+
+    steps:
+
+      - name: 1. Check out code
+        uses: actions/checkout@v4 # https://github.com/actions/checkout
+        with:
+          fetch-depth: '0' # https://github.com/shipkit/shipkit-changelog#fetch-depth-on-ci
+
+      - name: 2. Set up Java for running Gradle build
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: 21
+          cache: 'gradle'
+
+      - name: 3. Build and release
+        run: >
+          ./gradlew
+          githubRelease
+          publishToSonatype
+          closeAndReleaseStagingRepositories
+          releaseSummary
+          --info
+          --stacktrace
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          NEXUS_TOKEN_USER: ${{secrets.NEXUS_TOKEN_USER}}
+          NEXUS_TOKEN_PWD: ${{secrets.NEXUS_TOKEN_PWD}}
+          PGP_KEY: ${{secrets.PGP_KEY}}
+          PGP_PWD: ${{secrets.PGP_PWD}}
diff --git a/.github/workflows/gradle-wrapper-validation.yml b/.github/workflows/gradle-wrapper-validation.yml
deleted file mode 100644
index 405a2b3065..0000000000
--- a/.github/workflows/gradle-wrapper-validation.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-name: "Validate Gradle Wrapper"
-on: [push, pull_request]
-
-jobs:
-  validation:
-    name: "Validation"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: gradle/wrapper-validation-action@v1
diff --git a/.gitignore b/.gitignore
index 9d0c115582..2638ca5724 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
+# Mac
+.DS_Store
+
 # Intellij
 *.iml
 *.ipr
@@ -12,6 +15,9 @@
 .settings/
 bin/
 
+# VSCode
+.vscode/
+
 # Gradle & builds
 build
 build-cache
@@ -21,3 +27,7 @@ out
 classes
 .gradletasknamecache
 *.log
+
+# Used to check reproducibility of Mockito jars
+checksums/
+/.tool-versions
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 26c444f3ef..0000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-# More details on how to configure the Travis build
-# https://docs.travis-ci.com/user/customizing-the-build/
-
-# Speed up build by leveraging travis caches
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/
-
-# Enabling container based infrastructure hoping it will help the build speed <= this didn't work well, so it's reverted
-# see https://docs.travis-ci.com/user/migrating-from-legacy/ and https://docs.travis-ci.com/user/ci-environment
-sudo: true
-
-language: java
-
-dist: trusty
-
-matrix:
-  include:
-  - jdk: openjdk8
-  - jdk: openjdk8
-    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline
-  - jdk: openjdk9
-    env: SKIP_RELEASE=true
-  - jdk: openjdk9
-    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline
-  - jdk: openjdk9
-    env: SKIP_RELEASE=true SIMULATE_JAVA11=true
-  - jdk: openjdk10
-    env: SKIP_RELEASE=true
-  - jdk: openjdk10
-    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline
-  - jdk: openjdk11
-    env: SKIP_RELEASE=true
-  - jdk: openjdk11
-    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline
-
-branches:
-  #Don't build tags
-  except:
-  - /^v\d/
-
-#Below skips the installation step completely (https://docs.travis-ci.com/user/customizing-the-build/#Skipping-the-Installation-Step)
-#We need it because otherwise Travis CI injects an awkward './gradlew assemble' step into the CI workflow
-#We want to control and decide what Gradle tasks are executed
-install:
- - true
-
-script:
-  # We are using && below on purpose
-  # ciPerformRelease must run only when the entire build has completed
-  # This guarantees that no release steps are executed when the build or tests fail
-  - ./gradlew spotlessCheck && ./gradlew build idea -s && ./gradlew ciPerformRelease
-
-after_success:
-  #Generates coverage report:
-  - ./gradlew coverageReport -Pjacoco -s --scan && cp build/reports/jacoco/mockitoCoverage/mockitoCoverage.xml jacoco.xml || echo "Code coverage failed"
-  - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"
diff --git a/README.md b/README.md
index a69f94874a..40a805c948 100644
--- a/README.md
+++ b/README.md
@@ -1,85 +1,85 @@
-<a href="http://site.mockito.org">
-<img src="https://raw.githubusercontent.com/mockito/mockito/release/3.x/src/javadoc/org/mockito/logo.png"
-     srcset="https://raw.githubusercontent.com/mockito/mockito/release/3.x/src/javadoc/org/mockito/logo@2x.png 2x"
+<a href="https://site.mockito.org">
+<img src="https://raw.githubusercontent.com/mockito/mockito/main/config/javadoc/resources/org/mockito/logo.png"
+     srcset="https://raw.githubusercontent.com/mockito/mockito/main/config/javadoc/resources/org/mockito/logo@2x.png 2x"
      alt="Mockito" />
 </a>
 
 Most popular mocking framework for Java
 
-[![Build Status](https://travis-ci.org/mockito/mockito.svg?branch=release/3.x)](https://travis-ci.org/mockito/mockito)
+[![CI](https://github.com/mockito/mockito/workflows/CI/badge.svg)](https://github.com/mockito/mockito/actions?query=workflow%3ACI)
 [![Coverage Status](https://img.shields.io/codecov/c/github/mockito/mockito.svg)](https://codecov.io/github/mockito/mockito)
-[![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/mockito/mockito/blob/release/3.x/LICENSE)
+[![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/mockito/mockito/blob/main/LICENSE)
 
-[![Release Notes](https://img.shields.io/badge/release%20notes-3.x-yellow.svg)](https://github.com/mockito/mockito/blob/release/3.x/doc/release-notes/official.md)
+[![Release Notes](https://img.shields.io/badge/release%20notes-5.x-yellow.svg)](https://github.com/mockito/mockito/releases/)
 [![Maven Central](https://img.shields.io/maven-central/v/org.mockito/mockito-core.svg)](https://search.maven.org/artifact/org.mockito/mockito-core/)
-[![Bintray](https://img.shields.io/bintray/v/mockito/maven/mockito-development)](https://bintray.com/mockito/maven/mockito/_latestVersion)
 [![Javadoc](https://www.javadoc.io/badge/org.mockito/mockito-core.svg)](https://www.javadoc.io/doc/org.mockito/mockito-core)
 
 
-## Current version is 3.x
-Still on Mockito 1.x? See [what's new](https://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2) in Mockito 2! [Mockito 3](https://github.com/mockito/mockito/releases/tag/v3.0.0) does not introduce any breaking API changes, but now requires Java 8 over Java 6 for Mockito 2.
+## Current version is 5.x
+Still on Mockito 1.x? See [what's new](https://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2) in Mockito 2!
+[Mockito 3](https://github.com/mockito/mockito/releases/tag/v3.0.0) does not introduce any breaking API changes, but now requires Java 8 over Java 6 for Mockito 2.
+[Mockito 4](https://github.com/mockito/mockito/releases/tag/v4.0.0) removes deprecated API.
+[Mockito 5](https://github.com/mockito/mockito/releases/tag/v5.0.0) switches the default mockmaker to mockito-inline, and now requires Java 11.
+Only one major version is supported at a time, and changes are not backported to older versions.
 
 ## Mockito for enterprise
 
-Available as part of the Tidelift Subscription
+Available as part of the [Tidelift](https://tidelift.com/subscription/pkg/maven-org-mockito-mockito-core) Subscription.
 
-The maintainers of org.mockito:mockito-core and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/maven-org-mockito-mockito-core?utm_source=maven-org-mockito-mockito-core&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+The maintainers of org.mockito:mockito-core and thousands of other packages are working with Tidelift to deliver
+commercial support and maintenance for the open source dependencies you use to build your applications. Save time,
+reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use.
+[Learn more.](https://tidelift.com/subscription/pkg/maven-org-mockito-mockito-core?utm_source=maven-org-mockito-mockito-core&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
 
 ## Development
 
-Mockito [continuously delivers](https://github.com/mockito/mockito/wiki/Continuous-Delivery-Overview) improvements using Shipkit library (http://shipkit.org). See the [latest release notes](https://github.com/mockito/mockito/blob/release/3.x/doc/release-notes/official.md) and [latest documentation](http://javadoc.io/page/org.mockito/mockito-core/2/org/mockito/Mockito.html). Docs in javadoc.io are available 24h after release. Read also about [semantic versioning in Mockito](https://github.com/mockito/mockito/wiki/Semantic-Versioning). **Note: not every version is published to Maven Central.**
+Mockito publishes every change as a `-SNAPSHOT` version to a public Sonatype repository. Roughly once a month, we
+publish a new minor or patch version to Maven Central. For release automation we use
+[Shipkit library](http://shipkit.org), [Gradle Nexus Publish Plugin](https://github.com/gradle-nexus/publish-plugin).
+Fully automated releases are awesome, and you should do that for your libraries, too!
+See the [latest release notes](https://github.com/mockito/mockito/releases/)
+and [latest documentation](https://javadoc.io/doc/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html). Docs in
+javadoc.io are available 24h after release. Read also
+about [semantic versioning in Mockito](https://github.com/mockito/mockito/wiki/Semantic-Versioning).
 
 Older 1.x and 2.x releases are available in
-[Central Repository](http://search.maven.org/#artifactdetails|org.mockito|mockito-core|1.10.19|jar)
-, [Bintray](https://bintray.com/mockito/maven/mockito/1.10.19/view)
-and [javadoc.io](http://javadoc.io/doc/org.mockito/mockito-core/1.10.19/org/mockito/Mockito.html) (documentation).
+[Central Repository](https://search.maven.org/artifact/org.mockito/mockito-core/1.10.19/jar)
+and [javadoc.io](https://javadoc.io/doc/org.mockito/mockito-core/1.10.19/org/mockito/Mockito.html) (documentation).
 
 ## More information
 
-All you want to know about Mockito is hosted at [The Mockito Site](http://site.mockito.org) which is [Open Source](https://github.com/mockito/mockito.github.io) and likes [pull requests](https://github.com/mockito/mockito.github.io/pulls), too.
+All you want to know about Mockito is hosted at [The Mockito Site](https://site.mockito.org) which is [Open Source](https://github.com/mockito/mockito.github.io) and likes [pull requests](https://github.com/mockito/mockito.github.io/pulls), too.
 
-Want to contribute? Take a look at the [Contributing Guide](https://github.com/mockito/mockito/blob/release/3.x/.github/CONTRIBUTING.md).
+Want to contribute? Take a look at the [Contributing Guide](https://github.com/mockito/mockito/blob/main/.github/CONTRIBUTING.md).
 
 Enjoy Mockito!
 
 ## Need help?
 
-* Search / Ask question on [stackoverflow](http://stackoverflow.com/questions/tagged/mockito)
-* Go to the [mockito mailing-list](http://groups.google.com/group/mockito) (moderated)
+* Search / Ask question on [stackoverflow](https://stackoverflow.com/questions/tagged/mockito)
+* Go to the [mockito mailing-list](https://groups.google.com/group/mockito) (moderated)
 * Open a ticket in GitHub [issue tracker](https://github.com/mockito/mockito/issues)
 
 ## How to develop Mockito?
 
 To build locally:
 
-     ./gradlew build
-
-To develop in IntelliJ IDEA you can use built-in Gradle import wizard in IDEA.
-Alternatively generate the importable IDEA metadata files using:
-
-     ./gradlew idea
-
-Then, _open_ the generated *.ipr file in IDEA.
+```shell
+./gradlew build
+```
+You can open in any IDE that support Gradle, e.g. IntelliJ IDEA, or Fleet.
+For Eclipse, one may need to run `./gradlew eclipse` before importing the project.
 
 ## How to release new version?
 
-Mockito [implements Continuous Delivery model](https://github.com/mockito/mockito/wiki/Continuous-Delivery-Overview).
-Every change on main branch (for example merging a pull request) triggers a release build on Travis CI.
-The build publishes new version if specific criteria are met: all tests green, no 'ci skip release' used in commit message, see the build log for more information.
-Every new version is published to ["mockito/maven" Bintray repository](https://bintray.com/mockito/maven).
-New versions that Mockito team deems "notable" are additionally published to [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.mockito%22) and [JCenter](https://bintray.com/bintray/jcenter).
-We used to publish every version to Maven Central but we changed this strategy based on feedback from the community ([#911](https://github.com/mockito/mockito/issues/911)).
-
-* Q: What's new in Mockito release model?
-
-  A: In Q2 2017 we implemented [Mockito Continuous Delivery Pipeline 2.0](https://github.com/mockito/mockito/issues/911).
-  Not every version is published to Maven Central.
-
-* Q: How to publish to Maven Central?
-
-  A: Include "[ci maven-central-release]" in the **merge** commit when merging the PR.
-  **Hint**: To signify a new feature consider updating version to next minor/major, like: "2.8.0", "2.9.0", "3.0.0".
+1. Every change on the main development branch is released as `-SNAPSHOT` version to Sonatype snapshot repo
+   at https://s01.oss.sonatype.org/content/repositories/snapshots/org/mockito/mockito-core.
+2. To release a non-snapshot version to Maven Central push an annotated tag, for example:
 
-* Q: How to promote already released version to a notable version?
+    ```shell
+    git tag -a -m "Release 3.4.5" v3.4.5
+    git push origin v3.4.5
+    ```
 
-  A: It isn't automated at the moment. [What's the use case?](https://github.com/mockito/mockito/issues/911)
+3. At the moment, you **may not create releases from GitHub Web UI**. Doing so will make the CI build fail because the
+   CI creates the changelog and posts to GitHub releases. We'll support this in the future.
diff --git a/build.gradle b/build.gradle
deleted file mode 100644
index a44878c0a9..0000000000
--- a/build.gradle
+++ /dev/null
@@ -1,134 +0,0 @@
-buildscript {
-    repositories {
-        mavenLocal() //for local testing of mockito-release-tools
-        jcenter()
-        maven { url "https://plugins.gradle.org/m2/" }
-    }
-
-    dependencies {
-        classpath 'gradle.plugin.nl.javadude.gradle.plugins:license-gradle-plugin:0.14.0'
-        classpath 'net.ltgt.gradle:gradle-errorprone-plugin:0.6'
-
-        //Using buildscript.classpath so that we can resolve shipkit from maven local, during local testing
-        classpath 'org.shipkit:shipkit:2.1.6'
-    }
-}
-
-plugins {
-    id 'com.gradle.build-scan' version '2.2.1'
-    id "com.diffplug.gradle.spotless" version "3.24.3"
-    id 'eclipse'
-}
-
-description = 'Mockito mock objects library core API and implementation'
-
-apply plugin: 'base'
-archivesBaseName = "mockito-core"
-
-apply plugin: "org.shipkit.java"
-allprojects {
-    plugins.withId("java") {
-        //Only upload specific modules we select
-        bintrayUpload.enabled = false
-    }
-}
-
-apply from: 'gradle/root/ide.gradle'
-apply from: 'gradle/root/gradle-fix.gradle'
-apply from: 'gradle/java-library.gradle'
-apply from: 'gradle/license.gradle'
-apply from: 'gradle/root/coverage.gradle'
-
-apply from: 'gradle/mockito-core/inline-mock.gradle'
-apply from: 'gradle/mockito-core/osgi.gradle'
-apply from: 'gradle/mockito-core/javadoc.gradle'
-apply from: 'gradle/mockito-core/testing.gradle'
-
-apply from: 'gradle/dependencies.gradle'
-
-allprojects { proj ->
-    repositories {
-        jcenter()
-    }
-    plugins.withId('java') {
-        proj.apply from: "$rootDir/gradle/errorprone.gradle"
-    }
-    tasks.withType(JavaCompile) {
-        //I don't believe those warnings add value given modern IDEs
-        options.warnings = false
-        options.encoding = 'UTF-8'
-    }
-    tasks.withType(Javadoc) {
-        options.addStringOption('Xdoclint:none', '-quiet')
-        options.addStringOption('encoding', 'UTF-8')
-        options.addStringOption('charSet', 'UTF-8')
-        options.setSource('8')
-    }
-    apply plugin: 'checkstyle'
-    checkstyle {
-       configFile = rootProject.file('config/checkstyle/checkstyle.xml')
-    }
-}
-
-configurations {
-    testUtil //TODO move to separate project
-}
-
-dependencies {
-    compile libraries.bytebuddy, libraries.bytebuddyagent
-
-    compileOnly libraries.junit4, libraries.hamcrest, libraries.opentest4j
-    compile libraries.objenesis
-
-    testCompile libraries.asm
-
-    testCompile libraries.assertj
-
-    //putting 'provided' dependencies on test compile and runtime classpath
-    testCompileOnly configurations.compileOnly
-    testRuntime configurations.compileOnly
-
-    testUtil sourceSets.test.output
-}
-
-wrapper {
-    gradleVersion = '5.3.1'
-    distributionSha256Sum = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
-}
-
-//Posting Build scans to https://scans.gradle.com
-buildScan {
-    termsOfServiceUrl = 'https://gradle.com/terms-of-service'
-    termsOfServiceAgree = 'yes'
-}
-
-spotless {
-    java {
-        licenseHeaderFile rootProject.file('config/spotless/spotless.header')
-
-        removeUnusedImports()
-        trimTrailingWhitespace()
-        endWithNewline()
-        indentWithSpaces(4)
-
-        importOrder 'static java', 'static javax', 'static ', 'java', 'javax', ''
-    }
-}
-
-
-//workaround for #1444, delete when Shipkit bug is fixed
-subprojects {
-	eclipse {
-		project {
-			name = rootProject.name + '-' + project.name
-		}
-	}
-
-    afterEvaluate {
-        def lib = publishing.publications.javaLibrary
-        if(lib && !lib.artifactId.startsWith("mockito-")) {
-            lib.artifactId = "mockito-" + lib.artifactId
-        }
-    }
-}
-//end workaround
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000000..b5b00de8a0
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,22 @@
+buildscript {
+    repositories {
+        mavenLocal() //for local testing of mockito-release-tools
+        google()
+        gradlePluginPortal()
+    }
+
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.24")
+    }
+}
+
+plugins {
+    id("eclipse")
+    id("com.github.ben-manes.versions") version "0.51.0"
+    id("mockito.root.releasing-conventions")
+
+    // Top-level android plugin declaration required for :mockito-integration-tests:android-tests to work
+    alias(libs.plugins.android.application) apply false
+}
+
+
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
new file mode 100644
index 0000000000..60cdda5b56
--- /dev/null
+++ b/buildSrc/build.gradle.kts
@@ -0,0 +1,21 @@
+plugins {
+    // doc: https://docs.gradle.org/current/userguide/kotlin_dsl.html
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation(libs.gradleplugin.testLogger)
+    implementation(libs.gradleplugin.animalSniffer)
+    implementation(libs.gradleplugin.bnd)
+    implementation(libs.gradleplugin.errorprone)
+    implementation(libs.gradleplugin.spotless)
+    implementation(libs.gradleplugin.spotless.googleJavaFormat)
+    implementation(libs.gradleplugin.license)
+
+    implementation(libs.gradleplugin.nexusPublish)
+    implementation(libs.gradleplugin.shipkit.changelog)
+    implementation(libs.gradleplugin.shipkit.autoVersion)
+
+    // https://github.com/gradle/gradle/issues/15383
+    implementation(files(libs.javaClass.superclass.protectionDomain.codeSource.location))
+}
diff --git a/buildSrc/settings.gradle.kts b/buildSrc/settings.gradle.kts
new file mode 100644
index 0000000000..1a4794687b
--- /dev/null
+++ b/buildSrc/settings.gradle.kts
@@ -0,0 +1,11 @@
+dependencyResolutionManagement {
+    repositories {
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/Common.kt b/buildSrc/src/main/kotlin/Common.kt
new file mode 100644
index 0000000000..d250678050
--- /dev/null
+++ b/buildSrc/src/main/kotlin/Common.kt
@@ -0,0 +1,10 @@
+import org.gradle.accessors.dm.LibrariesForLibs
+import org.gradle.api.Project
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.kotlin.dsl.the
+
+val Project.libs
+    get() = the<LibrariesForLibs>()
+
+val Project.sourceSets
+    get() = the<SourceSetContainer>()
diff --git a/buildSrc/src/main/kotlin/MockitoJavadoc.kt b/buildSrc/src/main/kotlin/MockitoJavadoc.kt
new file mode 100644
index 0000000000..46fa27446a
--- /dev/null
+++ b/buildSrc/src/main/kotlin/MockitoJavadoc.kt
@@ -0,0 +1,6 @@
+import org.gradle.api.provider.Property
+
+interface MockitoJavadocExtension {
+    val title: Property<String>
+    val docTitle: Property<String>
+}
diff --git a/buildSrc/src/main/kotlin/TaskExtensions.kt b/buildSrc/src/main/kotlin/TaskExtensions.kt
new file mode 100644
index 0000000000..50331722aa
--- /dev/null
+++ b/buildSrc/src/main/kotlin/TaskExtensions.kt
@@ -0,0 +1,7 @@
+import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.external.javadoc.StandardJavadocDocletOptions
+
+/** Applies the standard doclet options. */
+fun Javadoc.javadocDocletOptions(block: StandardJavadocDocletOptions.() -> Unit) {
+    (options as StandardJavadocDocletOptions).apply(block)
+}
diff --git a/buildSrc/src/main/kotlin/mockito.java-backward-compatibility-checks-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.java-backward-compatibility-checks-conventions.gradle.kts
new file mode 100644
index 0000000000..d19efc6644
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.java-backward-compatibility-checks-conventions.gradle.kts
@@ -0,0 +1,30 @@
+import ru.vyarus.gradle.plugin.animalsniffer.AnimalSnifferExtension
+
+plugins {
+    java // for sourceSets
+    id("ru.vyarus.animalsniffer")
+}
+
+
+val main: SourceSet by sourceSets.getting
+configure<AnimalSnifferExtension> {
+    sourceSets = listOf(main)
+    annotation = "org.mockito.internal.SuppressSignatureCheck"
+
+    // See please https://github.com/mojohaus/animal-sniffer/issues/172
+    ignore(
+        "java.lang.instrument.Instrumentation",
+        "java.lang.invoke.MethodHandle",
+        "java.lang.invoke.MethodHandles\$Lookup",
+        "java.lang.StackWalker",
+        "java.lang.StackWalker\$StackFrame",
+        "java.lang.StackWalker\$Option",
+    )
+}
+
+dependencies {
+    // Equivalent to "net.sf.androidscents.signature:android-api-level-26:8.0.0_r2@signature"
+    signature(variantOf(libs.animalSniffer.android.apiLevel26) { artifactType("signature") })
+    signature(variantOf(libs.animalSniffer.java) { artifactType("signature") })
+}
+
diff --git a/buildSrc/src/main/kotlin/mockito.java-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.java-conventions.gradle.kts
new file mode 100644
index 0000000000..1e41ef22d7
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.java-conventions.gradle.kts
@@ -0,0 +1,34 @@
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.plugins.JavaPluginExtension
+
+// only apply to Java projects
+// i.e., do nothing when applied to Android projects
+plugins.withType(JavaPlugin::class) {
+    val javaReleaseVersion = 11
+
+    configure<JavaPluginExtension> {
+        sourceCompatibility = JavaVersion.toVersion(javaReleaseVersion)
+        targetCompatibility = JavaVersion.toVersion(javaReleaseVersion)
+    }
+
+    tasks {
+        withType<JavaCompile>().configureEach {
+            // I don't believe those warnings add value given modern IDEs
+            options.isWarnings = false
+            options.encoding = "UTF-8"
+        }
+
+        withType<Javadoc>().configureEach {
+            options {
+                encoding = "UTF-8"
+                source = javaReleaseVersion.toString()
+
+                if (this is StandardJavadocDocletOptions) {
+                    addStringOption("Xdoclint:none", "-quiet")
+                    addStringOption("charSet", "UTF-8")
+                }
+            }
+        }
+    }
+}
+
diff --git a/buildSrc/src/main/kotlin/mockito.java-library-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.java-library-conventions.gradle.kts
new file mode 100644
index 0000000000..40633ea36d
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.java-library-conventions.gradle.kts
@@ -0,0 +1,36 @@
+plugins {
+    `java-library`
+    id("mockito.java-conventions")
+    id("mockito.test-conventions")
+    id("mockito.test-retry-conventions")
+    id("mockito.test-launcher-conventions")
+    id("net.ltgt.errorprone")
+}
+
+if (!project.name.startsWith("mockito-")) {
+    throw GradleException("Published project module should be prefixed with `mockito-` : ${project.projectDir})")
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    errorprone(libs.errorprone)
+}
+
+tasks {
+    withType<AbstractArchiveTask>().configureEach {
+        isPreserveFileTimestamps = false
+        isReproducibleFileOrder = true
+        // dirMode = Integer.parseInt("0755", 8)
+        dirPermissions {
+            unix("rwxr-xr-x") // 0755
+        }
+        // fileMode = Integer.parseInt("0644", 8)
+        filePermissions {
+            unix("rw-r--r--") // 0644
+        }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts
new file mode 100644
index 0000000000..29aab3a9dd
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts
@@ -0,0 +1,69 @@
+import org.gradle.api.tasks.javadoc.Javadoc
+
+plugins {
+    java
+}
+
+val mockitoJavadocExtension = project.extensions.create<MockitoJavadocExtension>("mockitoJavadoc").apply {
+    title.convention(project.name)
+    docTitle.convention("<h1>${project.name}</h1>")
+}
+
+val javadocConfigDir = "$rootDir/config/javadoc"
+
+tasks.named<Javadoc>("javadoc") {
+    inputs.dir(javadocConfigDir)
+    description = "Creates javadoc html for ${project.name}."
+
+    // Work-around as suggested in https://github.com/gradle/gradle/issues/19726
+    val sourceSetDirectories = sourceSets.main.get().java.sourceDirectories.joinToString(":")
+    val coreOptions = options as CoreJavadocOptions
+    coreOptions.addStringOption("-source-path", sourceSetDirectories)
+    exclude("**/internal/**")
+
+    // For more details on the format
+    // see https://docs.oracle.com/en/java/javase/21/javadoc/javadoc.html
+    options {
+        title = mockitoJavadocExtension.title.get()
+        encoding = "UTF-8"
+
+        if (this is StandardJavadocDocletOptions) {
+            addBooleanOption("-allow-script-in-comments", true)
+            addFileOption("-add-stylesheet", project.file("$javadocConfigDir/resources/mockito-theme.css"))
+            addStringOption("Xwerror", "-quiet")
+            charSet = "UTF-8"
+            docEncoding = "UTF-8"
+            docTitle = mockitoJavadocExtension.docTitle.get()
+
+            bottom(
+                """
+                <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/obsidian.min.css">
+                <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
+                <script>hljs.highlightAll();</script>
+                """.trimIndent().replace("\r|\n|[ ]{8}".toRegex(), "")
+            )
+
+            group("Main package", "org.mockito")
+            links("https://junit.org/junit4/javadoc/${project.libs.versions.junit4.get()}/")
+            linksOffline(
+                "https://docs.oracle.com/en/java/javase/11/docs/api/",
+                "$javadocConfigDir/jdk-package-list"
+            )
+
+            isSplitIndex = true
+            isUse = true
+            windowTitle = mockitoJavadocExtension.title.get()
+
+            addBooleanOption("html5", true)
+        }
+        memberLevel = JavadocMemberLevel.PROTECTED
+        outputLevel = JavadocOutputLevel.QUIET
+    }
+
+    doLast {
+        copy {
+            from("$javadocConfigDir/resources")
+            into(destinationDir!!)
+        }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/mockito.library-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.library-conventions.gradle.kts
new file mode 100644
index 0000000000..09049d6282
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.library-conventions.gradle.kts
@@ -0,0 +1,9 @@
+plugins {
+    base
+    id("mockito.java-library-conventions")
+    id("mockito.osgi-conventions")
+    id("mockito.publication-conventions")
+    id("mockito.quality-checkstyle-conventions")
+    id("mockito.quality-spotless-conventions")
+    id("mockito.license-conventions")
+}
diff --git a/buildSrc/src/main/kotlin/mockito.license-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.license-conventions.gradle.kts
new file mode 100644
index 0000000000..247caf88af
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.license-conventions.gradle.kts
@@ -0,0 +1,29 @@
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+
+plugins {
+    id("com.github.hierynomus.license")
+}
+
+val licenseHeaderFile = rootProject.file("doc/licenses/HEADER.txt")
+
+license {
+    header = licenseHeaderFile
+    strictCheck = true
+    ignoreFailures = true
+    skipExistingHeaders = true
+    mapping(mapOf(
+        "java" to "SLASHSTAR_STYLE",
+        "groovy" to "SLASHSTAR_STYLE",
+        "kt" to "SLASHSTAR_STYLE",
+    ))
+
+    exclude("junit-platform.properties")
+    exclude("mockito-extensions/org.mockito.plugins.*")
+    exclude("META-INF/services/org.junit.jupiter.api.extension.Extension")
+    exclude("org/mockito/internal/util/concurrent/README.md")
+    exclude("org/mockito/internal/util/concurrent/LICENSE")
+
+
+    ext["year"] = OffsetDateTime.now(ZoneOffset.UTC).year
+}
diff --git a/buildSrc/src/main/kotlin/mockito.osgi-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.osgi-conventions.gradle.kts
new file mode 100644
index 0000000000..eaa8a3ed92
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.osgi-conventions.gradle.kts
@@ -0,0 +1,3 @@
+plugins {
+    id("biz.aQute.bnd.builder")
+}
diff --git a/buildSrc/src/main/kotlin/mockito.publication-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.publication-conventions.gradle.kts
new file mode 100644
index 0000000000..de2f6ac5d9
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.publication-conventions.gradle.kts
@@ -0,0 +1,166 @@
+import org.gradle.kotlin.dsl.`maven-publish`
+import org.gradle.kotlin.dsl.withType
+
+plugins {
+    `maven-publish`
+    signing
+}
+
+// enforce the same group for all published artifacts
+group = "org.mockito"
+
+val localRepoForTesting = rootProject.layout.buildDirectory.dir("repo")
+
+// generic publication conventions
+publishing {
+    publications {
+        withType(MavenPublication::class).configureEach {
+            pom {
+                artifactId = project.base.archivesName.get()
+                name = artifactId
+                description = providers.provider { project.description }
+                url = "https://github.com/mockito/mockito"
+                licenses {
+                    license {
+                        name = "MIT"
+                        url = "https://opensource.org/licenses/MIT"
+                        distribution = "repo"
+                    }
+                }
+                developers {
+                    listOf(
+                        "mockitoguy:Szczepan Faber",
+                        "bric3:Brice Dutheil",
+                        "raphw:Rafael Winterhalter",
+                        "TimvdLippe:Tim van der Lippe"
+                    ).forEach { devData ->
+                        developer {
+                            val devInfo = devData.split(":")
+                            id = devInfo[0]
+                            name = devInfo[1]
+                            url = "https://github.com/" + devInfo[0]
+                            roles = listOf("Core developer")
+                        }
+                    }
+                }
+                scm {
+                    url = "https://github.com/mockito/mockito.git"
+                }
+                issueManagement {
+                    url = "https://github.com/mockito/mockito/issues"
+                    system = "GitHub issues"
+                }
+                ciManagement {
+                    url = "https://github.com/mockito/mockito/actions"
+                    system = "GH Actions"
+                }
+            }
+        }
+    }
+
+    //useful for testing - running "publish" will create artifacts/pom in a local dir
+    repositories {
+        maven(uri(localRepoForTesting)) {
+            name = "local"
+        }
+    }
+}
+
+tasks.clean {
+    doLast {
+        delete(localRepoForTesting)
+    }
+}
+
+// Java platform publication conventions (BOM file)
+plugins.withType(JavaPlatformPlugin::class) {
+    publishing {
+        publications {
+            register<MavenPublication>("mockitoPlatform") {
+                from(components["javaPlatform"])
+            }
+        }
+    }
+}
+
+// Java library publication conventions
+plugins.withType<JavaLibraryPlugin>().configureEach {
+    // Sources/javadoc artifacts required by Maven module publications
+    val licenseSpec = copySpec {
+        from(project.rootDir)
+        include("LICENSE")
+    }
+
+    val sourcesJar by tasks.registering(Jar::class) {
+        archiveClassifier.set("sources")
+        from(project.sourceSets["main"].allSource)
+        with(licenseSpec)
+    }
+
+    val javadocJar by tasks.registering(Jar::class) {
+        archiveClassifier.set("javadoc")
+        from(tasks.named("javadoc"))
+        with(licenseSpec)
+    }
+
+    project.artifacts {
+        archives(sourcesJar)
+        archives(javadocJar)
+    }
+
+    tasks.named("jar", Jar::class) {
+        with(licenseSpec)
+    }
+
+    // only create a 'java' publication when the JavaPlugin is present
+    publishing {
+        publications {
+            register<MavenPublication>("mockitoLibrary") {
+                from(components["java"])
+                artifact(sourcesJar)
+                artifact(javadocJar)
+
+                pom {
+                    // Gradle does not write 'jar' packaging to the pom (unlike other packaging types).
+                    // This is OK because 'jar' is implicit/default:
+                    // https://maven.apache.org/guides/introduction/introduction-to-the-pom.html#minimal-pom
+                    packaging = project.tasks.named<Jar>("jar").get().archiveExtension.get()
+                }
+            }
+        }
+    }
+
+    tasks.named<GenerateMavenPom>("generatePomFileForMockitoLibraryPublication") {
+        doLast {
+            // validates that the pom has correct artifact id to avoid issues like #1444
+            destination.readText().let { pomContent ->
+                require(pomContent.contains("<artifactId>${project.base.archivesName.get()}</artifactId>")) {
+                    "POM file does not contain the correct artifactId: ${project.base.archivesName.get()}"
+                }
+                require(pomContent.contains("<name>${project.base.archivesName.get()}</name>")) {
+                    "POM file does not contain the correct name: ${project.base.archivesName.get()}"
+                }
+            }
+        }
+    }
+
+    // fleshes out problems with Maven pom generation when building
+    tasks.build {
+        dependsOn("publishAllPublicationsToLocalRepository")
+    }
+}
+
+tasks.withType<GenerateModuleMetadata>().configureEach {
+    enabled = false
+}
+
+// https://docs.gradle.org/current/userguide/signing_plugin.html
+signing {
+    if (providers.environmentVariable("PGP_KEY").isPresent) {
+        useInMemoryPgpKeys(
+            providers.environmentVariable("PGP_KEY").orNull,
+            providers.environmentVariable("PGP_PWD").orNull
+        )
+        sign(publishing.publications)
+    }
+}
diff --git a/buildSrc/src/main/kotlin/mockito.quality-checkstyle-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.quality-checkstyle-conventions.gradle.kts
new file mode 100644
index 0000000000..3fda6bd2cb
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.quality-checkstyle-conventions.gradle.kts
@@ -0,0 +1,19 @@
+import org.gradle.api.plugins.quality.Checkstyle
+import org.gradle.kotlin.dsl.checkstyle
+import org.gradle.kotlin.dsl.withType
+
+plugins {
+    checkstyle
+}
+
+checkstyle {
+    configFile = rootProject.file("config/checkstyle/checkstyle.xml")
+}
+
+tasks.withType<Checkstyle>().configureEach {
+    reports {
+        xml.required.set(false)
+        html.required.set(true)
+        html.stylesheet = resources.text.fromFile("$rootDir/config/checkstyle/checkstyle.xsl")
+    }
+}
diff --git a/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts
new file mode 100644
index 0000000000..5f896044fc
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts
@@ -0,0 +1,46 @@
+import com.diffplug.gradle.spotless.SpotlessExtension
+import com.diffplug.spotless.FormatterFunc
+import com.google.googlejavaformat.java.Formatter
+import com.google.googlejavaformat.java.JavaFormatterOptions
+import java.io.Serializable
+
+plugins {
+    id("com.diffplug.spotless")
+}
+
+configure<SpotlessExtension> {
+    // We run the check separately on CI, so don't run this by default
+    isEnforceCheck = false
+
+    java {
+        licenseHeaderFile(rootProject.file("config/spotless/spotless.header"))
+
+        // Not using stock googleJavaFormat due to missing options like reorderModifiers
+        // Also, using the Serializable interface to work around bug in spotless 7.0.0
+        // https://github.com/diffplug/spotless/issues/2387
+        custom("google-java-format", object : Serializable, FormatterFunc {
+            override fun apply(input: String): String {
+                val formatterOptions = JavaFormatterOptions.builder()
+                    .style(JavaFormatterOptions.Style.AOSP)
+                    .reorderModifiers(true)
+                    .formatJavadoc(false)
+                    .build()
+
+                return Formatter(formatterOptions).formatSource(input)
+            }
+        })
+
+        toggleOffOn()
+    }
+
+    format("misc") {
+        target(
+            "*.gradle",
+            "*.gradle.kts",
+            ".gitignore",
+        )
+        targetExclude("**/build/")
+        trimTrailingWhitespace()
+    }
+}
+
diff --git a/buildSrc/src/main/kotlin/mockito.root.releasing-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.root.releasing-conventions.gradle.kts
new file mode 100644
index 0000000000..b7d77b024a
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.root.releasing-conventions.gradle.kts
@@ -0,0 +1,75 @@
+plugins {
+    id("org.shipkit.shipkit-auto-version")
+    id("org.shipkit.shipkit-changelog")
+    id("org.shipkit.shipkit-github-release")
+
+    id("io.github.gradle-nexus.publish-plugin")
+}
+
+val isSnapshot = version.toString().endsWith("SNAPSHOT")
+val githubTokenProvider = providers.environmentVariable("GITHUB_TOKEN").orElse("")
+val githubShaProvider = providers.environmentVariable("GITHUB_SHA").orElse("")
+val mockitoRepository = "mockito/mockito"
+
+tasks {
+    generateChangelog {
+        githubToken = githubTokenProvider.get()
+        previousRevision = project.ext["shipkit-auto-version.previous-tag"].toString()
+        repository = mockitoRepository
+    }
+
+    githubRelease {
+        enabled = !isSnapshot
+        dependsOn(generateChangelog)
+        githubToken = githubTokenProvider.get()
+        newTagRevision = githubShaProvider.get()
+        repository = mockitoRepository
+        changelog = generateChangelog.get().outputFile
+    }
+
+    closeAndReleaseStagingRepositories {
+        enabled = !isSnapshot
+    }
+
+    val releaseSummary by registering {
+        doLast {
+            if (isSnapshot) {
+                logger.lifecycle(
+                    """
+                    RELEASE SUMMARY
+                      SNAPSHOTS released to: https://s01.oss.sonatype.org/content/repositories/snapshots/org/mockito/mockito-core
+                      Release to Maven Central: SKIPPED FOR SNAPSHOTS
+                      Github releases: SKIPPED FOR SNAPSHOTS
+                    """.trimIndent()
+                )
+            } else {
+                logger.lifecycle(
+                    """
+                    RELEASE SUMMARY
+                      Release to Maven Central (available in few hours): https://repo1.maven.org/maven2/org/mockito/mockito-core/
+                      Github releases: https://github.com/mockito/mockito/releases
+                    """.trimIndent()
+                )
+            }
+        }
+    }
+}
+
+nexusPublishing {
+    packageGroup = "org.mockito"
+    repositoryDescription = provider { "Mockito ${project.version}" }
+
+    repositories {
+        if (!providers.environmentVariable("NEXUS_TOKEN_PWD").orNull.isNullOrBlank()) {
+            sonatype {
+                // Publishing to: https://s01.oss.sonatype.org (faster instance)
+                nexusUrl = uri("https://s01.oss.sonatype.org/service/local/")
+                snapshotRepositoryUrl = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
+
+                username = providers.environmentVariable("NEXUS_TOKEN_USER")
+                password = providers.environmentVariable("NEXUS_TOKEN_PWD")
+            }
+        }
+    }
+}
+
diff --git a/buildSrc/src/main/kotlin/mockito.test-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.test-conventions.gradle.kts
new file mode 100644
index 0000000000..1c1541d031
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.test-conventions.gradle.kts
@@ -0,0 +1,33 @@
+import com.adarshr.gradle.testlogger.theme.ThemeType
+
+plugins {
+    id("mockito.java-conventions")
+    id("com.adarshr.test-logger")
+    id("mockito.quality-spotless-conventions")
+    id("mockito.license-conventions")
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+testlogger {
+    theme = ThemeType.MOCHA_PARALLEL
+    isShowPassed = false
+}
+
+tasks {
+    // Configure the main "test" task for `java` only projects.
+    plugins.withType(JavaPlugin::class) {
+        named<Test>("test") {
+            // This ignores classes with JUnit annotations not ending with "Test"
+            include("**/*Test.class")
+
+            if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)
+                && providers.environmentVariable("MEMBER_ACCESSOR").orNull == "member-accessor-reflection") {
+                jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED")
+            }
+        }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/mockito.test-jfr-profiling-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.test-jfr-profiling-conventions.gradle.kts
new file mode 100644
index 0000000000..d3edda47a5
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.test-jfr-profiling-conventions.gradle.kts
@@ -0,0 +1,34 @@
+plugins.withType(JavaPlugin::class) {
+    tasks.withType<Test>().configureEach {
+        val taskName = name
+        /*
+         * If the gradle option -Pjfr is set during test execution, JFR will be activated for that execution.
+         */
+        if (project.extensions.extraProperties.has("jfr")) {
+            val jfrDir = "build/jfr"
+            val jfrConfigFile = rootProject.file("config/jfr/jfr_config.jfc")
+            val jfrFile = project.file("$jfrDir/${taskName}_Exec.jfr")
+
+            jvmArgs(
+                //https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html
+                // Search for -XX:FlightRecorderOptions and -XX:StartFlightRecording for more details in the documentation
+                "-XX:+UnlockDiagnosticVMOptions",
+                "-XX:+DebugNonSafepoints",
+                "-XX:FlightRecorderOptions=stackdepth=1024",
+                "-XX:StartFlightRecording=name=TestExec_$taskName,disk=true,maxsize=1g,dumponexit=true,filename=$jfrFile,settings=${jfrConfigFile.absolutePath}")
+
+            //We do not want to be UP-TO-DATE, if we are doing a Java Flight Recording. We always want a new recording.
+            outputs.upToDateWhen { false }
+
+            doFirst {
+                //Ensure that the jfr folder exists, otherwise the Java process start will fail.
+                project.file(jfrDir).mkdirs()
+            }
+
+            doLast{
+                logger.lifecycle("Java Flight Recording was written to: $jfrFile")
+            }
+        }
+    }
+}
+
diff --git a/buildSrc/src/main/kotlin/mockito.test-launcher-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.test-launcher-conventions.gradle.kts
new file mode 100644
index 0000000000..8c4d6c487f
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.test-launcher-conventions.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    `jvm-toolchains`
+}
+
+tasks.withType<Test> {
+    // Apply the CI test launcher configuration to any test tasks.
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = providers
+            .gradleProperty("mockito.test.java")
+            .map {
+                if (it == "auto") {
+                    JavaLanguageVersion.of(JavaVersion.current().majorVersion)
+                } else {
+                    JavaLanguageVersion.of(it)
+                }
+            }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/mockito.test-retry-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.test-retry-conventions.gradle.kts
new file mode 100644
index 0000000000..10ea2b2390
--- /dev/null
+++ b/buildSrc/src/main/kotlin/mockito.test-retry-conventions.gradle.kts
@@ -0,0 +1,86 @@
+import java.util.concurrent.ConcurrentSkipListSet
+
+plugins {
+    java
+}
+
+/*
+    Plugin that retries failed tests.
+    Mockito has concurrent API and those tests and inherently flaky.
+    We decided to use retries to stabilize (conscious team choice)
+    Long term, we can evolve retry-test script plugin to a binary plugin or make it more robust
+
+    Plugin adds 'retryTest' task that runs tests that failed during the execution of 'test' task.
+*/
+tasks {
+    val retryTest by registering(Test::class) {
+        description = "Retries failed tests (if present)"
+        outputs.upToDateWhen { false } //we want to always run flaky tests because they are flaky
+        isEnabled = false // toggled on by `test` task if there are failed tests
+
+        // re-use same parameters
+        testClassesDirs = test.map { it.testClassesDirs }.get()
+        classpath = test.map { it.classpath }.get()
+        isScanForTestClasses = test.map { it.isScanForTestClasses }.get()
+        include(test.map { it.includes }.get())
+
+        // logging handled by test-logger plugin
+
+        doFirst {
+            logger.lifecycle("[retryTest] retrying ${filter.includePatterns.size} test(s).")
+        }
+        addTestListener(object : TestListener {
+            override fun beforeSuite(suite: TestDescriptor) {}
+            override fun beforeTest(testDescriptor: TestDescriptor) {}
+            override fun afterTest(testDescriptor: TestDescriptor, result: TestResult) {}
+            override fun afterSuite(descriptor: TestDescriptor, result: TestResult) {
+                descriptor.parent ?: return  // root
+                if (result.failedTestCount > 0) {
+                    logger.lifecycle("\n[retryTest] retried ${filter.includePatterns.size} test(s), $result.failedTestCount still failed.")
+                } else {
+                    logger.lifecycle("\n[retryTest] ${filter.includePatterns.size} test(s) were retried successfully:\n  ${filter.includePatterns.joinToString("\n  ")}")
+                }
+            }
+        })
+    }
+
+    test {
+        finalizedBy(retryTest)
+        val failedTests = ConcurrentSkipListSet<String>()
+
+        addTestListener(object : TestListener {
+            override fun beforeSuite(suite: TestDescriptor) {}
+            override fun beforeTest(testDescriptor: TestDescriptor) {}
+
+            override fun afterTest(testDescriptor: TestDescriptor, result: TestResult) {
+                if (!testDescriptor.isComposite /* e.g. is not a parent */ && result.failedTestCount > 0) {
+                    //adding fully qualified test name, dropping "()" from the method name
+                    failedTests.add("${testDescriptor.className}.${testDescriptor.name.replace("\\(\\)", "")}")
+                }
+            }
+
+            override fun afterSuite(descriptor: TestDescriptor, result: TestResult) {
+                descriptor.parent ?: return  // root
+                val failuresReport = layout.buildDirectory.file("$name-failures.txt").get().asFile
+                val deletion = !failuresReport.exists() || failuresReport.delete()
+
+                val reportPath = rootProject.relativePath(failuresReport)
+                if (!deletion) {
+                    throw GradleException("Problems deleting failures file: $reportPath. Please delete manually and retry.")
+                }
+
+                if (failedTests.isNotEmpty()) {
+                    failuresReport.writeText(failedTests.joinToString("\n"))
+                    logger.lifecycle("\n[retryTest] wrote ${failedTests.size} failed tests to: $reportPath")
+                    logger.info("[retryTest] all failed tests:\n  ${failedTests.joinToString("\n  ")}")
+                    retryTest.get().isEnabled = true
+                    retryTest.get().filter.setIncludePatterns(*failedTests.toTypedArray())
+                    ignoreFailures = true
+                } else {
+                    logger.info("\n[retryTest] There are no failed tests, '$reportPath' file was deleted (if it existed).")
+                }
+            }
+        })
+    }
+}
+
diff --git a/check_reproducibility.sh b/check_reproducibility.sh
new file mode 100755
index 0000000000..d4aab96f6c
--- /dev/null
+++ b/check_reproducibility.sh
@@ -0,0 +1,26 @@
+#!/bin/bash -e
+
+# This script is taken from https://github.com/junit-team/junit5/pull/2217
+
+rm -rf checksums/
+mkdir checksums/
+
+export SOURCE_DATE_EPOCH=$(date +%s)
+
+function calculate_checksums() {
+    OUTPUT=checksums/$1
+
+    ./gradlew --no-build-cache clean assemble
+
+    find ./build -name '*.jar' \
+        | grep '/build/libs/' \
+        | grep --invert-match 'javadoc' \
+        | sort \
+        | xargs sha256sum > ${OUTPUT}
+}
+
+
+calculate_checksums checksums-1.txt
+calculate_checksums checksums-2.txt
+
+diff checksums/checksums-1.txt checksums/checksums-2.txt
diff --git a/config/checkstyle/checkstyle.xml b/config/checkstyle/checkstyle.xml
index 2a5094bcda..c38f152429 100644
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <!DOCTYPE module PUBLIC
     "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
-    "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+    "https://checkstyle.org/dtds/configuration_1_2.dtd">
 <module name="Checker">
     <!--
      Different editors and IDEs may insert or remove trailing
@@ -16,6 +16,9 @@
 
      See also https://github.com/mockito/mockito/issues/903
      -->
+    <module name="BeforeExecutionExclusionFileFilter">
+        <property name="fileNamePattern" value="module\-info\.java$" />
+    </module>
     <module name="NewlineAtEndOfFile"/>
     <module name="RegexpSingleline">
         <!-- \s matches whitespace character, $ matches end of line. -->
@@ -28,8 +31,7 @@
         </module>
     </module>
     <module name="RegexpHeader">
-        <property name="headerFile" value="config/checkstyle/java.header"/>
+        <property name="headerFile" value="${config_loc}/java.header"/>
         <property name="fileExtensions" value="java"/>
     </module>
 </module>
-
diff --git a/config/javadoc/jdk-package-list/element-list b/config/javadoc/jdk-package-list/element-list
new file mode 100644
index 0000000000..4cfabf8fdf
--- /dev/null
+++ b/config/javadoc/jdk-package-list/element-list
@@ -0,0 +1,282 @@
+module:java.base
+java.io
+java.lang
+java.lang.annotation
+java.lang.invoke
+java.lang.module
+java.lang.ref
+java.lang.reflect
+java.math
+java.net
+java.net.spi
+java.nio
+java.nio.channels
+java.nio.channels.spi
+java.nio.charset
+java.nio.charset.spi
+java.nio.file
+java.nio.file.attribute
+java.nio.file.spi
+java.security
+java.security.acl
+java.security.cert
+java.security.interfaces
+java.security.spec
+java.text
+java.text.spi
+java.time
+java.time.chrono
+java.time.format
+java.time.temporal
+java.time.zone
+java.util
+java.util.concurrent
+java.util.concurrent.atomic
+java.util.concurrent.locks
+java.util.function
+java.util.jar
+java.util.regex
+java.util.spi
+java.util.stream
+java.util.zip
+javax.crypto
+javax.crypto.interfaces
+javax.crypto.spec
+javax.net
+javax.net.ssl
+javax.security.auth
+javax.security.auth.callback
+javax.security.auth.login
+javax.security.auth.spi
+javax.security.auth.x500
+javax.security.cert
+module:java.compiler
+javax.annotation.processing
+javax.lang.model
+javax.lang.model.element
+javax.lang.model.type
+javax.lang.model.util
+javax.tools
+module:java.datatransfer
+java.awt.datatransfer
+module:java.desktop
+java.applet
+java.awt
+java.awt.color
+java.awt.desktop
+java.awt.dnd
+java.awt.event
+java.awt.font
+java.awt.geom
+java.awt.im
+java.awt.im.spi
+java.awt.image
+java.awt.image.renderable
+java.awt.print
+java.beans
+java.beans.beancontext
+javax.accessibility
+javax.imageio
+javax.imageio.event
+javax.imageio.metadata
+javax.imageio.plugins.bmp
+javax.imageio.plugins.jpeg
+javax.imageio.plugins.tiff
+javax.imageio.spi
+javax.imageio.stream
+javax.print
+javax.print.attribute
+javax.print.attribute.standard
+javax.print.event
+javax.sound.midi
+javax.sound.midi.spi
+javax.sound.sampled
+javax.sound.sampled.spi
+javax.swing
+javax.swing.border
+javax.swing.colorchooser
+javax.swing.event
+javax.swing.filechooser
+javax.swing.plaf
+javax.swing.plaf.basic
+javax.swing.plaf.metal
+javax.swing.plaf.multi
+javax.swing.plaf.nimbus
+javax.swing.plaf.synth
+javax.swing.table
+javax.swing.text
+javax.swing.text.html
+javax.swing.text.html.parser
+javax.swing.text.rtf
+javax.swing.tree
+javax.swing.undo
+module:java.instrument
+java.lang.instrument
+module:java.logging
+java.util.logging
+module:java.management
+java.lang.management
+javax.management
+javax.management.loading
+javax.management.modelmbean
+javax.management.monitor
+javax.management.openmbean
+javax.management.relation
+javax.management.remote
+javax.management.timer
+module:java.management.rmi
+javax.management.remote.rmi
+module:java.naming
+javax.naming
+javax.naming.directory
+javax.naming.event
+javax.naming.ldap
+javax.naming.spi
+module:java.net.http
+java.net.http
+module:java.prefs
+java.util.prefs
+module:java.rmi
+java.rmi
+java.rmi.activation
+java.rmi.dgc
+java.rmi.registry
+java.rmi.server
+javax.rmi.ssl
+module:java.scripting
+javax.script
+module:java.se
+module:java.security.jgss
+javax.security.auth.kerberos
+org.ietf.jgss
+module:java.security.sasl
+javax.security.sasl
+module:java.smartcardio
+javax.smartcardio
+module:java.sql
+java.sql
+javax.sql
+module:java.sql.rowset
+javax.sql.rowset
+javax.sql.rowset.serial
+javax.sql.rowset.spi
+module:java.transaction.xa
+javax.transaction.xa
+module:java.xml
+javax.xml
+javax.xml.catalog
+javax.xml.datatype
+javax.xml.namespace
+javax.xml.parsers
+javax.xml.stream
+javax.xml.stream.events
+javax.xml.stream.util
+javax.xml.transform
+javax.xml.transform.dom
+javax.xml.transform.sax
+javax.xml.transform.stax
+javax.xml.transform.stream
+javax.xml.validation
+javax.xml.xpath
+org.w3c.dom
+org.w3c.dom.bootstrap
+org.w3c.dom.events
+org.w3c.dom.ls
+org.w3c.dom.ranges
+org.w3c.dom.traversal
+org.w3c.dom.views
+org.xml.sax
+org.xml.sax.ext
+org.xml.sax.helpers
+module:java.xml.crypto
+javax.xml.crypto
+javax.xml.crypto.dom
+javax.xml.crypto.dsig
+javax.xml.crypto.dsig.dom
+javax.xml.crypto.dsig.keyinfo
+javax.xml.crypto.dsig.spec
+module:jdk.accessibility
+com.sun.java.accessibility.util
+module:jdk.attach
+com.sun.tools.attach
+com.sun.tools.attach.spi
+module:jdk.charsets
+module:jdk.compiler
+com.sun.source.doctree
+com.sun.source.tree
+com.sun.source.util
+com.sun.tools.javac
+module:jdk.crypto.cryptoki
+module:jdk.crypto.ec
+module:jdk.dynalink
+jdk.dynalink
+jdk.dynalink.beans
+jdk.dynalink.linker
+jdk.dynalink.linker.support
+jdk.dynalink.support
+module:jdk.editpad
+module:jdk.hotspot.agent
+module:jdk.httpserver
+com.sun.net.httpserver
+com.sun.net.httpserver.spi
+module:jdk.jartool
+com.sun.jarsigner
+jdk.security.jarsigner
+module:jdk.javadoc
+com.sun.javadoc
+com.sun.tools.javadoc
+jdk.javadoc.doclet
+module:jdk.jcmd
+module:jdk.jconsole
+com.sun.tools.jconsole
+module:jdk.jdeps
+module:jdk.jdi
+com.sun.jdi
+com.sun.jdi.connect
+com.sun.jdi.connect.spi
+com.sun.jdi.event
+com.sun.jdi.request
+module:jdk.jdwp.agent
+module:jdk.jfr
+jdk.jfr
+jdk.jfr.consumer
+module:jdk.jlink
+module:jdk.jshell
+jdk.jshell
+jdk.jshell.execution
+jdk.jshell.spi
+jdk.jshell.tool
+module:jdk.jsobject
+netscape.javascript
+module:jdk.jstatd
+module:jdk.localedata
+module:jdk.management
+com.sun.management
+module:jdk.management.agent
+module:jdk.management.jfr
+jdk.management.jfr
+module:jdk.naming.dns
+module:jdk.naming.rmi
+module:jdk.net
+jdk.net
+jdk.nio
+module:jdk.pack
+module:jdk.rmic
+module:jdk.scripting.nashorn
+jdk.nashorn.api.scripting
+jdk.nashorn.api.tree
+module:jdk.sctp
+com.sun.nio.sctp
+module:jdk.security.auth
+com.sun.security.auth
+com.sun.security.auth.callback
+com.sun.security.auth.login
+com.sun.security.auth.module
+module:jdk.security.jgss
+com.sun.security.jgss
+module:jdk.xml.dom
+org.w3c.dom.css
+org.w3c.dom.html
+org.w3c.dom.stylesheets
+org.w3c.dom.xpath
+module:jdk.zipfs
diff --git a/src/javadoc/favicon.ico b/config/javadoc/resources/favicon.ico
similarity index 100%
rename from src/javadoc/favicon.ico
rename to config/javadoc/resources/favicon.ico
diff --git a/config/javadoc/resources/mockito-theme.css b/config/javadoc/resources/mockito-theme.css
new file mode 100644
index 0000000000..69f4ab5add
--- /dev/null
+++ b/config/javadoc/resources/mockito-theme.css
@@ -0,0 +1,13 @@
+:root {
+    /* Text colors for body and block elements */
+    --body-text-color: #333333;
+    /* Colors for navigation bar and table captions */
+    --navbar-background-color: #474747;
+    /* Background and text colors for selected tabs and navigation items */
+    --selected-background-color: #EAF9DD;
+    /* Text color for page title */
+    --title-color: #333333;
+    /* Text colors for links */
+    --link-color: #333333;
+    --link-color-active: #82a54d;
+}
diff --git a/src/javadoc/org/mockito/logo.png b/config/javadoc/resources/org/mockito/logo.png
similarity index 100%
rename from src/javadoc/org/mockito/logo.png
rename to config/javadoc/resources/org/mockito/logo.png
diff --git a/src/javadoc/org/mockito/logo@2x.png b/config/javadoc/resources/org/mockito/logo@2x.png
similarity index 100%
rename from src/javadoc/org/mockito/logo@2x.png
rename to config/javadoc/resources/org/mockito/logo@2x.png
diff --git a/config/jfr/jfr_config.jfc b/config/jfr/jfr_config.jfc
new file mode 100644
index 0000000000..eae0a621e1
--- /dev/null
+++ b/config/jfr/jfr_config.jfc
@@ -0,0 +1,836 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration version="2.0" label="Mockito_JFR_Config" description="Profiling for test execution" provider="Mockito">
+
+    <event name="jdk.ThreadAllocationStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.ClassLoadingStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">1000 ms</setting>
+    </event>
+
+    <event name="jdk.ClassLoaderStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.JavaThreadStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">1000 ms</setting>
+    </event>
+
+    <event name="jdk.SymbolTableStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.StringTableStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.PlaceholderTableStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.LoaderConstraintsTableStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.ProtectionDomainCacheTableStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.ThreadStart">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ThreadEnd">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.ThreadSleep">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="locking-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.ThreadPark">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="locking-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.JavaMonitorEnter">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="locking-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.JavaMonitorWait">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="locking-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.JavaMonitorInflate">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="locking-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.SyncOnValueBasedClass">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.BiasedLockRevocation">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.BiasedLockSelfRevocation">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.BiasedLockClassRevocation">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ReservedStackActivation">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ClassLoad">
+      <setting name="enabled" control="class-loading">false</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ClassDefine">
+      <setting name="enabled" control="class-loading">false</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.RedefineClasses">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.RetransformClasses">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ClassRedefinition">
+      <setting name="enabled" control="class-loading">true</setting>
+    </event>
+
+    <event name="jdk.ClassUnload">
+      <setting name="enabled" control="class-loading">false</setting>
+    </event>
+
+    <event name="jdk.JVMInformation">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.InitialSystemProperty">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.ExecutionSample">
+      <setting name="enabled" control="method-sampling-enabled">true</setting>
+      <setting name="period" control="method-sampling-java-interval">2 ms</setting>
+    </event>
+
+    <event name="jdk.NativeMethodSample">
+      <setting name="enabled" control="method-sampling-enabled">true</setting>
+      <setting name="period" control="method-sampling-native-interval">20 ms</setting>
+    </event>
+
+    <event name="jdk.SafepointBegin">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.SafepointStateSynchronization">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.SafepointCleanup">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.SafepointCleanupTask">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.SafepointEnd">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ExecuteVMOperation">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.Shutdown">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ThreadDump">
+      <setting name="enabled" control="thread-dump-enabled">true</setting>
+      <setting name="period" control="thread-dump">10 s</setting>
+    </event>
+
+    <event name="jdk.IntFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.UnsignedIntFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.LongFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.UnsignedLongFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.DoubleFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.BooleanFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.StringFlag">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.IntFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.UnsignedIntFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.LongFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.UnsignedLongFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.DoubleFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.BooleanFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.StringFlagChanged">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.ObjectCount">
+      <setting name="enabled" control="gc-enabled-all">false</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.GCConfiguration">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.GCHeapConfiguration">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.YoungGenerationConfiguration">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.GCTLABConfiguration">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.GCSurvivorConfiguration">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.ObjectCountAfterGC">
+      <setting name="enabled">false</setting>
+    </event>
+
+    <event name="jdk.GCHeapSummary">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.PSHeapSummary">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.G1HeapSummary">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.MetaspaceSummary">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.MetaspaceGCThreshold">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.MetaspaceAllocationFailure">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.MetaspaceOOM">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.MetaspaceChunkFreeListSummary">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.GarbageCollection">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.SystemGC">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ParallelOldGarbageCollection">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.YoungGarbageCollection">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.OldGarbageCollection">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.G1GarbageCollection">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhasePause">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhasePauseLevel1">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhasePauseLevel2">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhasePauseLevel3">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhasePauseLevel4">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhaseConcurrent">
+      <setting name="enabled" control="gc-enabled-high">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCPhaseConcurrentLevel1">
+      <setting name="enabled" control="gc-enabled-high">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.GCReferenceStatistics">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.PromotionFailed">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.EvacuationFailed">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.EvacuationInformation">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.G1MMU">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.G1EvacuationYoungStatistics">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.G1EvacuationOldStatistics">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.GCPhaseParallel">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.G1BasicIHOP">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.G1AdaptiveIHOP">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.PromoteObjectInNewPLAB">
+      <setting name="enabled" control="gc-enabled-high">true</setting>
+    </event>
+
+    <event name="jdk.PromoteObjectOutsidePLAB">
+      <setting name="enabled" control="gc-enabled-high">true</setting>
+    </event>
+
+    <event name="jdk.ConcurrentModeFailure">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.AllocationRequiringGC">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.TenuringDistribution">
+      <setting name="enabled" control="gc-enabled-normal">true</setting>
+    </event>
+
+    <event name="jdk.G1HeapRegionInformation">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.G1HeapRegionTypeChange">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+    </event>
+
+    <event name="jdk.ShenandoahHeapRegionInformation">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.ShenandoahHeapRegionStateChange">
+      <setting name="enabled" control="gc-enabled-high">false</setting>
+    </event>
+
+    <event name="jdk.OldObjectSample">
+      <setting name="enabled" control="old-objects-enabled">true</setting>
+      <setting name="stackTrace" control="old-objects-stack-trace">true</setting>
+      <setting name="cutoff" control="old-objects-cutoff">0 ns</setting>
+    </event>
+
+    <event name="jdk.CompilerConfiguration">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.CompilerStatistics">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">1000 ms</setting>
+    </event>
+
+    <event name="jdk.Compilation">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="threshold" control="compiler-compilation-threshold">100 ms</setting>
+    </event>
+
+    <event name="jdk.CompilerPhase">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="threshold" control="compiler-phase-threshold">10 s</setting>
+    </event>
+
+    <event name="jdk.CompilationFailure">
+      <setting name="enabled" control="compiler-enabled-failure">true</setting>
+    </event>
+
+    <event name="jdk.CompilerInlining">
+      <setting name="enabled" control="compiler-enabled-failure">true</setting>
+    </event>
+
+    <event name="jdk.JITRestart">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+    </event>
+
+    <event name="jdk.CodeSweeperConfiguration">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.CodeSweeperStatistics">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.SweepCodeCache">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="threshold" control="compiler-sweeper-threshold">100 ms</setting>
+    </event>
+
+    <event name="jdk.CodeCacheConfiguration">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.CodeCacheStatistics">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.CodeCacheFull">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+    </event>
+
+    <event name="jdk.OSInformation">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.VirtualizationInformation">
+     <setting name="enabled">true</setting>
+     <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.ContainerConfiguration">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.ContainerCPUUsage">
+      <setting name="enabled">true</setting>
+      <setting name="period">30 s</setting>
+    </event>
+
+    <event name="jdk.ContainerCPUThrottling">
+      <setting name="enabled">true</setting>
+      <setting name="period">30 s</setting>
+    </event>
+
+    <event name="jdk.ContainerMemoryUsage">
+      <setting name="enabled">true</setting>
+      <setting name="period">30 s</setting>
+    </event>
+
+    <event name="jdk.ContainerIOUsage">
+      <setting name="enabled">true</setting>
+      <setting name="period">30 s</setting>
+    </event>
+
+    <event name="jdk.CPUInformation">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.ThreadContextSwitchRate">
+      <setting name="enabled" control="compiler-enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.CPULoad">
+      <setting name="enabled">true</setting>
+      <setting name="period">1000 ms</setting>
+    </event>
+
+    <event name="jdk.ThreadCPULoad">
+      <setting name="enabled">true</setting>
+      <setting name="period">10 s</setting>
+    </event>
+
+    <event name="jdk.CPUTimeStampCounter">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.SystemProcess">
+      <setting name="enabled">true</setting>
+      <setting name="period">endChunk</setting>
+    </event>
+
+    <event name="jdk.ProcessStart">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.NetworkUtilization">
+      <setting name="enabled">true</setting>
+      <setting name="period">5 s</setting>
+    </event>
+
+    <event name="jdk.InitialEnvironmentVariable">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.PhysicalMemory">
+      <setting name="enabled">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.ObjectAllocationInNewTLAB">
+      <setting name="enabled" control="gc-enabled-high">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ObjectAllocationOutsideTLAB">
+      <setting name="enabled" control="gc-enabled-high">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ObjectAllocationSample">
+      <setting name="enabled" control="object-allocation-enabled">true</setting>
+      <setting name="throttle" control="allocation-profiling">1000/s</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.NativeLibrary">
+      <setting name="enabled">true</setting>
+      <setting name="period">everyChunk</setting>
+    </event>
+
+    <event name="jdk.ModuleRequire">
+      <setting name="enabled">true</setting>
+      <setting name="period">endChunk</setting>
+    </event>
+
+    <event name="jdk.ModuleExport">
+      <setting name="enabled">true</setting>
+      <setting name="period">endChunk</setting>
+    </event>
+
+    <event name="jdk.FileForce">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="file-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.FileRead">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="file-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.FileWrite">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="file-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.SocketRead">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="socket-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.SocketWrite">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold" control="socket-threshold">10 ms</setting>
+    </event>
+
+    <event name="jdk.Deserialization">
+       <setting name="enabled">false</setting>
+       <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.InitialSecurityProperty">
+      <setting name="enabled">true</setting>
+      <setting name="period">beginChunk</setting>
+    </event>
+
+    <event name="jdk.SecurityPropertyModification">
+       <setting name="enabled">false</setting>
+       <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.SecurityProviderService">
+       <setting name="enabled">false</setting>
+       <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.TLSHandshake">
+      <setting name="enabled">false</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.X509Validation">
+       <setting name="enabled">false</setting>
+       <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.X509Certificate">
+       <setting name="enabled">false</setting>
+       <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.JavaExceptionThrow">
+      <setting name="enabled" control="enable-exceptions">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.JavaErrorThrow">
+      <setting name="enabled" control="enable-errors">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.ExceptionStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">1000 ms</setting>
+    </event>
+
+    <event name="jdk.ActiveRecording">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.ActiveSetting">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.Flush">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ns</setting>
+    </event>
+
+    <event name="jdk.DataLoss">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.DumpReason">
+      <setting name="enabled">true</setting>
+    </event>
+
+    <event name="jdk.ZAllocationStall">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZPageAllocation">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+      <setting name="threshold">1 ms</setting>
+    </event>
+
+    <event name="jdk.ZRelocationSet">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZRelocationSetGroup">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZStatisticsCounter">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZStatisticsSampler">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZThreadPhase">
+      <setting name="enabled">false</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZUncommit">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.ZUnmap">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ms</setting>
+    </event>
+
+    <event name="jdk.Deoptimization">
+      <setting name="enabled">true</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.HeapDump">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">0 ns</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+    <event name="jdk.DirectBufferStatistics">
+      <setting name="enabled">true</setting>
+      <setting name="period">5 s</setting>
+    </event>
+
+    <event name="jdk.GCLocker">
+      <setting name="enabled">true</setting>
+      <setting name="threshold">100 ms</setting>
+      <setting name="stackTrace">true</setting>
+    </event>
+
+</configuration>
diff --git a/doc/release-notes/official.md b/doc/release-notes/official.md
index a9d866e818..edae708fe3 100644
--- a/doc/release-notes/official.md
+++ b/doc/release-notes/official.md
@@ -1,4 +1,212 @@
-<sup><sup>*Release notes were automatically generated by [Shipkit](http://shipkit.org/)*</sup></sup>
+# Deprecated
+
+As of Oct 2020, this file is no longer updated.
+The most current Mockito changelog is automatically generated to [GitHub Releases](https://github.com/mockito/mockito/releases).
+The generation is implemented using https://shipkit.org.
+
+# Old release notes
+
+#### 3.6.0
+ - 2020-10-27 - [7 commits](https://github.com/mockito/mockito/compare/v3.5.15...v3.6.0) by [Szczepan Faber](https://github.com/mockitoguy) (4), [shipkit-org](https://github.com/shipkit-org) (2), [Tim van der Lippe](https://github.com/TimvdLippe) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.6.0-green.svg)](https://bintray.com/mockito/maven/mockito/3.6.0)
+ - Retry the release [(#2078)](https://github.com/mockito/mockito/pull/2078)
+ - Retry 3.6.0 release [(#2077)](https://github.com/mockito/mockito/pull/2077)
+
+#### 3.5.15
+ - 2020-10-19 - [4 commits](https://github.com/mockito/mockito/compare/v3.5.14...v3.5.15) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.15-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.15)
+ - Mock resolver plugin [(#2042)](https://github.com/mockito/mockito/pull/2042)
+
+#### 3.5.14
+ - 2020-10-17 - [2 commits](https://github.com/mockito/mockito/compare/v3.5.13...v3.5.14) by [Marcono1234](https://github.com/Marcono1234) (1), [shestee](https://github.com/shestee) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.14-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.5.14)
+ - Fixes #2061: ArgumentMatcher error messages use lambda class names [(#2071)](https://github.com/mockito/mockito/pull/2071)
+ - Fixed typo in osgi.gradle [(#2070)](https://github.com/mockito/mockito/pull/2070)
+ - Lambda used as ArgumentMatcher causes decamelized lambda name to appear in error message [(#2061)](https://github.com/mockito/mockito/issues/2061)
+
+#### 3.5.13
+ - 2020-09-24 - [1 commit](https://github.com/mockito/mockito/compare/v3.5.12...v3.5.13) by [Sinan Kozak](https://github.com/kozaxinan) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.13-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.13)
+ - Use single version for strictly in mockito-android [(#2053)](https://github.com/mockito/mockito/pull/2053)
+
+#### 3.5.12
+ - 2020-09-18 - [1 commit](https://github.com/mockito/mockito/compare/v3.5.11...v3.5.12) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.12-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.5.12)
+ - Update Byte Buddy. [(#2050)](https://github.com/mockito/mockito/pull/2050)
+
+#### 3.5.11
+ - 2020-09-17 - [2 commits](https://github.com/mockito/mockito/compare/v3.5.10...v3.5.11) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.11-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.11)
+ - Do not exclude synthetic constructors from instrumentation. Fixes #2040. [(#2046)](https://github.com/mockito/mockito/pull/2046)
+ - Mockito.spy(Activity).getBaseContext() returns null on Robolectric 4.4 and Java8 [(#2040)](https://github.com/mockito/mockito/issues/2040)
+
+#### 3.5.10
+ - 2020-09-03 - [2 commits](https://github.com/mockito/mockito/compare/v3.5.9...v3.5.10) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.10-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.10)
+ - Escape mock during method dispatch on mock to avoid premature garbage collection. [(#2034)](https://github.com/mockito/mockito/pull/2034)
+ - Exception "The mock object was garbage collected." [(#1802)](https://github.com/mockito/mockito/issues/1802)
+
+#### 3.5.9
+ - 2020-09-01 - [1 commit](https://github.com/mockito/mockito/compare/v3.5.8...v3.5.9) by [Sinan Kozak](https://github.com/kozaxinan) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.9-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.9)
+ - Fixes #2007 : Downgrade objenesis version for mockito-android [(#2024)](https://github.com/mockito/mockito/pull/2024)
+ - Android instrumentation test packaging fails for mockito-android 3.5.0 with minSdk < 26 [(#2007)](https://github.com/mockito/mockito/issues/2007)
+
+#### 3.5.8
+ - 2020-08-27 - [1 commit](https://github.com/mockito/mockito/compare/v3.5.7...v3.5.8) by [ahmadmoawad](https://github.com/ahmadmoawad) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.8-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.5.8)
+ - Fix typo in CONTRIBUTING.md and SpyOnInjectedFieldsHandler [(#1994)](https://github.com/mockito/mockito/pull/1994)
+
+#### 3.5.7
+ - 2020-08-25 - [2 commits](https://github.com/mockito/mockito/compare/v3.5.6...v3.5.7) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.7-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.7)
+ - Initializes classes prior to instrumentation to avoid uncontrolled code execution. [(#2023)](https://github.com/mockito/mockito/pull/2023)
+ - Stackoverflow error when upgrading to v3.5.2 [(#2011)](https://github.com/mockito/mockito/issues/2011)
+
+#### 3.5.6
+ - 2020-08-24 - [5 commits](https://github.com/mockito/mockito/compare/v3.5.5...v3.5.6) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.6-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.6)
+ - Only apply argument on illegal module access for inline tests if Java version is at least 9. [(#2022)](https://github.com/mockito/mockito/pull/2022)
+ - Constructor dispatch [(#2021)](https://github.com/mockito/mockito/pull/2021)
+
+#### 3.5.5
+ - 2020-08-22 - [3 commits](https://github.com/mockito/mockito/compare/v3.5.4...v3.5.5) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.5-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.5)
+ - Constructor dispatch [(#2020)](https://github.com/mockito/mockito/pull/2020)
+
+#### 3.5.4
+ - 2020-08-21 - [2 commits](https://github.com/mockito/mockito/compare/v3.5.3...v3.5.4) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.4-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.4)
+ - Only enable mocking of types right before instantiation to avoid circular interception of constructor creation. [(#2017)](https://github.com/mockito/mockito/pull/2017)
+
+#### 3.5.3
+ - 2020-08-20 - [3 commits](https://github.com/mockito/mockito/compare/v3.5.2...v3.5.3) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.3-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.3)
+ - [ci maven-central-release] Constructor dispatch [(#2013)](https://github.com/mockito/mockito/pull/2013)
+ - Constructor not called when using mockito-inline (3.5.x) [(#2012)](https://github.com/mockito/mockito/issues/2012)
+
+#### 3.5.2
+ - 2020-08-18 - [1 commit](https://github.com/mockito/mockito/compare/v3.5.1...v3.5.2) by [Tim van der Lippe](https://github.com/TimvdLippe) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.2-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.2)
+ - No pull requests referenced in commit messages.
+
+#### 3.5.1
+ - 2020-08-18 - [3 commits](https://github.com/mockito/mockito/compare/v3.5.0...v3.5.1) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.1-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.5.1)
+ - Introduce animal sniffer [(#2006)](https://github.com/mockito/mockito/pull/2006)
+
+#### 3.5.0
+ - 2020-08-15 - [9 commits](https://github.com/mockito/mockito/compare/v3.4.8...v3.5.0) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.5.0-green.svg)](https://bintray.com/mockito/maven/mockito/3.5.0)
+ - Pre release 3.5.0 [(#2004)](https://github.com/mockito/mockito/pull/2004)
+
+#### 3.4.8
+ - 2020-08-09 - [1 commit](https://github.com/mockito/mockito/compare/v3.4.7...v3.4.8) by [Erhard Pointl](https://github.com/epeee) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.8-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.4.8)
+ - Update objenesis to 3.1 [(#1998)](https://github.com/mockito/mockito/pull/1998)
+
+#### 3.4.7
+ - 2020-08-05 - [1 commit](https://github.com/mockito/mockito/compare/v3.4.6...v3.4.7) by [Per Lundberg](https://github.com/perlun) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.7-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.4.7)
+ - Mockito.verify(): fix typo in Javadoc [(#1991)](https://github.com/mockito/mockito/pull/1991)
+
+#### 3.4.6
+ - 2020-07-29 - [3 commits](https://github.com/mockito/mockito/compare/v3.4.5...v3.4.6) by [Rafael Winterhalter](https://github.com/raphw) (2), [Valery Yatsynovich](https://github.com/valfirst) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.6-green.svg)](https://bintray.com/mockito/maven/mockito/3.4.6)
+ - [Bugfixes] Do not pass static mocks to regular listener callback. [(#1989)](https://github.com/mockito/mockito/pull/1989)
+ - MockitoJUnitRunner causes NPE when using @Mock on MockedStatic fields [(#1988)](https://github.com/mockito/mockito/issues/1988)
+ - Fixes #1985 : Update README to refer the latest documentation [(#1986)](https://github.com/mockito/mockito/pull/1986)
+ - README should refer the latest available documentation [(#1985)](https://github.com/mockito/mockito/issues/1985)
+
+#### 3.4.5
+ - 2020-07-20 - [2 commits](https://github.com/mockito/mockito/compare/v3.4.4...v3.4.5) by [Erhard Pointl](https://github.com/epeee) (1), [Johnny Lim](https://github.com/izeye) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.5-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.4.5)
+ - Fix typo [(#1984)](https://github.com/mockito/mockito/pull/1984)
+ - Update assertj to 3.16.1 [(#1982)](https://github.com/mockito/mockito/pull/1982)
+
+#### 3.4.4
+ - 2020-07-18 - [2 commits](https://github.com/mockito/mockito/compare/v3.4.3...v3.4.4) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.4-green.svg)](https://bintray.com/mockito/maven/mockito/3.4.4)
+ - Fixes #1855 and #939: improve error message when the inline mock maker cannot be used. [(#1974)](https://github.com/mockito/mockito/pull/1974)
+ - javax.tools.ToolProvider could not be found in InlineByteBuddyMockMaker [(#1855)](https://github.com/mockito/mockito/issues/1855)
+
+#### 3.4.3
+ - 2020-07-17 - [1 commit](https://github.com/mockito/mockito/compare/v3.4.2...v3.4.3) by [Robert Chmielowiec](https://github.com/chmielowiec) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.3-green.svg)](https://bintray.com/mockito/maven/mockito/3.4.3)
+ - Fix Javadoc invalid syntax [(#1978)](https://github.com/mockito/mockito/pull/1978)
+ - Broken documentation [(#1977)](https://github.com/mockito/mockito/issues/1977)
+
+#### 3.4.2
+ - 2020-07-16 - [2 commits](https://github.com/mockito/mockito/compare/v3.4.1...v3.4.2) by [Rafael Winterhalter](https://github.com/raphw) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.2-green.svg)](https://bintray.com/mockito/maven/mockito/3.4.2)
+ - Fixes #1967: Correctly handle mocks with limited life-cycle in listeners. [(#1968)](https://github.com/mockito/mockito/pull/1968)
+ - Static method mocks incompatible with MockitoExtension (NotAMockException) [(#1967)](https://github.com/mockito/mockito/issues/1967)
+
+#### 3.4.1
+ - 2020-07-15 - [1 commit](https://github.com/mockito/mockito/compare/v3.4.0...v3.4.1) by [mickroll](https://github.com/mickroll) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.1-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.4.1)
+ - update dependency to byte buddy version 1.10.13 [(#1973)](https://github.com/mockito/mockito/pull/1973)
+ - Update dependency to byte buddy version 1.10.13 [(#1972)](https://github.com/mockito/mockito/issues/1972)
+
+#### 3.4.0
+ - 2020-07-10 - [19 commits](https://github.com/mockito/mockito/compare/v3.3.12...v3.4.0) by 9 authors - published to [![Bintray](https://img.shields.io/badge/Bintray-3.4.0-green.svg)](https://bintray.com/mockito/maven/mockito/3.4.0)
+ - Commits: [Tim van der Lippe](https://github.com/TimvdLippe) (5), [Erhard Pointl](https://github.com/epeee) (4), [Rafael Winterhalter](https://github.com/raphw) (3), [Eitan Adler](https://github.com/grimreaper) (2), adrianriley (1), akluball (1), [Artem Prigoda](https://github.com/arteam) (1), [Jamie Tanna](https://github.com/jamietanna) (1), [Naoki Takezoe](https://github.com/takezoe) (1)
+ - [Android support] Enable mocking static methods in Mockito [(#1013)](https://github.com/mockito/mockito/issues/1013)
+ - Document using `@Mock` with method parameters [(#1961)](https://github.com/mockito/mockito/pull/1961)
+ - Documentation: `@Mock` on method parameters [(#1960)](https://github.com/mockito/mockito/issues/1960)
+ - Update errorprone gradle plugin to v1.2.1 [(#1958)](https://github.com/mockito/mockito/pull/1958)
+ - Update spotless Travis job name to be more descriptive [(#1957)](https://github.com/mockito/mockito/pull/1957)
+ - Fix a confusing typo in subclassing error message [(#1953)](https://github.com/mockito/mockito/pull/1953)
+ - Update bnd gradle plugin to v5.1.1 [(#1952)](https://github.com/mockito/mockito/pull/1952)
+ - Use errorprone 2.4.0 [(#1951)](https://github.com/mockito/mockito/pull/1951)
+ - Use jacoco v0.8.5 [(#1950)](https://github.com/mockito/mockito/pull/1950)
+ - Fixes #1712 : prepend description to AssertionError thrown in verification [(#1949)](https://github.com/mockito/mockito/pull/1949)
+ - Update gradle 6 [(#1948)](https://github.com/mockito/mockito/pull/1948)
+ - Move spotless check to separate build task [(#1946)](https://github.com/mockito/mockito/pull/1946)
+ - [Travis] Replace JDK 9/10 with 14 [(#1945)](https://github.com/mockito/mockito/pull/1945)
+ - Fixes #1898 : Return mock name from toString method for deep stub mocks [(#1942)](https://github.com/mockito/mockito/pull/1942)
+ - [checkstyle] switch to new DTD [(#1940)](https://github.com/mockito/mockito/pull/1940)
+ - Use google-java-format in spotless [(#1934)](https://github.com/mockito/mockito/pull/1934)
+ - Update report message to use any() instead of anyObject() [(#1931)](https://github.com/mockito/mockito/pull/1931)
+ - [build] bump gradle to latest 5.x release [(#1923)](https://github.com/mockito/mockito/pull/1923)
+ - [build] update gradle-errorprone-plugin to 1.1.0 [(#1908)](https://github.com/mockito/mockito/pull/1908)
+ - RETURNS_DEEP_STUBS override a mock's toString to `null` [(#1898)](https://github.com/mockito/mockito/issues/1898)
+ - "description" not printing when verify args don't match [(#1712)](https://github.com/mockito/mockito/issues/1712)
+
+#### 3.3.12
+ - 2020-05-25 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.11...v3.3.12) by [Vinicius Scheidegger](https://github.com/vinischeidegger) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.12-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.12)
+ - Update javadoc - remove deprecated class [(#1938)](https://github.com/mockito/mockito/pull/1938)
+
+#### 3.3.11
+ - 2020-05-14 - [5 commits](https://github.com/mockito/mockito/compare/v3.3.10...v3.3.11) by [Andrei Silviu Dragnea](https://github.com/andreisilviudragnea) (2), [Szczepan Faber](https://github.com/mockitoguy) (2), [Eitan Adler](https://github.com/grimreaper) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.11-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.11)
+ - JUnit 5 strict stubs check should not suppress the regular test failure [(#1928)](https://github.com/mockito/mockito/pull/1928)
+ - Fix import order [(#1927)](https://github.com/mockito/mockito/pull/1927)
+ - [build] add ben-manes dependency upgrade finder [(#1922)](https://github.com/mockito/mockito/pull/1922)
+
+#### 3.3.10
+ - 2020-04-30 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.9...v3.3.10) by [netbeansuser2019](https://github.com/netbeansuser2019) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.10-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.10)
+ - Update dependencies.gradle [(#1920)](https://github.com/mockito/mockito/pull/1920)
+
+#### 3.3.9
+ - 2020-04-20 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.8...v3.3.9) by [dean-burdaky](https://github.com/dean-burdaky) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.9-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.9)
+ - Fix Pattern matcher not matching to subregion [(#1914)](https://github.com/mockito/mockito/pull/1914)
+ - ArgumentMatchers.matches not working [(#1905)](https://github.com/mockito/mockito/issues/1905)
+
+#### 3.3.8
+ - 2020-04-15 - [2 commits](https://github.com/mockito/mockito/compare/v3.3.7...v3.3.8) by [Eitan Adler](https://github.com/grimreaper) (1), [NanjanChung](https://github.com/NanjanChung) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.8-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.8)
+ - Fixes #1910: update description of ArgumentMatcher javadoc [(#1911)](https://github.com/mockito/mockito/pull/1911)
+ - Documentation of ArgumentMatchers any() is confusing [(#1910)](https://github.com/mockito/mockito/issues/1910)
+ - [tests] use ArgumentMatchers over Matchers [(#1907)](https://github.com/mockito/mockito/pull/1907)
+
+#### 3.3.7
+ - 2020-04-12 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.6...v3.3.7) by [Eitan Adler](https://github.com/grimreaper) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.7-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.7)
+ - [documentation] change deprecated warnings from 3.x -> 4.x [(#1906)](https://github.com/mockito/mockito/pull/1906)
+
+#### 3.3.6
+ - 2020-03-25 - [3 commits](https://github.com/mockito/mockito/compare/v3.3.5...v3.3.6) by [Marcin Mikołajczyk](https://github.com/mikolajczykmarcin) (2), [Alex Wilson](https://github.com/mrwilson) (1) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.6-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.6)
+ - Feature/returns empty java8 time [(#1896)](https://github.com/mockito/mockito/pull/1896)
+ - Fixes #1894 checkstyle error on windows [(#1895)](https://github.com/mockito/mockito/pull/1895)
+ - Checkstyle error on windows [(#1894)](https://github.com/mockito/mockito/issues/1894)
+ - Make JARs build reproducibly [(#1892)](https://github.com/mockito/mockito/pull/1892)
+ - Build is not reproducible [(#1891)](https://github.com/mockito/mockito/issues/1891)
+ - Add java.time types to ReturnsEmptyValues [(#1885)](https://github.com/mockito/mockito/issues/1885)
+
+#### 3.3.5
+ - 2020-03-23 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.4...v3.3.5) by [Shyam Sundar J](https://github.com/severussundar) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.5-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.5)
+ - Fixes #id : 1888 [(#1893)](https://github.com/mockito/mockito/pull/1893)
+ - Documentation typo [(#1888)](https://github.com/mockito/mockito/issues/1888)
+
+#### 3.3.4
+ - 2020-03-21 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.3...v3.3.4) by [dean-burdaky](https://github.com/dean-burdaky) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.4-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.4)
+ - Fix mocks throwing same instance with throwable class [(#1890)](https://github.com/mockito/mockito/pull/1890)
+ - thenThrow(Class) no longer creates new instances [(#1875)](https://github.com/mockito/mockito/issues/1875)
+
+#### 3.3.3
+ - 2020-03-13 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.2...v3.3.3) by [Tim van der Lippe](https://github.com/TimvdLippe) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.3-green.svg)](https://bintray.com/mockito/maven/mockito/3.3.3)
+ - No pull requests referenced in commit messages.
+
+#### 3.3.2
+ - 2020-02-28 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.1...v3.3.2) by [Jean-Michel Leclercq](https://github.com/LeJeanbono) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.2-green.svg)](https://bintray.com/mockito/maven/mockito-development/3.3.2)
+ - Fix UnnecessaryStubbingException javadoc [(#1881)](https://github.com/mockito/mockito/pull/1881)
+
+#### 3.3.1
+ - 2020-02-26 - [1 commit](https://github.com/mockito/mockito/compare/v3.3.0...v3.3.1) by [Tim van der Lippe](https://github.com/TimvdLippe) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.1-green.svg)](https://bintray.com/mockito/maven/mockito/3.3.1)
+ - Revert "Fixed undetected unused stubbing when matching previous stubbed call" [(#1878)](https://github.com/mockito/mockito/pull/1878)
 
 #### 3.3.0
  - 2020-02-21 - [1 commit](https://github.com/mockito/mockito/compare/v3.2.11...v3.3.0) by [Tim van der Lippe](https://github.com/TimvdLippe) - published to [![Bintray](https://img.shields.io/badge/Bintray-3.3.0-green.svg)](https://bintray.com/mockito/maven/mockito/3.3.0)
@@ -1728,7 +1936,7 @@ Last version published to Maven Central after the team adopted [Continuous Deliv
 * Commits: 5
   * 2: Brice Dutheil
   * 2: Christian Schwarz
-  * 1: Felix Dekker
+  * 1: F.W. Dekker
 * Improvements: 4
   * Replaced ObjectBox with AtomicReference [(#777)](https://github.com/mockito/mockito/pull/777)
   * InvocationMatcher internal improvements [(#776)](https://github.com/mockito/mockito/pull/776)
diff --git a/gradle.properties b/gradle.properties
index 5970e287bb..377b887db4 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,3 +1,24 @@
 org.gradle.daemon=true
 org.gradle.parallel=true
 org.gradle.caching=true
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 \
+  -XX:+IgnoreUnrecognizedVMOptions \
+  --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \
+  --add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED \
+  --add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED \
+  --add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED \
+  --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED \
+  --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app"s APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official
+
+# Version of JDK to use for running tests.
+# Possible values:
+# - auto -> use Java running Gradle, best for local dev.
+# - A Java major version number, like 11 or 17.
+mockito.test.java=auto
diff --git a/gradle/coverage.gradle b/gradle/coverage.gradle
new file mode 100644
index 0000000000..5f5012e5c9
--- /dev/null
+++ b/gradle/coverage.gradle
@@ -0,0 +1,65 @@
+rootProject.subprojects { Project project ->
+    plugins.withId("java") {
+        project.apply plugin: "jacoco"
+        project.jacoco {
+            toolVersion = '0.8.11'
+        }
+    }
+}
+
+def mockitoCoverage = tasks.register("mockitoCoverage", JacocoReport) { mockitoCoverage ->
+    group = LifecycleBasePlugin.VERIFICATION_GROUP
+    rootProject.subprojects { Project currentProject ->
+        plugins.withId("jacoco") {
+            plugins.withId("java") {
+                // JacocoReport.sourceSets() appends both sourceDirectories and classDirectories.
+                mockitoCoverage.sourceSets currentProject.sourceSets.main
+                mockitoCoverage.executionData(currentProject.tasks.test)
+            }
+            plugins.withId("com.android.base") {
+                // The :androidTest project only contains test infrastructure, so there's no need to grab sources/classes.
+
+                def androidTest = currentProject.tasks.connectedDebugAndroidTest
+                def instrumentationCoverage = currentProject
+                    .layout.buildDirectory.dir("outputs/code_coverage/debugAndroidTest/connected")
+                    .map { it.asFileTree.matching { include "*/coverage.ec" } }
+                mockitoCoverage.executionData(currentProject.files(instrumentationCoverage))
+                mockitoCoverage.mustRunAfter(androidTest)
+
+                def unitTest = currentProject.tasks.testDebugUnitTest
+                def coverageFiles = currentProject
+                    .layout.buildDirectory.dir("outputs/unit_test_code_coverage/debugUnitTest")
+                    .map { it.asFileTree.matching { include "testDebugUnitTest.exec" } }
+                mockitoCoverage.executionData(currentProject.files(coverageFiles).builtBy(unitTest))
+            }
+        }
+    }
+
+    gradle.taskGraph.whenReady { // Theoretically Gradle.projectsEvaluated, but not possible here.
+        // Run this after all projects' sourceSets have been added (which is delayed to when the jacoco plugin is applied).
+        classDirectories.setFrom(
+            classDirectories.files.collect {
+                fileTree(
+                    dir: it,
+                    exclude: ["**/internal/util/concurrent/**"]
+                )
+            }
+        )
+    }
+
+    reports {
+        xml.required = true
+        html.required = true
+        html.outputLocation = rootProject.layout.buildDirectory.dir("jacocoHtml")
+    }
+
+    doLast {
+        def reportFile = new File(reports.html.outputLocation.get().asFile, "index.html")
+        logger.lifecycle "Jacoco HTML created: file://${reportFile.toURI().path}"
+    }
+}
+
+tasks.register("coverageReport") {
+    group = LifecycleBasePlugin.VERIFICATION_GROUP
+    dependsOn(mockitoCoverage)
+}
diff --git a/gradle/dependencies.gradle b/gradle/dependencies.gradle
deleted file mode 100644
index e052dad88e..0000000000
--- a/gradle/dependencies.gradle
+++ /dev/null
@@ -1,48 +0,0 @@
-ext {
-    libraries = [:]
-}
-
-def versions = [:]
-
-versions.bytebuddy = '1.10.5'
-versions.junitJupiter = '5.4.2'
-versions.errorprone = '2.3.2'
-
-libraries.junit4 = 'junit:junit:4.12'
-libraries.junitJupiterApi = "org.junit.jupiter:junit-jupiter-api:${versions.junitJupiter}"
-libraries.junitPlatformLauncher = 'org.junit.platform:junit-platform-launcher:1.1.0'
-libraries.junitJupiterEngine = "org.junit.jupiter:junit-jupiter-engine:${versions.junitJupiter}"
-libraries.assertj = 'org.assertj:assertj-core:3.15.0'
-libraries.hamcrest = 'org.hamcrest:hamcrest-core:1.3'
-libraries.opentest4j = 'org.opentest4j:opentest4j:1.1.1'
-
-libraries.bytebuddy = "net.bytebuddy:byte-buddy:${versions.bytebuddy}"
-libraries.bytebuddyagent = "net.bytebuddy:byte-buddy-agent:${versions.bytebuddy}"
-libraries.bytebuddyandroid = "net.bytebuddy:byte-buddy-android:${versions.bytebuddy}"
-
-libraries.errorprone = "com.google.errorprone:error_prone_core:${versions.errorprone}"
-libraries.errorproneTestApi = "com.google.errorprone:error_prone_test_helpers:${versions.errorprone}"
-
-libraries.autoservice = "com.google.auto.service:auto-service:1.0-rc5"
-
-// objenesis 3.x with full Java 11 support requires Java 8, bump version when Java 7 support is dropped
-libraries.objenesis = 'org.objenesis:objenesis:2.6'
-
-libraries.asm = 'org.ow2.asm:asm:7.0'
-
-libraries.osgi = 'org.osgi:osgi.core:7.0.0'
-libraries.equinox = 'org.eclipse.platform:org.eclipse.osgi:3.15.0'
-libraries.bndGradle =  'biz.aQute.bnd:biz.aQute.bnd.gradle:4.3.1'
-
-def kotlinVersion = '1.2.10'
-def kotlinVersion_1_3 = '1.3.0-rc-57'
-libraries.kotlin = [
-    version: kotlinVersion,
-    version_1_3: kotlinVersion_1_3,
-
-    stdlib: "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}",
-    coroutines: 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.3',
-
-    stdlib_1_3:  "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion_1_3",
-    releaseCoroutines: "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.26.1-eap13"
-]
diff --git a/gradle/errorprone.gradle b/gradle/errorprone.gradle
deleted file mode 100644
index 43c8633fcd..0000000000
--- a/gradle/errorprone.gradle
+++ /dev/null
@@ -1,16 +0,0 @@
-
-apply plugin: "net.ltgt.errorprone"
-
-if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
-    dependencies {
-        errorproneJavac("com.google.errorprone:javac:9+181-r4173-1")
-    }
-}
-
-dependencies {
-    errorprone libraries.errorprone
-}
-
-tasks.named("compileTestJava").configure {
-    options.errorprone.errorproneArgs << "-Xep:MockitoCast:OFF"
-}
diff --git a/gradle/java-library.gradle b/gradle/java-library.gradle
deleted file mode 100644
index be214c6c24..0000000000
--- a/gradle/java-library.gradle
+++ /dev/null
@@ -1,38 +0,0 @@
-apply plugin: "java"
-
-group = 'org.mockito'
-
-if (!archivesBaseName.startsWith("mockito-")) {
-    archivesBaseName = "mockito-" + project.name
-}
-
-generatePomFileForJavaLibraryPublication.doLast {
-    //validates the the pom has correct artifact id to avoid issues like #1444
-    def pom = new XmlSlurper().parse(destination)
-    assert pom.artifactId == archivesBaseName
-    assert pom.name == archivesBaseName
-}
-
-bintrayUpload.enabled = true
-
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
-
-test {
-    include "**/*Test.class"
-
-    testLogging {
-        exceptionFormat 'full'
-        showCauses true
-    }
-}
-
-apply from: "$rootDir/gradle/retry-test.gradle"
-
-tasks.withType(Checkstyle) {
-    reports {
-        xml.enabled false
-        html.enabled true
-        html.stylesheet resources.text.fromFile("$rootDir/config/checkstyle/checkstyle.xsl")
-    }
-}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
new file mode 100644
index 0000000000..2e02e29680
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,60 @@
+[versions]
+bytebuddy = "1.15.11"
+errorprone = "2.23.0"
+junit4 = "4.13.2"
+junit-jupiter = "5.11.4"
+junit-platform = "1.11.4"
+kotlin = "2.0.21"
+
+gradleplugin-test-logger = "4.0.0"
+gradleplugin-animal-sniffer = "1.7.2"
+gradleplugin-aQute-bnd = "7.1.0"
+gradleplugin-errorprone = "4.1.0"
+gradleplugin-spotless = "7.0.2"
+
+gradleplugin-android = "7.4.2"
+
+[libraries]
+android-junit = { module = "androidx.test.ext:junit", version = "1.2.1" }
+android-runner = { module = "androidx.test:runner", version = "1.6.2" }
+assertj = { module = "org.assertj:assertj-core", version = "3.27.3" }
+autoservice = { module = "com.google.auto.service:auto-service", version = "1.1.1" }
+bnd-gradle = { module = "biz.aQute.bnd:biz.aQute.bnd.gradle", version.ref = "gradleplugin-aQute-bnd" }
+bytebuddy = { module = "net.bytebuddy:byte-buddy", version.ref = "bytebuddy" }
+bytebuddy-agent = { module = "net.bytebuddy:byte-buddy-agent", version.ref = "bytebuddy" }
+bytebuddy-android = { module = "net.bytebuddy:byte-buddy-android", version.ref = "bytebuddy" }
+equinox = { module = "org.eclipse.platform:org.eclipse.osgi", version = "3.22.0" }
+errorprone = { module = "com.google.errorprone:error_prone_core", version.ref = "errorprone" }
+errorprone-test-api = { module = "com.google.errorprone:error_prone_test_helpers", version.ref = "errorprone" }
+groovy = { module = "org.codehaus.groovy:groovy", version = "3.0.23" }
+hamcrest = { module = "org.hamcrest:hamcrest-core", version = "3.0" }
+junit4 = { module = "junit:junit", version.ref = "junit4" }
+junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit-jupiter" }
+junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit-jupiter" }
+junit-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version.ref = "junit-jupiter" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junit-platform" }
+junit-vintage-engine = { module = "org.junit.vintage:junit-vintage-engine", version.ref = "junit-jupiter" }
+kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
+kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version = "1.6.3-native-mt" }
+objenesis = { module = "org.objenesis:objenesis", version = "3.3" }
+opentest4j = { module = "org.opentest4j:opentest4j", version = "1.3.0" }
+osgi = { module = "org.osgi:osgi.core", version = "8.0.0" }
+
+# For buildSrc logic
+gradleplugin-testLogger = { module = "com.adarshr:gradle-test-logger-plugin", version.ref = "gradleplugin-test-logger" }
+gradleplugin-animalSniffer = { module = "ru.vyarus:gradle-animalsniffer-plugin", version.ref = "gradleplugin-animal-sniffer" }
+gradleplugin-bnd = { module = "biz.aQute.bnd:biz.aQute.bnd.gradle", version.ref = "gradleplugin-aQute-bnd" }
+gradleplugin-errorprone = { module = "net.ltgt.gradle:gradle-errorprone-plugin", version.ref = "gradleplugin-errorprone" }
+gradleplugin-spotless = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "gradleplugin-spotless" }
+gradleplugin-spotless-googleJavaFormat = { module = "com.google.googlejavaformat:google-java-format", version = "1.25.2" }
+gradleplugin-license = { module = "com.github.hierynomus.license:com.github.hierynomus.license.gradle.plugin", version = "0.16.1" }
+gradleplugin-nexusPublish = { module = "io.github.gradle-nexus:publish-plugin", version = "2.0.0" }
+gradleplugin-shipkit-changelog = { module = "org.shipkit:shipkit-changelog", version = "2.0.1" }
+gradleplugin-shipkit-autoVersion = { module = "org.shipkit:shipkit-auto-version", version = "2.1.0" }
+
+# animal sniffer compatibility signatures
+animalSniffer-android-apiLevel26 = { module = "net.sf.androidscents.signature:android-api-level-26", version = "8.0.0_r2" }
+animalSniffer-java = { module = "org.codehaus.mojo.signature:java18", version = "1.0" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "gradleplugin-android" }
diff --git a/gradle/license.gradle b/gradle/license.gradle
deleted file mode 100644
index f6eb52d899..0000000000
--- a/gradle/license.gradle
+++ /dev/null
@@ -1,16 +0,0 @@
-def licenseHeaderFile = rootProject.file('doc/licenses/HEADER.txt')
-
-allprojects {
-    apply plugin: 'com.github.hierynomus.license'
-    license {
-        header = licenseHeaderFile
-        strictCheck = true
-        ignoreFailures = true
-        skipExistingHeaders = true
-        mapping {
-            java = 'SLASHSTAR_STYLE'
-            groovy = 'SLASHSTAR_STYLE'
-        }
-        ext.year = Calendar.getInstance().get(Calendar.YEAR)
-    }
-}
diff --git a/gradle/mockito-core/inline-mock.gradle b/gradle/mockito-core/inline-mock.gradle
deleted file mode 100644
index ae39ffeec1..0000000000
--- a/gradle/mockito-core/inline-mock.gradle
+++ /dev/null
@@ -1,15 +0,0 @@
-task copyMockMethodDispatcher(type: Copy) {
-    dependsOn compileJava
-    from "${sourceSets.main.java.outputDir}/org/mockito/internal/creation/bytebuddy/inject"
-    into "${sourceSets.main.java.outputDir}/org/mockito/internal/creation/bytebuddy/inject"
-    include "MockMethodDispatcher.class"
-    rename { String fileName ->
-        fileName.replace('.class', '.raw')
-    }
-}
-classes.dependsOn(copyMockMethodDispatcher)
-
-jar {
-    exclude("org/mockito/internal/creation/bytebuddy/inject/package-info.class")
-    exclude("org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class")
-}
diff --git a/gradle/mockito-core/javadoc.gradle b/gradle/mockito-core/javadoc.gradle
deleted file mode 100644
index 0ed36bb960..0000000000
--- a/gradle/mockito-core/javadoc.gradle
+++ /dev/null
@@ -1,74 +0,0 @@
-//It seems the gradle javadoc task works file by file and as such disable some features of javadoc tool
-//such as link to packages, https://groups.google.com/d/msg/gradle-dev/R83dy_6PHMc/bgw0cUTMFAAJ
-javadoc {
-    description "Creates javadoc html for Mockito API."
-
-    // For more details on the format
-    // see https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javadoc.html
-
-    source = sourceSets.main.allJava
-    destinationDir = file("$buildDir/javadoc")
-    title = "Mockito ${project.version} API"
-
-    // The way *gradle* javadoc task works and due to *gradle exclusion* the log output triggers javadoc warning and
-    // errors on internal classes that are not found, non-exhaustive list :
-    //
-    // * import org.mockito.internal.Internal <- error: package org.mockito.internal does not exists
-    // * import org.mockito.internal.Internal.util <- error: static import only from classes and interfaces
-    // * class Public extends Internal <- cannot find symbol
-    // * warning - Tag @linkplain: reference not found: org.mockito.internal.Internal internal stuff
-    // * warning - Tag @link: reference not found: org.mockito.stubbing
-    //
-    // While there's errors the javadoc is still generated without those symbols or links ;
-    // for this reason the javadoc output is suppressed and can be reactivated with --info option.
-    exclude 'org/mockito/internal'
-    logging.captureStandardError LogLevel.INFO
-    logging.captureStandardOutput LogLevel.INFO // suppress "## warnings" message
-
-    options.docTitle = """<h1><a href="org/mockito/Mockito.html">Click to see examples</a>. Mockito ${project.version} API.</h1>"""
-    options.windowTitle = "Mockito ${project.version} API"
-    options.group("Main package", ["org.mockito"])
-    options.memberLevel = JavadocMemberLevel.PROTECTED
-    options.outputLevel = JavadocOutputLevel.QUIET
-    options.charSet = 'UTF-8'
-    options.encoding = 'UTF-8'
-    options.docEncoding = 'UTF-8'
-    options.use = true
-    options.splitIndex = true
-    options.noDeprecated = false
-    options.noDeprecatedList = false
-    options.noIndex = false
-    options.noNavBar = false
-    options.noTree = false
-    options.links = ['https://docs.oracle.com/javase/6/docs/api/',
-                     'http://junit.org/junit4/javadoc/4.12/',
-                     'http://hamcrest.org/JavaHamcrest/javadoc/1.3/']
-    options.header("""<em id="mockito-version-header-javadoc7-header"><strong>Mockito ${project.version} API</strong></em>""")
-    options.footer("""<em id="mockito-version-header-javadoc7-footer"><strong>Mockito ${project.version} API</strong></em>""")
-    options.bottom("""
-        <script type="text/javascript" src="{@docRoot}/js/jdk6-project-version-insert.min.js"></script>
-        <script type="text/javascript" src="{@docRoot}/js/jquery-1.7.min.js"></script>
-        <script type="text/javascript" src="{@docRoot}/js/highlight-8.6-java/highlight.pack.js"></script>
-
-        <link rel="stylesheet" type="text/css" href="{@docRoot}/js/highlight-8.6-java/styles/obsidian.css"/>
-        <script type="text/javascript" src="{@docRoot}/js/index.js" async defer></script>
-    """.replaceAll(/\r|\n|[ ]{8}/, ""))
-    options.stylesheetFile rootProject.file("src/javadoc/stylesheet.css")
-    options.addStringOption('Xdoclint:none', '-quiet')
-
-    def minorVersion = System.getProperty("java.version") =~ /1.8.0_(\d*)/
-
-    // Since JDK 8 version 121 scripts are not allowed in comments. However,
-    // earlier version throw an error if an unknown option is passed.
-    // Therefore only add this option if the JDK is actually correct.
-    if (minorVersion.size() > 0 && Integer.valueOf(minorVersion[0][1]) >= 121 || JavaVersion.current().isJava9Compatible()) {
-        options.addBooleanOption('-allow-script-in-comments', true)
-    }
-
-    doLast {
-        copy {
-            from "src/javadoc"
-            into "$buildDir/javadoc"
-        }
-    }
-}
diff --git a/gradle/mockito-core/osgi.gradle b/gradle/mockito-core/osgi.gradle
deleted file mode 100644
index 1e942f6569..0000000000
--- a/gradle/mockito-core/osgi.gradle
+++ /dev/null
@@ -1,35 +0,0 @@
-apply plugin: 'osgi'
-
-afterEvaluate {
-    tasks.matching { it.name == 'jar' }.all { jar ->
-        jar.manifest {
-            classpath = project.configurations.runtime
-
-            instruction '-versionpolicy', '[${version;==;${@}},${version;+;${@}})'
-
-            name = 'Mockito Mock Library for Java. Core bundle requires Byte Buddy and Objenesis.'
-            symbolicName = 'org.mockito.mockito-core'
-            version = project.version.replace('-', '.')
-
-            instruction 'Export-Package',
-                    '!org.mockito.internal.*',
-                    "org.mockito.*;version=${version}"
-
-            instruction 'Import-Package',
-                    'net.bytebuddy.*;version="[1.6.0,2.0)"',
-                    'junit.*;resolution:=optional',
-                    'org.junit.*;resolution:=optional',
-                    'org.hamcrest;resolution:=optional',
-                    'org.objenesis;version="[2.5,3.0)"',
-                    'org.opentest4j.*;resolution:=optional',
-                    'org.mockito.*'
-
-            instruction 'Private-Package',
-                    'org.mockito.*'
-
-            instruction '-removeheaders', 'Private-Package'
-
-            attributes 'Automatic-Module-Name': 'org.mockito'
-        }
-    }
-}
diff --git a/gradle/mockito-core/testing.gradle b/gradle/mockito-core/testing.gradle
deleted file mode 100644
index a7c14c1f62..0000000000
--- a/gradle/mockito-core/testing.gradle
+++ /dev/null
@@ -1,29 +0,0 @@
-def java11 = System.env.SIMULATE_JAVA11
-if (java11 != null) {
-    test {
-        logger.info("$it.path - use Java11 simluation: ${java11}")
-        systemProperty "org.mockito.internal.noUnsafeInjection", java11
-    }
-}
-
-task(createTestResources).doLast {
-    def mockMakerFile = new File("$projectDir/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker")
-    if (System.env.MOCK_MAKER != null) {
-        logger.info("Using MockMaker ${System.env.MOCK_MAKER}")
-        mockMakerFile.parentFile.mkdirs()
-        mockMakerFile.createNewFile()
-        mockMakerFile.write(System.env.MOCK_MAKER)
-    } else {
-        logger.info("Using default MockMaker")
-    }
-}
-
-task(removeTestResources).doLast {
-    def mockMakerFile = new File("$projectDir/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker")
-    if (mockMakerFile.exists()) {
-        mockMakerFile.delete()
-    }
-}
-
-compileTestJava.dependsOn createTestResources
-compileTestJava.finalizedBy removeTestResources
diff --git a/gradle/retry-test.gradle b/gradle/retry-test.gradle
deleted file mode 100644
index 23ae107237..0000000000
--- a/gradle/retry-test.gradle
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
-Plugin that retries failed tests.
-Mockito has concurrent API and those tests and inherently flaky.
-We decided to use retries to stabilize (conscious team choice)
-Long term, we can evolve retry-test script plugin to a binary plugin or make it more robust
-
-Plugin adds 'retryTest' task that runs tests that failed during the execution of 'test' task.
-*/
-task retryTest(type: Test) {
-    description = "Retries failed tests (if present)"
-    enabled = false
-    doFirst {
-        logger.lifecycle "[retryTest] retrying ${filter.includePatterns.size()} test(s)."
-    }
-    afterSuite { descriptor, result ->
-        if (!descriptor.parent) { //root
-            if (result.failedTestCount > 0) {
-                logger.lifecycle "\n[retryTest] retried ${filter.includePatterns.size()} test(s), $result.failedTestCount still failed."
-            } else {
-                logger.lifecycle "\n[retryTest] ${filter.includePatterns.size()} test(s) were retried successfully:\n  " + filter.includePatterns.join("\n  ")
-            }
-        }
-    }
-    testClassesDirs = test.testClassesDirs
-    classpath = test.classpath
-    scanForTestClasses = test.scanForTestClasses
-    outputs.upToDateWhen { false } //we want to always run flaky tests because they are flaky
-
-    include "**/*Test.class"
-
-    testLogging {
-        exceptionFormat 'full'
-        showCauses true
-    }
-}
-
-test {
-    finalizedBy retryTest
-    ext.failedTests = []
-    afterTest { descriptor, result ->
-        if (!descriptor.composite /* e.g. is not a parent */ && result.failedTestCount > 0 ) {
-            //adding fully qualified test name, dropping "()" from the method name
-            failedTests.add(descriptor.className + "." + descriptor.name.replaceAll("\\(\\)", ""))
-        }
-    }
-    afterSuite { descriptor, result ->
-        if (!descriptor.parent) { //root
-            def failuresReport = new File(buildDir, name + "-failures.txt")
-            def deletion = !failuresReport.exists() || failuresReport.delete()
-            if (!deletion) {
-                throw new GradleException("Problems deleting failures file: $reportPath. Please delete manually and retry.")
-            }
-            def reportPath = rootProject.relativePath(failuresReport)
-            if (!failedTests.empty) {
-                failuresReport << failedTests.join("\n")
-                logger.lifecycle "\n[retryTest] wrote ${failedTests.size()} failed tests to: $reportPath"
-                logger.info "[retryTest] all failed tests:\n  " + failedTests.join("\n  ")
-                retryTest.enabled = true
-                retryTest.filter.includePatterns = failedTests.toArray(new String[failedTests.size()])
-                ignoreFailures = true
-            } else {
-                logger.info "\n[retryTest] There are no failed tests, '$reportPath' file was deleted (if existed)."
-            }
-        }
-    }
-}
-
-
diff --git a/gradle/root/coverage.gradle b/gradle/root/coverage.gradle
deleted file mode 100644
index 03ec3883e6..0000000000
--- a/gradle/root/coverage.gradle
+++ /dev/null
@@ -1,53 +0,0 @@
-if (!project.hasProperty("jacoco")) {
-    //JaCoCo plugin prevents using Build Cache. We will enable jacoco configuration only when specific property is supplied
-    //TODO remove this workaround when we migrate to Gradle 5.0 (https://github.com/gradle/gradle/issues/5269)
-    logger.info "JaCoCo code coverage will not be configured because 'jacoco' project property is not present."
-    return //don't evaluate this Gradle file any further
-} else {
-    logger.lifecycle "Configuring JaCoCo code coverage because 'jacoco' project property is present."
-}
-
-//TODO: Standard JaCoCo coverage doesn't work in Android module
-task mockitoCoverage(type: JacocoReport) {
-
-    allprojects { currentProject ->
-        plugins.withId("java") {
-            mockitoCoverage.sourceSets currentProject.sourceSets.main
-
-            apply plugin: "jacoco"
-
-            jacoco {
-                toolVersion = '0.8.2'
-
-                if (currentProject != rootProject) {   //already automatically enhanced in mockito main project as "java" plugin was applied before
-                    applyTo test
-                }
-                test.jacoco.destinationFile = file("${currentProject.buildDir}/jacoco/test.exec")
-            }
-
-            mockitoCoverage.executionData(files(test.jacoco.destinationFile).builtBy(test))
-        }
-    }
-
-    reports {
-        xml.enabled true
-        html.enabled true
-        html.destination file("${buildDir}/jacocoHtml")
-    }
-
-    doFirst {
-        classDirectories.from = classDirectories.files.collect {
-            fileTree(
-                dir: it,
-                exclude: ['**/org/mockito/internal/util/concurrent/**']
-            )
-        }
-        executionData.from = executionData.files.findAll { it.exists() }
-    }
-
-    doLast {
-        logger.lifecycle "Jacoco HTML created: file://${new File(reports.html.destination, "index.html").toURI().path}"
-    }
-}
-
-task coverageReport(dependsOn: ["mockitoCoverage"]) {}
diff --git a/gradle/root/gradle-fix.gradle b/gradle/root/gradle-fix.gradle
deleted file mode 100644
index c37eab2ee2..0000000000
--- a/gradle/root/gradle-fix.gradle
+++ /dev/null
@@ -1,13 +0,0 @@
-
-// GradleWorkerMain ignores options available in the environment, so we have to pass them there
-
-allprojects {
-    tasks.withType(JavaForkOptions) {
-        // should improve memory on a 64bit JVM
-        jvmArgs "-XX:+UseCompressedOops"
-
-        // should avoid GradleWorkerMain to steal focus
-        jvmArgs "-Djava.awt.headless=true"
-        jvmArgs "-Dapple.awt.UIElement=true"
-    }
-}
diff --git a/gradle/root/ide.gradle b/gradle/root/ide.gradle
deleted file mode 100644
index bfc7ed77d8..0000000000
--- a/gradle/root/ide.gradle
+++ /dev/null
@@ -1,11 +0,0 @@
-assert rootProject == project
-
-allprojects {
-    apply plugin: 'eclipse'
-    apply plugin: 'idea'
-}
-
-idea.project {
-    vcs = 'Git'
-}
-
diff --git a/gradle/shipkit.gradle b/gradle/shipkit.gradle
deleted file mode 100644
index aa4546cd0e..0000000000
--- a/gradle/shipkit.gradle
+++ /dev/null
@@ -1,89 +0,0 @@
-shipkit {
-    gitHub.repository = "mockito/mockito"
-    gitHub.readOnlyAuthToken = "a0a4c0f41c200f7c653323014d6a72a127764e17"
-
-    releaseNotes.file = "doc/release-notes/official.md"
-    releaseNotes.labelMapping = [
-        '1.* incompatible': 'Incompatible changes with previous major version (v1.x)',
-        'java-9': "Java 9 support",
-        'java-8': "Java 8 support",
-        'new feature': "New features",
-        'BDD': 'Behavior-Driven Development support',
-        'bug': "Bugfixes",
-        'enhancement': "Enhancements",
-        'android': "Android support",
-        'docs': 'Documentation'
-    ]
-
-    git.releasableBranchRegex = "release/.+"  // 'release/2.x', 'release/3.x', etc.
-
-    def buildNo = System.getenv("TRAVIS_BUILD_NUMBER")
-    git.commitMessagePostfix = buildNo? "by CI build $buildNo\n\n[ci skip-release]" : "by local build\n\n[ci skip-release]"
-
-    team.developers = ['mockitoguy:Szczepan Faber', 'bric3:Brice Dutheil', 'raphw:Rafael Winterhalter', 'TimvdLippe:Tim van der Lippe']
-}
-
-/**
- * Mockito team does not publish to Maven Central every release as requested by the community.
- * We publish to maven central only some versions. All versions are published to Bintray on every change.
- * See https://github.com/mockito/mockito/issues/911
- */
-boolean centralRelease = shouldReleaseToCentral(project)
-
-afterEvaluate {
-    //using afterEvaluate because 'assertReleaseNeeded' task is added after 'shipkit.gradle' file is evaluated by Gradle
-   [assertReleaseNeeded, releaseNeeded].each {
-        it.skipComparePublications = centralRelease
-    }
-}
-
-allprojects {
-    plugins.withId("org.shipkit.bintray") {
-        bintray {
-            pkg {
-                repo = 'maven' //https://bintray.com/mockito/maven
-
-                //We need to use some user id here, because the Bintray key is associated with the user
-                //However, any user id is good, so longer the user has necessary privileges to the repository
-                user = 'szczepiq' //https://bintray.com/szczepiq
-
-                userOrg = 'mockito' //https://bintray.com/mockito
-                name = 'mockito' //https://bintray.com/mockito/maven/mockito
-                licenses = ['MIT']
-                labels = ['mocks', 'tdd', 'unit tests']
-                publish = true //can be changed to 'false' for testing
-
-                //See our Bintray packages at https://bintray.com/mockito/maven
-                name = centralRelease? "mockito" : "mockito-development"
-
-                version {
-                    //Notable versions are automatically synced to Maven Central repository (https://oss.sonatype.org/)
-                    mavenCentralSync {
-                        sync = centralRelease
-                        user = System.env.NEXUS_TOKEN_USER
-                        password = System.env.NEXUS_TOKEN_PWD
-                    }
-                }
-            }
-        }
-    }
-}
-
-/**
- * Finds out if we should release to Maven Central.
- * To test this logic, run build with '-i' (info logging) and inspect the build output.
- */
-static boolean shouldReleaseToCentral(project) {
-    boolean centralReleaseByCommit = System.getenv("TRAVIS_COMMIT_MESSAGE")?.contains("[ci maven-central-release]")
-    boolean centralReleaseByProjectProperty = project.hasProperty("maven-central-release")
-    boolean centralRelease = centralReleaseByCommit || centralReleaseByProjectProperty
-    def message = """Release was using following settings:
- - commit message contains '[ci maven-central-release]': $centralReleaseByCommit
- - project property 'maven-central-release' exists: $centralReleaseByProjectProperty
- - Maven Central release is enabled: $centralRelease"""
-    project.logger.info(message)
-    project.afterEvaluate {
-        project.tasks.performRelease.doLast { logger.lifecycle(message) }
-    }
-    return centralRelease
-}
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 0d4a951687..d64cd49177 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index ea13fdfd19..fb602ee2af 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,8 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.3.1-bin.zip
+distributionSha256Sum=31c55713e40233a8303827ceb42ca48a47267a0ad4bab9177123121e71524c26
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index cccdd3d517..1aa94a4269 100755
--- a/gradlew
+++ b/gradlew
@@ -1,78 +1,127 @@
-#!/usr/bin/env sh
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# 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
+#
+#      https://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.
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -81,92 +130,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
 fi
 
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
     # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
         fi
-        i=$((i+1))
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
     done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
 fi
 
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
 exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
index f9553162f1..93e3f59f13 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -1,4 +1,20 @@
-@if "%DEBUG%" == "" @echo off
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -9,19 +25,23 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +55,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,38 +65,26 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
diff --git a/mockito-bom/build.gradle.kts b/mockito-bom/build.gradle.kts
new file mode 100644
index 0000000000..8ed867a9cb
--- /dev/null
+++ b/mockito-bom/build.gradle.kts
@@ -0,0 +1,22 @@
+plugins {
+    id("java-platform")
+    id("mockito.publication-conventions")
+}
+
+description = "Mockito Bill of Materials (BOM)"
+
+if (!base.archivesName.get().startsWith("mockito-")) {
+    logger.warn("Project module should be prefixed with `mockito-` : ${project.projectDir})")
+    base.archivesName = "mockito-" + project.name
+}
+
+val mockitoExtensions: Set<Project> = project(":mockito-extensions").subprojects
+dependencies {
+    constraints {
+        api(project(":mockito-core"))
+
+        mockitoExtensions.forEach {
+            api(it)
+        }
+    }
+}
diff --git a/mockito-core/build.gradle.kts b/mockito-core/build.gradle.kts
new file mode 100644
index 0000000000..0c15d91275
--- /dev/null
+++ b/mockito-core/build.gradle.kts
@@ -0,0 +1,240 @@
+import com.android.build.gradle.internal.tasks.factory.dependsOn
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.ClassWriter
+import org.objectweb.asm.ModuleVisitor
+import org.objectweb.asm.Opcodes
+
+plugins {
+    id("mockito.library-conventions")
+    id("mockito.java-backward-compatibility-checks-conventions")
+    id("mockito.javadoc-conventions")
+    id("java-test-fixtures")
+}
+
+description = "Mockito mock objects library core API and implementation"
+base.archivesName = "mockito-core"
+
+apply {
+    from(rootProject.file("gradle/coverage.gradle"))
+}
+
+configurations {
+    // Putting 'provided' dependencies on testCompileOnly and testRuntimeOnly classpath.
+    testCompileOnly.configure {
+        extendsFrom(compileOnly.get())
+    }
+    testRuntimeOnly.configure {
+        extendsFrom(compileOnly.get())
+    }
+}
+
+// Disables publishing test fixtures:
+// https://docs.gradle.org/current/userguide/java_testing.html#ex-disable-publishing-of-test-fixtures-variants
+with(components["java"] as AdhocComponentWithVariants) {
+    withVariantsFromConfiguration(configurations.testFixturesApiElements.get()) { skip() }
+    withVariantsFromConfiguration(configurations.testFixturesRuntimeElements.get()) { skip() }
+}
+
+dependencies {
+    api(libs.bytebuddy)
+    api(libs.bytebuddy.agent)
+
+    compileOnly(libs.junit4)
+    compileOnly(libs.hamcrest)
+    compileOnly(libs.opentest4j)
+    implementation(libs.objenesis)
+
+    testImplementation(libs.assertj)
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+
+    testFixturesImplementation(libs.assertj)
+    testFixturesImplementation(libs.objenesis)
+    testFixturesCompileOnly(libs.junit4)
+}
+
+mockitoJavadoc {
+    title = "Mockito ${project.version} API"
+    docTitle =
+        """<h1><a href="org/mockito/Mockito.html">Click to see examples</a>. Mockito ${project.version} API.</h1>"""
+}
+
+val generatedInlineResource: Provider<Directory> = layout.buildDirectory.dir("generated/resources/inline/java")
+sourceSets {
+    main {
+        resources {
+            output.dir(generatedInlineResource)
+        }
+    }
+}
+
+tasks {
+    val copyMockMethodDispatcher by registering(Copy::class) {
+        dependsOn(compileJava)
+
+        from(sourceSets.main.flatMap { it.java.classesDirectory }
+            .map { it.file("org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class") })
+        into(generatedInlineResource.map { it.dir("org/mockito/internal/creation/bytebuddy") })
+
+        rename(".*", "inject-MockMethodDispatcher.raw")
+    }
+
+    val removeInjectionPackageFromModuleInfo by registering(DefaultTask::class) {
+        dependsOn(compileJava)
+
+        doLast {
+            val moduleInfo = sourceSets.main.get().output.classesDirs.first().resolve("module-info.class")
+
+            val reader = ClassReader(moduleInfo.readBytes())
+            val writer = ClassWriter(reader, 0)
+            reader.accept(object : ClassVisitor(Opcodes.ASM9, writer) {
+                override fun visitModule(name: String?, access: Int, version: String?): ModuleVisitor {
+                    return object : ModuleVisitor(
+                        Opcodes.ASM9,
+                        super.visitModule(name, access, version)
+                    ) {
+                        override fun visitPackage(packaze: String) {
+                            if (packaze != "org/mockito/internal/creation/bytebuddy/inject") {
+                                super.visitPackage(packaze)
+                            }
+                        }
+                    }
+                }
+            }, 0)
+
+            moduleInfo.writeBytes(writer.toByteArray())
+        }
+    }
+
+    classes.dependsOn(copyMockMethodDispatcher)
+    classes.dependsOn(removeInjectionPackageFromModuleInfo)
+
+
+    jar {
+        exclude(
+            "org/mockito/internal/creation/bytebuddy/inject/package-info.class",
+            "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class",
+        )
+        manifest {
+            attributes(
+                "Premain-Class" to "org.mockito.internal.PremainAttach",
+                "Can-Retransform-Classes" to "true",
+            )
+        }
+
+        bundle { // this: BundleTaskExtension
+            classpath(project.configurations.compileClasspath)
+            bnd(
+                """
+                # Bnd instructions for the Mockito core bundle.
+
+                # Set a bundle name slightly different from project description.
+                Bundle-Name: Mockito Mock Library for Java. Core bundle requires Byte Buddy and Objenesis.
+
+                # Set the Bundle-SymbolicName to "org.mockito.mockito-core".
+                # Otherwise bnd plugin will use archiveClassifier by default.
+                Bundle-SymbolicName: org.mockito.mockito-core
+
+                # Version rules for the bundle.
+                # https://bnd.bndtools.org/macros/version_cleanup.html
+                Bundle-Version: ${'$'}{version_cleanup;${project.version}}
+
+                # Set bundle license
+                Bundle-License: MIT
+
+                # Export rules for public and internal packages
+                # https://bnd.bndtools.org/heads/export_package.html
+                Export-Package: \
+                    !org.mockito.internal.creation.bytebuddy.inject,org.mockito.internal.*;status=INTERNAL;mandatory:=status;version=${archiveVersion.get()}, \
+                    !org.mockito.internal.creation.bytebuddy.inject,org.mockito.*;version=${archiveVersion.get()}
+
+                # General rules for package import
+                # https://bnd.bndtools.org/heads/import_package.html
+                # Override the default version policy to allow for a range of versions.
+                # At this point it's unclear whether `versionpolicy` is deprecated, here's
+                # some relevant pages on versions
+                # https://bnd.bndtools.org/chapters/170-versioning.html
+                # https://bnd.bndtools.org/macros/version.html
+                # https://bnd.bndtools.org/macros/versionmask.html
+                # https://bnd.bndtools.org/macros/range.html
+                -versionpolicy: [${'$'}{version;==;${'$'}{@}},${'$'}{version;+;${'$'}{@}})
+                Import-Package: \
+                    net.bytebuddy.*;version="[1.6.0,2.0)", \
+                    junit.*;resolution:=optional, \
+                    org.junit.*;resolution:=optional, \
+                    org.hamcrest;resolution:=optional, \
+                    org.objenesis;version="[3.1,4.0)", \
+                    org.opentest4j.*;resolution:=optional, \
+                    !org.mockito.internal.creation.bytebuddy.inject,org.mockito.*
+
+                # Don't add the Private-Package header.
+                # See https://bnd.bndtools.org/instructions/removeheaders.html
+                -removeheaders: Private-Package
+
+                # Don't add all the extra headers bnd normally adds.
+                # See https://bnd.bndtools.org/instructions/noextraheaders.html
+                -noextraheaders: true
+            """.trimIndent()
+            )
+        }
+    }
+
+    test {
+        val java11 = providers.environmentVariable("SIMULATE_JAVA11")
+        if (java11.isPresent) {
+            logger.info("$path - use Java11 simulation: $java11")
+            systemProperty("org.mockito.internal.noUnsafeInjection", java11.get())
+        }
+    }
+}
+
+//<editor-fold defaultstate="collapsed" desc="Environment-based Mockito extension configuration for tests">
+val mockitoExtConfigFiles = listOf(
+    mockitoExtensionConfigFile(project, "org.mockito.plugins.MockMaker"),
+    mockitoExtensionConfigFile(project, "org.mockito.plugins.MemberAccessor"),
+)
+
+val createTestResources by tasks.registering {
+    outputs.files(mockitoExtConfigFiles)
+    doLast {
+        // Configure MockMaker from environment (if specified), otherwise use default
+        configureMockitoExtensionFromCi(project, "org.mockito.plugins.MockMaker", "MOCK_MAKER")
+
+        // Configure MemberAccessor from environment (if specified), otherwise use default
+        configureMockitoExtensionFromCi(project, "org.mockito.plugins.MemberAccessor", "MEMBER_ACCESSOR")
+    }
+}
+
+sourceSets.test {
+    resources {
+        output.dir(
+            layout.buildDirectory.dir("generated/resources/ext-config/test"),
+            "builtBy" to createTestResources
+        )
+    }
+}
+
+fun Task.configureMockitoExtensionFromCi(
+    project: Project,
+    mockitoExtension: String,
+    ciMockitoExtensionEnvVarName: String,
+) {
+    val mockitoExtConfigFile = mockitoExtensionConfigFile(project, mockitoExtension)
+    val extEnvVar = project.providers.environmentVariable(ciMockitoExtensionEnvVarName)
+    if (extEnvVar.isPresent && !extEnvVar.get().endsWith("default")) {
+        logger.info("Using $mockitoExtension ${extEnvVar.get()}")
+        mockitoExtConfigFile.run {
+            parentFile.mkdirs()
+            createNewFile()
+            writeText(extEnvVar.get())
+        }
+    } else {
+        logger.info("Using default $mockitoExtension")
+    }
+}
+
+fun mockitoExtensionConfigFile(project: Project, mockitoExtension: String) =
+    file(project.layout.buildDirectory.dir("generated/resources/ext-config/test/mockito-extensions/$mockitoExtension"))
+//</editor-fold>
+
diff --git a/src/conf/pmd-rules.xml b/mockito-core/src/conf/pmd-rules.xml
similarity index 100%
rename from src/conf/pmd-rules.xml
rename to mockito-core/src/conf/pmd-rules.xml
diff --git a/mockito-core/src/main/java/module-info.java b/mockito-core/src/main/java/module-info.java
new file mode 100644
index 0000000000..15fbf51d4d
--- /dev/null
+++ b/mockito-core/src/main/java/module-info.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+module org.mockito {
+    requires java.instrument;
+    requires jdk.attach;
+    requires net.bytebuddy;
+    requires net.bytebuddy.agent;
+    requires static junit;
+    requires static org.hamcrest;
+    requires static org.objenesis;
+    requires static org.opentest4j;
+    requires static jdk.unsupported;
+
+    exports org.mockito;
+    exports org.mockito.configuration;
+    exports org.mockito.creation.instance;
+    exports org.mockito.exceptions.base;
+    exports org.mockito.exceptions.misusing;
+    exports org.mockito.exceptions.verification;
+    exports org.mockito.exceptions.verification.junit;
+    exports org.mockito.exceptions.verification.opentest4j;
+    exports org.mockito.hamcrest;
+    exports org.mockito.invocation;
+    exports org.mockito.junit;
+    exports org.mockito.listeners;
+    exports org.mockito.mock;
+    exports org.mockito.plugins;
+    exports org.mockito.quality;
+    exports org.mockito.session;
+    exports org.mockito.stubbing;
+    exports org.mockito.verification;
+    exports org.mockito.internal to
+            java.instrument;
+    exports org.mockito.internal.configuration to
+            org.mockito.junit.jupiter;
+    exports org.mockito.internal.configuration.plugins to
+            org.mockito.junit.jupiter;
+    exports org.mockito.internal.session to
+            org.mockito.junit.jupiter;
+    exports org.mockito.internal.util to
+            org.mockito.junit.jupiter;
+}
diff --git a/src/main/java/org/mockito/AdditionalAnswers.java b/mockito-core/src/main/java/org/mockito/AdditionalAnswers.java
similarity index 97%
rename from src/main/java/org/mockito/AdditionalAnswers.java
rename to mockito-core/src/main/java/org/mockito/AdditionalAnswers.java
index 0281f32227..63ab9bb483 100644
--- a/src/main/java/org/mockito/AdditionalAnswers.java
+++ b/mockito-core/src/main/java/org/mockito/AdditionalAnswers.java
@@ -31,7 +31,7 @@
  *
  * <p>Currently offer answers that can return the parameter of an invocation at a certain position,
  * along with answers that draw on a strongly typed interface to provide a neater way to write custom answers
- * that either return a value or are void (see answer interfaces in {@link org.mockito.stubbing}).
+ * that either return a value or are void (see answer interfaces in org.mockito.stubbing).
  *
  * <p>See factory methods for more information : {@link #returnsFirstArg}, {@link #returnsSecondArg},
  * {@link #returnsLastArg}, {@link #returnsArgAt}, {@link #answer} and {@link #answerVoid}
@@ -39,7 +39,7 @@
  * @since 1.9.5
  */
 @SuppressWarnings("unchecked")
-public class AdditionalAnswers {
+public final class AdditionalAnswers {
     /**
      * Returns the first parameter of an invocation.
      *
@@ -276,7 +276,7 @@ public static <T> Answer<T> returnsArgAt(int position) {
      * This feature suffers from the same drawback as the spy.
      * The mock will call the delegate if you use regular when().then() stubbing style.
      * Since the real implementation is called this might have some side effects.
-     * Therefore you should to use the doReturn|Throw|Answer|CallRealMethod stubbing style. Example:
+     * Therefore, you should use the doReturn|Throw|Answer|CallRealMethod stubbing style. Example:
      *
      * <pre class="code"><code class="java">
      *   List listWithDelegate = mock(List.class, AdditionalAnswers.delegatesTo(awesomeList));
@@ -308,7 +308,7 @@ public static <T> Answer<T> delegatesTo(Object delegate) {
      *   when(mock.foo()).thenReturn(1, 2, 3);
      *
      *   //is equivalent to:
-     *   when(mock.foo()).thenAnswer(new ReturnsElementsOf(Arrays.asList(1, 2, 3)));
+     *   when(mock.foo()).thenAnswer(AdditionalAnswers.returnsElementsOf(Arrays.asList(1, 2, 3)));
      * </code></pre>
      *
      * @param elements The collection of elements to return.
@@ -330,7 +330,6 @@ public static <T> Answer<T> returnsElementsOf(Collection<?> elements) {
      *
      * @since 2.8.44
      */
-    @Incubating
     public static <T> Answer<T> answersWithDelay(long sleepyTime, Answer<T> answer) {
         return (Answer<T>) new AnswersWithDelay(sleepyTime, (Answer<Object>) answer);
     }
@@ -344,7 +343,6 @@ public static <T> Answer<T> answersWithDelay(long sleepyTime, Answer<T> answer)
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <T, A> Answer<T> answer(Answer1<T, A> answer) {
         return toAnswer(answer);
     }
@@ -357,7 +355,6 @@ public static <T, A> Answer<T> answer(Answer1<T, A> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <A> Answer<Void> answerVoid(VoidAnswer1<A> answer) {
         return toAnswer(answer);
     }
@@ -372,7 +369,6 @@ public static <A> Answer<Void> answerVoid(VoidAnswer1<A> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <T, A, B> Answer<T> answer(Answer2<T, A, B> answer) {
         return toAnswer(answer);
     }
@@ -386,7 +382,6 @@ public static <T, A, B> Answer<T> answer(Answer2<T, A, B> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <A, B> Answer<Void> answerVoid(VoidAnswer2<A, B> answer) {
         return toAnswer(answer);
     }
@@ -402,7 +397,6 @@ public static <A, B> Answer<Void> answerVoid(VoidAnswer2<A, B> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <T, A, B, C> Answer<T> answer(Answer3<T, A, B, C> answer) {
         return toAnswer(answer);
     }
@@ -417,7 +411,6 @@ public static <T, A, B, C> Answer<T> answer(Answer3<T, A, B, C> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <A, B, C> Answer<Void> answerVoid(VoidAnswer3<A, B, C> answer) {
         return toAnswer(answer);
     }
@@ -434,7 +427,6 @@ public static <A, B, C> Answer<Void> answerVoid(VoidAnswer3<A, B, C> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <T, A, B, C, D> Answer<T> answer(Answer4<T, A, B, C, D> answer) {
         return toAnswer(answer);
     }
@@ -450,7 +442,6 @@ public static <T, A, B, C, D> Answer<T> answer(Answer4<T, A, B, C, D> answer) {
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <A, B, C, D> Answer<Void> answerVoid(VoidAnswer4<A, B, C, D> answer) {
         return toAnswer(answer);
     }
@@ -468,7 +459,6 @@ public static <A, B, C, D> Answer<Void> answerVoid(VoidAnswer4<A, B, C, D> answe
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <T, A, B, C, D, E> Answer<T> answer(Answer5<T, A, B, C, D, E> answer) {
         return toAnswer(answer);
     }
@@ -486,7 +476,6 @@ public static <T, A, B, C, D, E> Answer<T> answer(Answer5<T, A, B, C, D, E> answ
      * @return the answer object to use
      * @since 2.1.0
      */
-    @Incubating
     public static <A, B, C, D, E> Answer<Void> answerVoid(VoidAnswer5<A, B, C, D, E> answer) {
         return toAnswer(answer);
     }
@@ -506,7 +495,6 @@ public static <A, B, C, D, E> Answer<Void> answerVoid(VoidAnswer5<A, B, C, D, E>
      * @return the answer object to use
      * @since 2.26.0
      */
-    @Incubating
     public static <T, A, B, C, D, E, F> Answer<T> answer(Answer6<T, A, B, C, D, E, F> answer) {
         return toAnswer(answer);
     }
@@ -525,8 +513,9 @@ public static <T, A, B, C, D, E, F> Answer<T> answer(Answer6<T, A, B, C, D, E, F
      * @return the answer object to use
      * @since 2.26.0
      */
-    @Incubating
     public static <A, B, C, D, E, F> Answer<Void> answerVoid(VoidAnswer6<A, B, C, D, E, F> answer) {
         return toAnswer(answer);
     }
+
+    private AdditionalAnswers() {}
 }
diff --git a/src/main/java/org/mockito/AdditionalMatchers.java b/mockito-core/src/main/java/org/mockito/AdditionalMatchers.java
similarity index 99%
rename from src/main/java/org/mockito/AdditionalMatchers.java
rename to mockito-core/src/main/java/org/mockito/AdditionalMatchers.java
index 319f92e304..2cb71c6a10 100644
--- a/src/main/java/org/mockito/AdditionalMatchers.java
+++ b/mockito-core/src/main/java/org/mockito/AdditionalMatchers.java
@@ -16,11 +16,11 @@
 import org.mockito.internal.matchers.LessThan;
 
 /**
- * See {@link Matchers} for general info about matchers.
+ * See {@link ArgumentMatchers} for general info about matchers.
  * <p>
  * AdditionalMatchers provides rarely used matchers, kept only for somewhat compatibility with EasyMock.
  * Use additional matchers very judiciously because they may impact readability of a test.
- * It is recommended to use matchers from {@link Matchers} and keep stubbing and verification simple.
+ * It is recommended to use matchers from {@link ArgumentMatchers} and keep stubbing and verification simple.
  * <p>
  * Example of using logical and(), not(), or() matchers:
  *
@@ -38,7 +38,7 @@
  * Scroll down to see all methods - full list of matchers.
  */
 @SuppressWarnings("ALL")
-public class AdditionalMatchers {
+public final class AdditionalMatchers {
 
     /**
      * argument greater than or equal the given value.
@@ -1054,4 +1054,6 @@ public static float eq(float value, float delta) {
     private static void reportMatcher(ArgumentMatcher<?> matcher) {
         mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher);
     }
+
+    private AdditionalMatchers() {}
 }
diff --git a/src/main/java/org/mockito/Answers.java b/mockito-core/src/main/java/org/mockito/Answers.java
similarity index 87%
rename from src/main/java/org/mockito/Answers.java
rename to mockito-core/src/main/java/org/mockito/Answers.java
index 5cbb1f71e6..30dc307437 100644
--- a/src/main/java/org/mockito/Answers.java
+++ b/mockito-core/src/main/java/org/mockito/Answers.java
@@ -24,7 +24,7 @@
  * </code></pre>
  * <b>This is not the full list</b> of Answers available in Mockito. Some interesting answers can be found in org.mockito.stubbing.answers package.
  */
-public enum Answers implements Answer<Object>{
+public enum Answers implements Answer<Object> {
     /**
      * The default configured answer of every mock.
      *
@@ -52,7 +52,6 @@ public enum Answers implements Answer<Object>{
      */
     RETURNS_MOCKS(new ReturnsMocks()),
 
-
     /**
      * An answer that returns <strong>deep stubs</strong> (not mocks).
      *
@@ -78,8 +77,7 @@ public enum Answers implements Answer<Object>{
      *
      * @see org.mockito.Mockito#RETURNS_SELF
      */
-    RETURNS_SELF(new TriesToReturnSelf())
-    ;
+    RETURNS_SELF(new TriesToReturnSelf());
 
     private final Answer<Object> implementation;
 
@@ -87,15 +85,7 @@ public enum Answers implements Answer<Object>{
         this.implementation = implementation;
     }
 
-    /**
-     * @deprecated as of 2.1.0 Use the enum-constant directly, instead of this getter. This method will be removed in a future release<br>
-     * E.g. instead of <code>Answers.CALLS_REAL_METHODS.get()</code> use <code>Answers.CALLS_REAL_METHODS</code> .
-     */
-    @Deprecated
-    public Answer<Object> get() {
-        return this;
-    }
-
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
         return implementation.answer(invocation);
     }
diff --git a/mockito-core/src/main/java/org/mockito/ArgumentCaptor.java b/mockito-core/src/main/java/org/mockito/ArgumentCaptor.java
new file mode 100644
index 0000000000..863c9a29b4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/ArgumentCaptor.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.internal.util.Primitives.defaultValue;
+
+import java.util.List;
+
+import org.mockito.internal.matchers.CapturingMatcher;
+
+/**
+ * Use it to capture argument values for further assertions.
+ *
+ * <p>
+ * Mockito verifies argument values in natural java style: by using an equals() method.
+ * This is also the recommended way of matching arguments because it makes tests clean and simple.
+ * In some situations though, it is helpful to assert on certain arguments after the actual verification.
+ * For example:
+ * <pre class="code"><code class="java">
+ *   ArgumentCaptor&lt;Person&gt; argument = ArgumentCaptor.forClass(Person.class);
+ *   verify(mock).doSomething(argument.capture());
+ *   assertEquals("John", argument.getValue().getName());
+ * </code></pre>
+ *
+ * Example of capturing varargs:
+ * <pre class="code"><code class="java">
+ *   //capturing varargs:
+ *   ArgumentCaptor&lt;Person&gt; varArgs = ArgumentCaptor.forClass(Person.class);
+ *   verify(mock).varArgMethod(varArgs.capture());
+ *   List expected = asList(new Person("John"), new Person("Jane"));
+ *   assertEquals(expected, varArgs.getAllValues());
+ * </code></pre>
+ *
+ * <p>
+ * <strong>Warning:</strong> it is recommended to use ArgumentCaptor with verification <strong>but not</strong> with stubbing.
+ * Using ArgumentCaptor with stubbing may decrease test readability because captor is created
+ * outside of assertion (aka verify or 'then') blocks.
+ * It may also reduce defect localization because if the stubbed method was not called, then no argument is captured.
+ *
+ * <p>
+ * In a way ArgumentCaptor is related to custom argument matchers (see javadoc for {@link ArgumentMatcher} class).
+ * Both techniques can be used for making sure certain arguments were passed to mock objects.
+ * However, ArgumentCaptor may be a better fit if:
+ * <ul>
+ * <li>custom argument matcher is not likely to be reused</li>
+ * <li>you just need it to assert on argument values to complete verification</li>
+ * </ul>
+ * Custom argument matchers via {@link ArgumentMatcher} are usually better for stubbing.
+ *
+ * <p>
+ * This utility class <strong>will</strong> perform type checking on the generic type (since Mockito 5.0.0).
+ * <p>
+ * There is an <strong>annotation</strong> that you might find useful: &#64;{@link Captor}
+ * <p>
+ * See the full documentation on Mockito in javadoc for {@link Mockito} class.
+ *
+ * @see Captor
+ * @since 1.8.0
+ */
+@CheckReturnValue
+public class ArgumentCaptor<T> {
+
+    private final CapturingMatcher<T> capturingMatcher;
+    private final Class<? extends T> clazz;
+
+    private ArgumentCaptor(Class<? extends T> clazz) {
+        this.clazz = clazz;
+        this.capturingMatcher = new CapturingMatcher<>(clazz);
+    }
+
+    /**
+     * Use it to capture the argument. This method <b>must be used inside of verification</b>.
+     * <p>
+     * Internally, this method registers a special implementation of an {@link ArgumentMatcher}.
+     * This argument matcher stores the argument value so that you can use it later to perform assertions.
+     * <p>
+     * See examples in javadoc for {@link ArgumentCaptor} class.
+     *
+     * @return null or default values
+     */
+    public T capture() {
+        T ignored = Mockito.argThat(capturingMatcher);
+        return defaultValue(clazz);
+    }
+
+    /**
+     * Returns the captured value of the argument. When capturing varargs use {@link #getAllValues()}.
+     * <p>
+     * If verified method was called multiple times then this method returns the latest captured value.
+     * <p>
+     * See examples in javadoc for {@link ArgumentCaptor} class.
+     *
+     * @return captured argument value
+     */
+    public T getValue() {
+        return this.capturingMatcher.getLastValue();
+    }
+
+    /**
+     * Returns all captured values. Use it when capturing varargs or when the verified method was called multiple times.
+     * When varargs method was called multiple times, this method returns merged list of all values from all invocations.
+     * <p>
+     * Example:
+     * <pre class="code"><code class="java">
+     *   mock.doSomething(new Person("John");
+     *   mock.doSomething(new Person("Jane");
+     *
+     *   ArgumentCaptor&lt;Person&gt; peopleCaptor = ArgumentCaptor.forClass(Person.class);
+     *   verify(mock, times(2)).doSomething(peopleCaptor.capture());
+     *
+     *   List&lt;Person&gt; capturedPeople = peopleCaptor.getAllValues();
+     *   assertEquals("John", capturedPeople.get(0).getName());
+     *   assertEquals("Jane", capturedPeople.get(1).getName());
+     * </pre>
+     *
+     * Example of capturing varargs:
+     * <pre class="code"><code class="java">
+     *   mock.countPeople(new Person("John"), new Person("Jane"); //vararg method
+     *
+     *   ArgumentCaptor&lt;Person&gt; peopleCaptor = ArgumentCaptor.forClass(Person.class);
+     *
+     *   verify(mock).countPeople(peopleCaptor.capture());
+     *
+     *   List expected = asList(new Person("John"), new Person("Jane"));
+     *   assertEquals(expected, peopleCaptor.getAllValues());
+     * </code></pre>
+     * See more examples in javadoc for {@link ArgumentCaptor} class.
+     *
+     * @return captured argument value
+     */
+    public List<T> getAllValues() {
+        return this.capturingMatcher.getAllValues();
+    }
+
+    /**
+     * Build a new <code>ArgumentCaptor</code>.
+     * <p>
+     * An <code>ArgumentCaptor</code> will perform type checks (since Mockito 5.0.0).
+     *
+     * @param clazz Type matching the parameter to be captured.
+     * @param <S> Type of clazz
+     * @param <U> Type of object captured by the newly built ArgumentCaptor
+     * @return A new ArgumentCaptor
+     */
+    public static <U, S extends U> ArgumentCaptor<U> forClass(Class<S> clazz) {
+        return new ArgumentCaptor<>(clazz);
+    }
+
+    /**
+     * Build a new <code>ArgumentCaptor</code> by inferring the class type.
+     * <p>
+     * This enables inferring the generic type of an argument captor without
+     * providing a raw class reference, which enables working around generic
+     * limitations of the Java compiler without producing compile-time warnings
+     * unlike {@link #forClass} which would require explicit casting or warning
+     * suppression.
+     * <p>
+     * Example usage:
+     *
+     * <pre class="code"><code class="java">
+     *   // Given
+     *   UserRepository repository = mock();
+     *   UserService service = new UserService(repository);
+     *
+     *   Map&lt;String, User&gt; expectedUsers = Map.of(
+     *       "12345", new User("12345", "Bob"),
+     *       "45678", new User("45678", "Dave")
+     *   );
+     *
+     *   ArgumentCaptor&lt;Map&lt;String, User&gt;&gt; captor = ArgumentCaptor.captor();
+     *
+     *   doNothing().when(repository).storeUsers(captor.capture());
+     *
+     *   // When
+     *   service.createUsers(List.of(
+     *       new User("12345", "Bob"),
+     *       new User("45678", "Dave")
+     *   ));
+     *
+     *   // Then
+     *   Map&lt;String, User&gt; actualUsers = captor.getValue();
+     *
+     *   assertThat(expectedUsers).isEqualTo(actualUsers);
+     * </code></pre>
+     *
+     * @param reified do not pass any value here. This is used to trick the compiler
+     *     into reifying the return type without needing casts.
+     * @param <U> the type of argument to be captured by this captor.
+     * @return A new ArgumentCaptor.
+     * @throws IllegalArgumentException if any arguments are passed to this method.
+     * @since 5.7.0
+     */
+    @SafeVarargs
+    @SuppressWarnings({"varargs", "unchecked"})
+    public static <U> ArgumentCaptor<U> captor(U... reified) {
+        if (reified == null || reified.length > 0) {
+            throw new IllegalArgumentException("Do not provide any arguments to the 'captor' call");
+        }
+
+        return forClass((Class<U>) reified.getClass().getComponentType());
+    }
+
+    /**
+     * Get the raw class being captured.
+     *
+     * @return the raw class that is being captured by this captor.
+     */
+    Class<? extends T> getCaptorType() {
+        return clazz;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/ArgumentMatcher.java b/mockito-core/src/main/java/org/mockito/ArgumentMatcher.java
new file mode 100644
index 0000000000..3c8ccdea00
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/ArgumentMatcher.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+/**
+ * Allows creating customized argument matchers.
+ * This API was changed in Mockito 2.1.0 in an effort to decouple Mockito from Hamcrest
+ * and reduce the risk of version incompatibility.
+ * Migration guide is included close to the bottom of this javadoc.
+ * <p>
+ * For non-trivial method arguments used in stubbing or verification, you have the following options
+ * (in no particular order):
+ * <ul>
+ *     <li>refactor the code so that the interactions with collaborators are easier to test with mocks.
+ *     Perhaps it is possible to pass a different argument to the method so that mocking is easier?
+ *     If stuff is hard to test it usually indicates the design could be better, so do refactor for testability!
+ *     </li>
+ *     <li>don't match the argument strictly, just use one of the lenient argument matchers like
+ *     {@link Mockito#notNull()}. Some times it is better to have a simple test that works than
+ *     a complicated test that seem to work.
+ *     </li>
+ *     <li>implement equals() method in the objects that are used as arguments to mocks.
+ *     Mockito naturally uses equals() for argument matching.
+ *     Many times, this is option is clean and simple.
+ *     </li>
+ *     <li>use {@link ArgumentCaptor} to capture the arguments and perform assertions on their state.
+ *     Useful when you need to verify the arguments. Captor is not useful if you need argument matching for stubbing.
+ *     Many times, this option leads to clean and readable tests with fine-grained validation of arguments.
+ *     </li>
+ *     <li>use customized argument matchers by implementing {@link ArgumentMatcher} interface
+ *     and passing the implementation to the {@link Mockito#argThat} method.
+ *     This option is useful if custom matcher is needed for stubbing and can be reused a lot.
+ *     Note that {@link Mockito#argThat} demonstrates <b>NullPointerException</b> auto-unboxing caveat.
+ *     </li>
+ *     <li>use an instance of hamcrest matcher and pass it to
+ *     {@link org.mockito.hamcrest.MockitoHamcrest#argThat(org.hamcrest.Matcher)}
+ *     Useful if you already have a hamcrest matcher. Reuse and win!
+ *     Note that {@link org.mockito.hamcrest.MockitoHamcrest#argThat(org.hamcrest.Matcher)} demonstrates <b>NullPointerException</b> auto-unboxing caveat.
+ *     </li>
+ *     <li>Java 8 only - use a lambda in place of an {@link ArgumentMatcher} since {@link ArgumentMatcher}
+ *     is effectively a functional interface. A lambda can be used with the {@link Mockito#argThat} method.</li>
+ * </ul>
+ *
+ * <p>
+ * Implementations of this interface can be used with {@link ArgumentMatchers#argThat} method.
+ * Use <code>toString()</code> method for description of the matcher
+ * - it is printed in verification errors.
+ *
+ * <pre class="code"><code class="java">
+ * class ListOfTwoElements implements ArgumentMatcher&lt;List&gt; {
+ *     public boolean matches(List list) {
+ *         return list.size() == 2;
+ *     }
+ *     public String toString() {
+ *         //printed in verification errors
+ *         return "[list of 2 elements]";
+ *     }
+ * }
+ *
+ * List mock = mock(List.class);
+ *
+ * when(mock.addAll(argThat(new ListOfTwoElements()))).thenReturn(true);
+ *
+ * mock.addAll(Arrays.asList(&quot;one&quot;, &quot;two&quot;));
+ *
+ * verify(mock).addAll(argThat(new ListOfTwoElements()));
+ * </code></pre>
+ *
+ * To keep it readable you can extract method, e.g:
+ *
+ * <pre class="code"><code class="java">
+ *   verify(mock).addAll(<b>argThat(new ListOfTwoElements())</b>);
+ *   //becomes
+ *   verify(mock).addAll(<b>listOfTwoElements()</b>);
+ * </code></pre>
+ *
+ * In Java 8 you can treat ArgumentMatcher as a functional interface
+ * and use a lambda, e.g.:
+ *
+ * <pre class="code"><code class="java">
+ *   verify(mock).addAll(<b>argThat(list -&gt; list.size() == 2)</b>);
+ * </code></pre>
+ *
+ * <p>
+ * Read more about other matchers in javadoc for {@link ArgumentMatchers} class.
+ * <h2>2.1.0 migration guide</h2>
+ *
+ * All existing custom implementations of <code>ArgumentMatcher</code> will no longer compile.
+ * All locations where hamcrest matchers are passed to <code>argThat()</code> will no longer compile.
+ * There are 2 approaches to fix the problems:
+ * <ul>
+ * <li>a) Refactor the hamcrest matcher to Mockito matcher:
+ * Use "implements ArgumentMatcher" instead of "extends ArgumentMatcher".
+ * Then refactor <code>describeTo()</code> method into <code>toString()</code> method.
+ * </li>
+ * <li>
+ * b) Use <code>org.mockito.hamcrest.MockitoHamcrest.argThat()</code> instead of <code>Mockito.argThat()</code>.
+ * Ensure that there is <a href="http://hamcrest.org/JavaHamcrest/">hamcrest</a> dependency on classpath
+ * (Mockito does not depend on hamcrest any more).
+ *
+ * </li>
+ * </ul>
+ * What option is right for you? If you don't mind having a compile-time dependency for Hamcrest,
+ * then the second option is probably right for you.
+ * Your choice should not have a big impact and is fully reversible -
+ * you can choose different option in future (and refactor the code)!
+ *
+ * @param <T> type of argument
+ * @since 2.1.0
+ */
+@FunctionalInterface
+public interface ArgumentMatcher<T> {
+
+    /**
+     * Informs if this matcher accepts the given argument.
+     * <p>
+     * The method should <b>never</b> assert if the argument doesn't match. It
+     * should only return false.
+     * <p>
+     * See the example in the top level javadoc for {@link ArgumentMatcher}
+     *
+     * @param argument
+     *            the argument
+     * @return true if this matcher accepts the given argument.
+     */
+    boolean matches(T argument);
+
+    /**
+     * The type of the argument this matcher matches.
+     *
+     * <p>This method is used to differentiate between a matcher used to match a raw vararg array parameter
+     * from a matcher used to match a single value passed as a vararg parameter.
+     *
+     * <p>Where the matcher:
+     * <ul>
+     *     <li>is at the parameter index of a vararg parameter</li>
+     *     <li>is the last matcher passed</li>
+     *     <li>this method returns a type assignable to the vararg parameter's raw type, i.e. its array type.</li>
+     * </ul>
+     *
+     * ...then the matcher is matched against the raw vararg parameter, rather than the first element of the raw parameter.
+     *
+     * <p>For example:
+     *
+     * <pre class="code"><code class="java">
+     *  // Given vararg method with signature:
+     *  int someVarargMethod(String... args);
+     *
+     *  // The following will match invocations with any number of parameters, i.e. any number of elements in the raw array.
+     *  mock.someVarargMethod(isA(String[].class));
+     *
+     *  // The following will match invocations with a single parameter, i.e. one string in the raw array.
+     *  mock.someVarargMethod(isA(String.class));
+     *
+     *  // The following will match invocations with two parameters, i.e. two strings in the raw array
+     *  mock.someVarargMethod(isA(String.class), isA(String.class));
+     * </code></pre>
+     *
+     * <p>Only matcher implementations that can conceptually match a raw vararg parameter should override this method.
+     *
+     * @return the type this matcher handles. The default value of {@link Void} means the type is not known.
+     * @since 4.11.0
+     */
+    default Class<?> type() {
+        return Void.class;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/ArgumentMatchers.java b/mockito-core/src/main/java/org/mockito/ArgumentMatchers.java
new file mode 100644
index 0000000000..05580a7c29
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/ArgumentMatchers.java
@@ -0,0 +1,1074 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import static org.mockito.internal.util.Primitives.defaultValue;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.regex.Pattern;
+
+import org.mockito.internal.matchers.Any;
+import org.mockito.internal.matchers.Contains;
+import org.mockito.internal.matchers.EndsWith;
+import org.mockito.internal.matchers.Equals;
+import org.mockito.internal.matchers.InstanceOf;
+import org.mockito.internal.matchers.Matches;
+import org.mockito.internal.matchers.NotNull;
+import org.mockito.internal.matchers.Null;
+import org.mockito.internal.matchers.Same;
+import org.mockito.internal.matchers.StartsWith;
+import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
+import org.mockito.internal.util.Primitives;
+
+/**
+ * Allow flexible verification or stubbing. See also {@link AdditionalMatchers}.
+ *
+ * <pre class="code"><code class="java">
+ * //stubbing using anyInt() argument matcher
+ * when(mockedList.get(anyInt())).thenReturn("element");
+ *
+ * //following prints "element"
+ * System.out.println(mockedList.get(999));
+ *
+ * //you can also verify using argument matcher
+ * verify(mockedList).get(anyInt());
+ * </code></pre>
+ *
+ * <p>
+ * Since Mockito <code>any(Class)</code> and <code>anyInt</code> family matchers perform a type check, thus they won't
+ * match <code>null</code> arguments. Instead use the <code>isNull</code> matcher.
+ *
+ * <pre class="code"><code class="java">
+ * // stubbing using anyBoolean() argument matcher
+ * when(mock.dryRun(anyBoolean())).thenReturn("state");
+ *
+ * // below the stub won't match, and won't return "state"
+ * mock.dryRun(null);
+ *
+ * // either change the stub
+ * when(mock.dryRun(isNull())).thenReturn("state");
+ * mock.dryRun(null); // ok
+ *
+ * // or fix the code ;)
+ * when(mock.dryRun(anyBoolean())).thenReturn("state");
+ * mock.dryRun(true); // ok
+ *
+ * </code></pre>
+ *
+ * The same apply for verification.
+ * </p>
+ *
+ *
+ * Scroll down to see all methods - full list of matchers.
+ *
+ * <p>
+ * <b>Warning:</b><br/>
+ *
+ * If you are using argument matchers, <b>all arguments</b> have to be provided by matchers.
+ *
+ * E.g: (example shows verification but the same applies to stubbing):
+ * </p>
+ *
+ * <pre class="code"><code class="java">
+ * verify(mock).someMethod(anyInt(), anyString(), <b>eq("third argument")</b>);
+ * //above is correct - eq() is also an argument matcher
+ *
+ * verify(mock).someMethod(anyInt(), anyString(), <b>"third argument"</b>);
+ * //above is incorrect - exception will be thrown because third argument is given without argument matcher.
+ * </code></pre>
+ *
+ * <p>
+ * Matcher methods like <code>any()</code>, <code>eq()</code> <b>do not</b> return matchers.
+ * Internally, they record a matcher on a stack and return a dummy value (usually null).
+ * This implementation is due to static type safety imposed by java compiler.
+ * The consequence is that you cannot use <code>any()</code>, <code>eq()</code> methods outside of verified/stubbed method.
+ * </p>
+ *
+ * <h1>Additional matchers</h1>
+ * <p>
+ * The class {@link AdditionalMatchers} offers rarely used matchers, although they can be useful, when
+ * it is useful to combine multiple matchers or when it is useful to negate a matcher necessary.
+ * </p>
+ *
+ * <h1>Custom Argument ArgumentMatchers</h1>
+ * <p>
+ * It is important to understand the use cases and available options for dealing with non-trivial arguments
+ * <b>before</b> implementing custom argument matchers. This way, you can select the best possible approach
+ * for given scenario and produce highest quality test (clean and maintainable).
+ * Please read on in the javadoc for {@link ArgumentMatcher} to learn about approaches and see the examples.
+ * </p>
+ *
+ * @see AdditionalMatchers
+ */
+@CheckReturnValue
+@SuppressWarnings("unchecked")
+public class ArgumentMatchers {
+
+    /**
+     * Matches <strong>anything</strong>, including nulls.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * <p>
+     * <strong>Notes : </strong><br/>
+     * <ul>
+     *     <li>For primitive types use {@link #anyChar()} family or {@link #isA(Class)} or {@link #any(Class)}.</li>
+     *     <li>Since Mockito 2.1.0 {@link #any(Class)} is not anymore an alias of this method.</li>
+     *     <li>Since Mockito 5.0.0 this no longer matches varargs. Use {@link #any(Class)} instead.</li>
+     * </ul>
+     * </p>
+     *
+     * @return <code>null</code>.
+     *
+     * @see #any(Class)
+     * @see #anyChar()
+     * @see #anyInt()
+     * @see #anyBoolean()
+     */
+    public static <T> T any() {
+        reportMatcher(Any.ANY);
+        return null;
+    }
+
+    /**
+     * Matches any object of given type, excluding nulls.
+     *
+     * <p>
+     * This matcher will perform a type check with the given type, thus excluding values.
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     *
+     * This is an alias of: {@link #isA(Class)}}
+     * </p>
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null instance of <code></code>, thus <code>null</code> is not anymore a valid value.
+     * As reference are nullable, the suggested API to <strong>match</strong> <code>null</code>
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p><strong>Notes : </strong><br/>
+     * <ul>
+     *     <li>For primitive types use {@link #anyChar()} family.</li>
+     *     <li>Since Mockito 2.1.0 this method will perform a type check thus <code>null</code> values are not authorized.</li>
+     *     <li>Since Mockito 2.1.0 {@link #any()} is no longer an alias of this method.</li>
+     *     <li>Since Mockito 5.0.0 this method can match varargs if the array type is specified, for example <code>any(String[].class)</code>.</li>
+     * </ul>
+     * </p>
+     *
+     * @param <T> The accepted type
+     * @param type the class of the accepted type.
+     * @return <code>null</code>.
+     * @see #any()
+     * @see #isA(Class)
+     * @see #notNull()
+     * @see #isNull()
+     */
+    public static <T> T any(Class<T> type) {
+        reportMatcher(new InstanceOf(type, "<any " + type.getCanonicalName() + ">"));
+        return defaultValue(type);
+    }
+
+    /**
+     * <code>Object</code> argument that implements the given class.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param <T>  the accepted type.
+     * @param type the class of the accepted type.
+     * @return <code>null</code>.
+     * @see #any(Class)
+     */
+    public static <T> T isA(Class<T> type) {
+        reportMatcher(new InstanceOf(type));
+        return defaultValue(type);
+    }
+
+    /**
+     * Any <code>boolean</code> or <strong>non-null</strong> <code>Boolean</code>
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Boolean</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>false</code>.
+     * @see #isNull()
+     */
+    public static boolean anyBoolean() {
+        reportMatcher(new InstanceOf(Boolean.class, "<any boolean>"));
+        return false;
+    }
+
+    /**
+     * Any <code>byte</code> or <strong>non-null</strong> <code>Byte</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Byte</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static byte anyByte() {
+        reportMatcher(new InstanceOf(Byte.class, "<any byte>"));
+        return 0;
+    }
+
+    /**
+     * Any <code>char</code> or <strong>non-null</strong> <code>Character</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Character</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static char anyChar() {
+        reportMatcher(new InstanceOf(Character.class, "<any char>"));
+        return 0;
+    }
+
+    /**
+     * Any int or <strong>non-null</strong> <code>Integer</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Integer</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static int anyInt() {
+        reportMatcher(new InstanceOf(Integer.class, "<any integer>"));
+        return 0;
+    }
+
+    /**
+     * Any <code>long</code> or <strong>non-null</strong> <code>Long</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Long</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static long anyLong() {
+        reportMatcher(new InstanceOf(Long.class, "<any long>"));
+        return 0;
+    }
+
+    /**
+     * Any <code>float</code> or <strong>non-null</strong> <code>Float</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Float</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static float anyFloat() {
+        reportMatcher(new InstanceOf(Float.class, "<any float>"));
+        return 0;
+    }
+
+    /**
+     * Any <code>double</code> or <strong>non-null</strong> <code>Double</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Double</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static double anyDouble() {
+        reportMatcher(new InstanceOf(Double.class, "<any double>"));
+        return 0;
+    }
+
+    /**
+     * Any <code>short</code> or <strong>non-null</strong> <code>Short</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow valued <code>Short</code>, thus <code>null</code> is not anymore a valid value.
+     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return <code>0</code>.
+     * @see #isNull()
+     */
+    public static short anyShort() {
+        reportMatcher(new InstanceOf(Short.class, "<any short>"));
+        return 0;
+    }
+
+    /**
+     * Any <strong>non-null</strong> <code>String</code>
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null <code>String</code>.
+     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return empty String ("")
+     * @see #isNull()
+     */
+    public static String anyString() {
+        reportMatcher(new InstanceOf(String.class, "<any string>"));
+        return "";
+    }
+
+    /**
+     * Any <strong>non-null</strong> <code>List</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null <code>List</code>.
+     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return empty List.
+     * @see #isNull()
+     */
+    public static <T> List<T> anyList() {
+        reportMatcher(new InstanceOf(List.class, "<any List>"));
+        return new ArrayList<T>(0);
+    }
+
+    /**
+     * Any <strong>non-null</strong> <code>Set</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null <code>Set</code>.
+     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return empty Set
+     * @see #isNull()
+     */
+    public static <T> Set<T> anySet() {
+        reportMatcher(new InstanceOf(Set.class, "<any set>"));
+        return new HashSet<T>(0);
+    }
+
+    /**
+     * Any <strong>non-null</strong> <code>Map</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null <code>Map</code>.
+     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return empty Map.
+     * @see #isNull()
+     */
+    public static <K, V> Map<K, V> anyMap() {
+        reportMatcher(new InstanceOf(Map.class, "<any map>"));
+        return new HashMap<K, V>(0);
+    }
+
+    /**
+     * Any <strong>non-null</strong> <code>Collection</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null <code>Collection</code>.
+     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return empty Collection.
+     * @see #isNull()
+     */
+    public static <T> Collection<T> anyCollection() {
+        reportMatcher(new InstanceOf(Collection.class, "<any collection>"));
+        return new ArrayList<T>(0);
+    }
+
+    /**
+     * Any <strong>non-null</strong> <code>Iterable</code>.
+     *
+     * <p>
+     * Since Mockito 2.1.0, only allow non-null <code>Iterable</code>.
+     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
+     * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
+     * 1.x.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class.
+     * </p>
+     *
+     * @return empty Iterable.
+     * @see #isNull()
+     * @since 2.1.0
+     */
+    public static <T> Iterable<T> anyIterable() {
+        reportMatcher(new InstanceOf(Iterable.class, "<any iterable>"));
+        return new ArrayList<T>(0);
+    }
+
+    /**
+     * <code>boolean</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static boolean eq(boolean value) {
+        reportMatcher(new Equals(value));
+        return false;
+    }
+
+    /**
+     * <code>byte</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static byte eq(byte value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * <code>char</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static char eq(char value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * <code>double</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static double eq(double value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * <code>float</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static float eq(float value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * <code>int</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static int eq(int value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * <code>long</code> argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static long eq(long value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * <code>short</code> argument that is equal to the given value.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param value the given value.
+     * @return <code>0</code>.
+     */
+    public static short eq(short value) {
+        reportMatcher(new Equals(value));
+        return 0;
+    }
+
+    /**
+     * Object argument that is equal to the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value the given value.
+     * @return <code>null</code>.
+     */
+    public static <T> T eq(T value) {
+        reportMatcher(new Equals(value));
+        if (value == null) return null;
+        return (T) Primitives.defaultValue(value.getClass());
+    }
+
+    /**
+     * Object argument that is reflection-equal to the given value with support for excluding
+     * selected fields from a class.
+     *
+     * <p>
+     * This matcher can be used when equals() is not implemented on compared objects.
+     * Matcher uses java reflection API to compare fields of wanted and actual object.
+     * </p>
+     *
+     * <p>
+     * Works similarly to <code>EqualsBuilder.reflectionEquals(this, other, excludeFields)</code> from
+     * apache commons library.
+     * <p>
+     * <b>Warning</b> The equality check is shallow!
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param value         the given value.
+     * @param excludeFields fields to exclude, if field does not exist it is ignored.
+     * @return <code>null</code>.
+     */
+    public static <T> T refEq(T value, String... excludeFields) {
+        reportMatcher(new ReflectionEquals(value, excludeFields));
+        return null;
+    }
+
+    /**
+     * Object argument that is the same as the given value.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param <T>   the type of the object, it is passed through to prevent casts.
+     * @param value the given value.
+     * @return <code>null</code>.
+     */
+    public static <T> T same(T value) {
+        reportMatcher(new Same(value));
+        if (value == null) {
+            return null;
+        }
+        return (T) Primitives.defaultValue(value.getClass());
+    }
+
+    /**
+     * <code>null</code> argument.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @return <code>null</code>.
+     * @see #isNotNull()
+     */
+    public static <T> T isNull() {
+        reportMatcher(Null.NULL);
+        return null;
+    }
+
+    /**
+     * <code>null</code> argument.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param type the type of the argument being matched.
+     * @return <code>null</code>.
+     * @see #isNotNull(Class)
+     * @since 4.11.0
+     */
+    public static <T> T isNull(Class<T> type) {
+        reportMatcher(new Null<>(type));
+        return null;
+    }
+
+    /**
+     * Not <code>null</code> argument.
+     *
+     * <p>
+     * Alias to {@link ArgumentMatchers#isNotNull()}
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @return <code>null</code>.
+     */
+    public static <T> T notNull() {
+        reportMatcher(NotNull.NOT_NULL);
+        return null;
+    }
+
+    /**
+     * Not <code>null</code> argument.
+     *
+     * <p>
+     * Alias to {@link ArgumentMatchers#isNotNull()}
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param type the type of the argument being matched.
+     * @return <code>null</code>.
+     * @since 4.11.0
+     */
+    public static <T> T notNull(Class<T> type) {
+        reportMatcher(new NotNull<>(type));
+        return null;
+    }
+
+    /**
+     * Not <code>null</code> argument.
+     *
+     * <p>
+     * Alias to {@link ArgumentMatchers#notNull()}
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @return <code>null</code>.
+     * @see #isNull()
+     */
+    public static <T> T isNotNull() {
+        return notNull();
+    }
+
+    /**
+     * Not <code>null</code> argument.
+     *
+     * <p>
+     * Alias to {@link ArgumentMatchers#notNull(Class)}
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param type the type of the argument being matched.
+     * @return <code>null</code>.
+     * @see #isNull()
+     * @since 4.11.0
+     */
+    public static <T> T isNotNull(Class<T> type) {
+        return notNull(type);
+    }
+
+    /**
+     * Argument that is either <code>null</code> or of the given type.
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     * </p>
+     *
+     * @param clazz Type to avoid casting
+     * @return <code>null</code>.
+     */
+    public static <T> T nullable(Class<T> clazz) {
+        AdditionalMatchers.or(isNull(), isA(clazz));
+        return Primitives.defaultValue(clazz);
+    }
+
+    /**
+     * <code>String</code> argument that contains the given substring.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param substring the substring.
+     * @return empty String ("").
+     */
+    public static String contains(String substring) {
+        reportMatcher(new Contains(substring));
+        return "";
+    }
+
+    /**
+     * <code>String</code> argument that matches the given regular expression.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param regex the regular expression.
+     * @return empty String ("").
+     *
+     * @see AdditionalMatchers#not(boolean)
+     */
+    public static String matches(String regex) {
+        reportMatcher(new Matches(regex));
+        return "";
+    }
+
+    /**
+     * <code>Pattern</code> argument that matches the given regular expression.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param pattern the regular expression pattern.
+     * @return empty String ("").
+     *
+     * @see AdditionalMatchers#not(boolean)
+     */
+    public static String matches(Pattern pattern) {
+        reportMatcher(new Matches(pattern));
+        return "";
+    }
+
+    /**
+     * <code>String</code> argument that ends with the given suffix.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param suffix the suffix.
+     * @return empty String ("").
+     */
+    public static String endsWith(String suffix) {
+        reportMatcher(new EndsWith(suffix));
+        return "";
+    }
+
+    /**
+     * <code>String</code> argument that starts with the given prefix.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param prefix the prefix.
+     * @return empty String ("").
+     */
+    public static String startsWith(String prefix) {
+        reportMatcher(new StartsWith(prefix));
+        return "";
+    }
+
+    /**
+     * Allows creating custom argument matchers.
+     *
+     * <p>
+     * This API has changed in 2.1.0, please read {@link ArgumentMatcher} for rationale and migration guide.
+     * <b>NullPointerException</b> auto-unboxing caveat is described below.
+     * </p>
+     *
+     * <p>
+     * It is important to understand the use cases and available options for dealing with non-trivial arguments
+     * <b>before</b> implementing custom argument matchers. This way, you can select the best possible approach
+     * for given scenario and produce highest quality test (clean and maintainable).
+     * Please read the documentation for {@link ArgumentMatcher} to learn about approaches and see the examples.
+     * </p>
+     *
+     * <p>
+     * <b>NullPointerException</b> auto-unboxing caveat.
+     * In rare cases when matching primitive parameter types you <b>*must*</b> use relevant intThat(), floatThat(), etc. method.
+     * This way you will avoid <code>NullPointerException</code> during auto-unboxing.
+     * Due to how java works we don't really have a clean way of detecting this scenario and protecting the user from this problem.
+     * Hopefully, the javadoc describes the problem and solution well.
+     * If you have an idea how to fix the problem, let us know via the mailing list or the issue tracker.
+     * </p>
+     *
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatcher} class
+     * </p>
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>null</code>.
+     */
+    public static <T> T argThat(ArgumentMatcher<T> matcher) {
+        reportMatcher(matcher);
+        return null;
+    }
+
+    /**
+     * Allows creating custom argument matchers where matching is considered successful when the consumer given by parameter does not throw an exception.
+     * <p>
+     * Typically used with {@link Mockito#verify(Object)} to execute assertions on parameters passed to the verified method invocation.
+     *
+     * @param consumer executes assertions on the verified argument
+     * @return <code>null</code>.
+     */
+    public static <T> T assertArg(Consumer<T> consumer) {
+        return argThat(
+                argument -> {
+                    consumer.accept(argument);
+                    return true;
+                });
+    }
+
+    /**
+     * Allows creating custom argument matchers where matching is considered successful when the consumer given by parameter does not throw an exception.
+     * Consumer is allowed to throw exception other than RuntimeException
+     * <p>
+     * Typically used with {@link Mockito#verify(Object)} to execute assertions on parameters passed to the verified method invocation.
+     *
+     * @param consumer executes assertions on the verified argument
+     * @return <code>null</code>.
+     */
+    public static <T> T assertArg(ThrowingConsumer<T> consumer) {
+        return argThat(
+                argument -> {
+                    consumer.accept(argument);
+                    return true;
+                });
+    }
+
+    /**
+     * Allows creating custom <code>char</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>char</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static char charThat(ArgumentMatcher<Character> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    /**
+     * Allows creating custom <code>boolean</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>boolean</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>false</code>.
+     */
+    public static boolean booleanThat(ArgumentMatcher<Boolean> matcher) {
+        reportMatcher(matcher);
+        return false;
+    }
+
+    /**
+     * Allows creating custom <code>byte</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>byte</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static byte byteThat(ArgumentMatcher<Byte> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    /**
+     * Allows creating custom <code>short</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>short</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static short shortThat(ArgumentMatcher<Short> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    /**
+     * Allows creating custom <code>int</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>int</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static int intThat(ArgumentMatcher<Integer> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    /**
+     * Allows creating custom <code>long</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>long</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static long longThat(ArgumentMatcher<Long> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    /**
+     * Allows creating custom <code>float</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>float</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static float floatThat(ArgumentMatcher<Float> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    /**
+     * Allows creating custom <code>double</code> argument matchers.
+     * <p>
+     * Note that {@link #argThat} will not work with primitive <code>double</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
+     * <p>
+     * See examples in javadoc for {@link ArgumentMatchers} class
+     *
+     * @param matcher decides whether argument matches
+     * @return <code>0</code>.
+     */
+    public static double doubleThat(ArgumentMatcher<Double> matcher) {
+        reportMatcher(matcher);
+        return 0;
+    }
+
+    private static void reportMatcher(ArgumentMatcher<?> matcher) {
+        mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher);
+    }
+}
diff --git a/src/main/java/org/mockito/BDDMockito.java b/mockito-core/src/main/java/org/mockito/BDDMockito.java
similarity index 87%
rename from src/main/java/org/mockito/BDDMockito.java
rename to mockito-core/src/main/java/org/mockito/BDDMockito.java
index b2dbf6e751..d37a07ae93 100644
--- a/src/main/java/org/mockito/BDDMockito.java
+++ b/mockito-core/src/main/java/org/mockito/BDDMockito.java
@@ -13,7 +13,7 @@
  * Behavior Driven Development style of writing tests uses <b>//given //when //then</b> comments as fundamental parts of your test methods.
  * This is exactly how we write our tests and we warmly encourage you to do so!
  * <p>
- * Start learning about BDD here: <a href="http://en.wikipedia.org/wiki/Behavior_Driven_Development">http://en.wikipedia.org/wiki/Behavior_Driven_Development</a>
+ * Start learning about BDD here: <a href="https://en.wikipedia.org/wiki/Behavior-driven_development">https://en.wikipedia.org/wiki/Behavior-driven_development</a>
  * <p>
  * The problem is that current stubbing api with canonical role of <b>when</b> word does not integrate nicely with <b>//given //when //then</b> comments.
  * It's because stubbing belongs to <b>given</b> component of the test and not to the <b>when</b> component of the test.
@@ -127,9 +127,12 @@ public interface BDDMyOngoingStubbing<T> {
          * See original {@link OngoingStubbing#thenThrow(Class, Class[])}
          * @since 2.1.0
          */
-        // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation
-        @SuppressWarnings ({"unchecked", "varargs"})
-        BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableType, Class<? extends Throwable>... throwableTypes);
+        // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+        // creation
+        @SuppressWarnings({"unchecked", "varargs"})
+        BDDMyOngoingStubbing<T> willThrow(
+                Class<? extends Throwable> throwableType,
+                Class<? extends Throwable>... throwableTypes);
 
         /**
          * See original {@link OngoingStubbing#thenCallRealMethod()}
@@ -176,8 +179,11 @@ public BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableTyp
             return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwableType));
         }
 
-        public BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableType, Class<? extends Throwable>... throwableTypes) {
-            return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwableType, throwableTypes));
+        public BDDMyOngoingStubbing<T> willThrow(
+                Class<? extends Throwable> throwableType,
+                Class<? extends Throwable>... throwableTypes) {
+            return new BDDOngoingStubbingImpl<T>(
+                    mockitoOngoingStubbing.thenThrow(throwableType, throwableTypes));
         }
 
         public BDDMyOngoingStubbing<T> willCallRealMethod() {
@@ -248,14 +254,6 @@ public interface Then<T> {
          */
         T should(InOrder inOrder, VerificationMode mode);
 
-        /**
-         * @see #verifyZeroInteractions(Object...)
-         * @since 2.1.0
-         * @deprecated Since 3.0.1. Please migrate your code to {@link #shouldHaveNoInteractions()}
-         */
-        @Deprecated
-        void shouldHaveZeroInteractions();
-
         /**
          * @see #verifyNoMoreInteractions(Object...)
          * @since 2.1.0
@@ -309,14 +307,6 @@ public T should(InOrder inOrder, VerificationMode mode) {
             return inOrder.verify(mock, mode);
         }
 
-        /**
-         * @see #verifyZeroInteractions(Object...)
-         * @since 2.1.0
-         */
-        public void shouldHaveZeroInteractions() {
-            verifyZeroInteractions(mock);
-        }
-
         /**
          * @see #verifyNoMoreInteractions(Object...)
          * @since 2.1.0
@@ -351,17 +341,6 @@ public interface BDDStubber {
          */
         BDDStubber will(Answer<?> answer);
 
-        /**
-         * See original {@link Stubber#doNothing()}.
-         *
-         * This method will be removed in version 3.0.0
-         *
-         * @since 1.8.0
-         * @deprecated as of 2.1.0 please use {@link #willDoNothing()} instead
-         */
-        @Deprecated
-        BDDStubber willNothing();
-
         /**
          * See original {@link Stubber#doNothing()}
          * @since 1.10.20
@@ -397,8 +376,10 @@ public interface BDDStubber {
          * See original {@link Stubber#doThrow(Class, Class[])}
          * @since 2.1.0
          */
-        @SuppressWarnings ({"unchecked", "varargs"})
-        BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
+        @SuppressWarnings({"unchecked", "varargs"})
+        BDDStubber willThrow(
+                Class<? extends Throwable> toBeThrown,
+                Class<? extends Throwable>... nextToBeThrown);
 
         /**
          * See original {@link Stubber#doCallRealMethod()}
@@ -433,14 +414,6 @@ public BDDStubber will(Answer<?> answer) {
             return new BDDStubberImpl(mockitoStubber.doAnswer(answer));
         }
 
-        /**
-         * @deprecated please use {@link #willDoNothing()} instead
-         */
-        @Deprecated
-        public BDDStubber willNothing() {
-            return willDoNothing();
-        }
-
         public BDDStubber willDoNothing() {
             return new BDDStubberImpl(mockitoStubber.doNothing());
         }
@@ -450,7 +423,8 @@ public BDDStubber willReturn(Object toBeReturned) {
         }
 
         public BDDStubber willReturn(Object toBeReturned, Object... nextToBeReturned) {
-            return new BDDStubberImpl(mockitoStubber.doReturn(toBeReturned).doReturn(nextToBeReturned));
+            return new BDDStubberImpl(
+                    mockitoStubber.doReturn(toBeReturned).doReturn(nextToBeReturned));
         }
 
         public BDDStubber willThrow(Throwable... toBeThrown) {
@@ -461,7 +435,9 @@ public BDDStubber willThrow(Class<? extends Throwable> toBeThrown) {
             return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown));
         }
 
-        public BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+        public BDDStubber willThrow(
+                Class<? extends Throwable> toBeThrown,
+                Class<? extends Throwable>... nextToBeThrown) {
             return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown, nextToBeThrown));
         }
 
@@ -490,7 +466,8 @@ public static BDDStubber willThrow(Class<? extends Throwable> toBeThrown) {
      * see original {@link Mockito#doThrow(Class)}
      * @since 1.9.0
      */
-    public static BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... throwableTypes) {
+    public static BDDStubber willThrow(
+            Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... throwableTypes) {
         return new BDDStubberImpl(Mockito.doThrow(toBeThrown, throwableTypes));
     }
 
diff --git a/mockito-core/src/main/java/org/mockito/Captor.java b/mockito-core/src/main/java/org/mockito/Captor.java
new file mode 100644
index 0000000000..cedd60e242
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/Captor.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Allows shorthand {@link org.mockito.ArgumentCaptor} creation on fields.
+ *
+ * <p>Example:
+ * <pre class="code"><code class="java">
+ * public class Test{
+ *
+ *    &#64;Captor ArgumentCaptor&lt;AsyncCallback&lt;Foo&gt;&gt; captor;
+ *
+ *    private AutoCloseable closeable;
+ *
+ *    &#64;Before
+ *    public void open() {
+ *       closeable = MockitoAnnotations.openMocks(this);
+ *    }
+ *
+ *    &#64;After
+ *    public void release() throws Exception {
+ *       closeable.close();
+ *    }
+ *
+ *    &#64;Test public void shouldDoSomethingUseful() {
+ *       //...
+ *       verify(mock).doStuff(captor.capture());
+ *       assertEquals("foo", captor.getValue());
+ *    }
+ * }
+ * </code></pre>
+ *
+ * <p>
+ * One of the advantages of using &#64;Captor annotation is that you can avoid warnings related capturing complex generic types.
+ *
+ * @see ArgumentCaptor
+ * @since 1.8.3
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.PARAMETER})
+@Documented
+public @interface Captor {}
diff --git a/src/main/java/org/mockito/CheckReturnValue.java b/mockito-core/src/main/java/org/mockito/CheckReturnValue.java
similarity index 80%
rename from src/main/java/org/mockito/CheckReturnValue.java
rename to mockito-core/src/main/java/org/mockito/CheckReturnValue.java
index 0498c148a8..935b3207f6 100644
--- a/src/main/java/org/mockito/CheckReturnValue.java
+++ b/mockito-core/src/main/java/org/mockito/CheckReturnValue.java
@@ -9,7 +9,6 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-
 /**
  * This annotation is not supposed to be used by Mockito end-users. Instead, we
  * use it to annotate methods for Static Analysis tools, including FindBugs and ErrorProne.
@@ -18,15 +17,9 @@
  * This annotation is public, because we have to use it in multiple packages.
  *
  * @see <a href="https://github.com/findbugsproject/findbugs/blob/264ae7baf890d2b347d91805c90057062b5dcb1e/findbugs/src/java/edu/umd/cs/findbugs/detect/BuildCheckReturnAnnotationDatabase.java#L120">Findbugs source code</a>
- * @see <a href="http://errorprone.info/bugpattern/CheckReturnValue">ErrorProne check</a>
+ * @see <a href="https://errorprone.info/bugpattern/CheckReturnValue">ErrorProne check</a>
  * @since 2.11.4
  */
-@Target({
-    ElementType.CONSTRUCTOR,
-    ElementType.METHOD,
-    ElementType.PACKAGE,
-    ElementType.TYPE
-})
+@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PACKAGE, ElementType.TYPE})
 @Retention(RetentionPolicy.CLASS)
-public @interface CheckReturnValue {
-}
+public @interface CheckReturnValue {}
diff --git a/mockito-core/src/main/java/org/mockito/DoNotMock.java b/mockito-core/src/main/java/org/mockito/DoNotMock.java
new file mode 100644
index 0000000000..fb2de8ecf4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/DoNotMock.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation representing a type that should not be mocked.
+ * <p>When marking a type {@code @DoNotMock}, you should always point to alternative testing
+ * solutions such as standard fakes or other testing utilities.
+ *
+ * Mockito enforces {@code @DoNotMock} with the {@link org.mockito.plugins.DoNotMockEnforcer}.
+ *
+ * If you want to use a custom {@code @DoNotMock} annotation, the {@link org.mockito.plugins.DoNotMockEnforcer}
+ * will match on annotations with a type ending in "org.mockito.DoNotMock". You can thus place
+ * your custom annotation in {@code com.my.package.org.mockito.DoNotMock} and Mockito will enforce
+ * that types annotated by {@code @com.my.package.org.mockito.DoNotMock} can not be mocked.
+ *
+ * <pre class="code"><code class="java">
+ * &#064;DoNotMock(reason = "Use a real instance instead")
+ * class DoNotMockMe {}
+ * </code></pre>
+ */
+@Target({TYPE})
+@Retention(RUNTIME)
+@Documented
+public @interface DoNotMock {
+    /**
+     * The reason why the annotated type should not be mocked.
+     *
+     * <p>This should suggest alternative APIs to use for testing objects of this type.
+     */
+    String reason() default "Create a real instance instead.";
+}
diff --git a/mockito-core/src/main/java/org/mockito/InOrder.java b/mockito-core/src/main/java/org/mockito/InOrder.java
new file mode 100644
index 0000000000..ee71ae197c
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/InOrder.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.Mockito.times;
+
+import org.mockito.verification.VerificationMode;
+
+/**
+ * Allows verification in order. E.g:
+ *
+ * <pre class="code"><code class="java">
+ * // Given
+ * First firstMock = mock(First.class);
+ * Second secondMock = mock(Second.class);
+ * InOrder inOrder = inOrder(firstMock, secondMock);
+ *
+ * // When
+ * firstMock.add("was called first");
+ * secondMock.add("was called second");
+ *
+ * // Then
+ * inOrder.verify(firstMock).add("was called first");
+ * inOrder.verify(secondMock).add("was called second");
+ * inOrder.verifyNoMoreInteractions();
+ * </code></pre>
+ *
+ * Static mocks can be verified alongside non-static mocks. E.g:
+ *
+ * <pre class="code"><code class="java">
+ * // Given
+ * First firstMock = mock(First.class);
+ * MockedStatic<StaticSecond> staticSecondMock = mockStatic(StaticSecond.class);
+ * InOrder inOrder = inOrder(firstMock, StaticSecond.class);
+ *
+ * // When
+ * firstMock.add("was called first");
+ * StaticSecond.doSomething("foobar");
+ *
+ * // Then
+ * inOrder.verify(firstMock).add("was called first");
+ * inOrder.verify(staticSecondMock, () -&gt; StaticSecond.doSomething("foobar"));
+ * inOrder.verifyNoMoreInteractions();
+ * </code></pre>
+ *
+ * As of Mockito 1.8.4 you can verifyNoMoreInteractions() in order-sensitive way. Read more:
+ * {@link InOrder#verifyNoMoreInteractions()}.
+ * <p>
+ *
+ * See examples in javadoc for {@link Mockito} class
+ */
+public interface InOrder {
+    /**
+     * Verifies interaction <b>happened once</b> in order.
+     * <p>
+     * Alias to <code>inOrder.verify(mock, times(1))</code>
+     * <p>
+     * Example:
+     * <pre class="code"><code class="java">
+     * InOrder inOrder = inOrder(firstMock, secondMock);
+     *
+     * inOrder.verify(firstMock).someMethod("was called first");
+     * inOrder.verify(secondMock).someMethod("was called second");
+     * </code></pre>
+     *
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param mock to be verified
+     *
+     * @return mock object itself
+     */
+    <T> T verify(T mock);
+
+    /**
+     * Verifies interaction in order. E.g:
+     *
+     * <pre class="code"><code class="java">
+     * InOrder inOrder = inOrder(firstMock, secondMock);
+     *
+     * inOrder.verify(firstMock, times(2)).someMethod("was called first two times");
+     * inOrder.verify(secondMock, atLeastOnce()).someMethod("was called second at least once");
+     * </code></pre>
+     *
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param mock to be verified
+     * @param mode for example times(x) or atLeastOnce()
+     *
+     * @return mock object itself
+     */
+    <T> T verify(T mock, VerificationMode mode);
+
+    /**
+     * Verifies static interaction in order, with exactly one number of invocations.
+     *
+     * @see #verify(MockedStatic, MockedStatic.Verification, VerificationMode)
+     */
+    default void verify(MockedStatic<?> mockedStatic, MockedStatic.Verification verification) {
+        verify(mockedStatic, verification, times(1));
+    }
+
+    /**
+     * Verifies static interaction in order. E.g:
+     *
+     * <pre class="code"><code class="java">
+     * try (MockedStatic<Foo> mocked = mockStatic(Foo.class)) {
+     *   InOrder inOrder = inOrder(Foo.class);
+     *
+     *   mocked.when(Foo::firstMethod).thenReturn("first");
+     *   mocked.when(Foo::secondMethod).thenReturn("second");
+     *
+     *   assertEquals("first", Foo.firstMethod());
+     *   assertEquals("second", Foo.secondMethod());
+     *
+     *   inOrder.verify(mocked, Foo::firstMethod, times(1));
+     *   inOrder.verify(mocked, Foo::secondMethod, atLeastOnce());
+     * }
+     * </code></pre>
+     *
+     * @param mockedStatic static mock to be verified
+     * @param verification verification to be verified
+     * @param mode         for example times(x) or atLeastOnce()
+     */
+    void verify(
+            MockedStatic<?> mockedStatic,
+            MockedStatic.Verification verification,
+            VerificationMode mode);
+
+    /**
+     * Verifies that no more interactions happened <b>in order</b>.
+     * Different from {@link Mockito#verifyNoMoreInteractions(Object...)} because the order of verification matters.
+     * <p>
+     * Example:
+     * <pre class="code"><code class="java">
+     * mock.foo(); //1st
+     * mock.bar(); //2nd
+     * mock.baz(); //3rd
+     *
+     * InOrder inOrder = inOrder(mock);
+     *
+     * inOrder.verify(mock).bar(); //2n
+     * inOrder.verify(mock).baz(); //3rd (last method)
+     *
+     * //passes because there are no more interactions after last method:
+     * inOrder.verifyNoMoreInteractions();
+     *
+     * //however this fails because 1st method was not verified:
+     * Mockito.verifyNoMoreInteractions(mock);
+     * </code></pre>
+     */
+    void verifyNoMoreInteractions();
+}
diff --git a/src/main/java/org/mockito/Incubating.java b/mockito-core/src/main/java/org/mockito/Incubating.java
similarity index 75%
rename from src/main/java/org/mockito/Incubating.java
rename to mockito-core/src/main/java/org/mockito/Incubating.java
index 2cdfaddf41..ba209b3c41 100644
--- a/src/main/java/org/mockito/Incubating.java
+++ b/mockito-core/src/main/java/org/mockito/Incubating.java
@@ -5,6 +5,7 @@
 package org.mockito;
 
 import java.lang.annotation.Documented;
+import java.lang.annotation.Inherited;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
@@ -22,8 +23,13 @@
  * and can change before release.
  * </li>
  * </ul>
+ *
+ * <p>
+ * Any components extending a class or interface annotated with this annotation should also
+ * be considered to be incubating, as the underlying implementation may be subject to future change
+ * before it is finalized.
  */
 @Retention(RetentionPolicy.RUNTIME)
+@Inherited
 @Documented
-public @interface Incubating {
-}
+public @interface Incubating {}
diff --git a/src/main/java/org/mockito/InjectMocks.java b/mockito-core/src/main/java/org/mockito/InjectMocks.java
similarity index 87%
rename from src/main/java/org/mockito/InjectMocks.java
rename to mockito-core/src/main/java/org/mockito/InjectMocks.java
index 375c35514d..c804126641 100644
--- a/src/main/java/org/mockito/InjectMocks.java
+++ b/mockito-core/src/main/java/org/mockito/InjectMocks.java
@@ -22,14 +22,14 @@
  * </ul>
  * <p>
  * Mockito will try to inject mocks only either by constructor injection,
- * setter injection, or property injection in order and as described below.
+ * property injection or setter injection in order and as described below.
  * If any of the following strategy fail, then Mockito <strong>won't report failure</strong>;
  * i.e. you will have to provide dependencies yourself.
  * <ol>
  *     <li><strong>Constructor injection</strong>; the biggest constructor is chosen,
  *     then arguments are resolved with mocks declared in the test only. If the object is successfully created
  *     with the constructor, then <strong>Mockito won't try the other strategies</strong>. Mockito has decided to no
- *     corrupt an object if it has a parametered constructor.
+ *     corrupt an object if it has a parameterized constructor.
  *     <p><u>Note:</u> If arguments can not be found, then null is passed.
  *     If non-mockable types are wanted, then constructor injection won't happen.
  *     In these cases, you will have to satisfy dependencies yourself.</p></li>
@@ -71,8 +71,14 @@
  *
  *   public class SampleBaseTestCase {
  *
- *       &#064;Before public void initMocks() {
- *           MockitoAnnotations.initMocks(this);
+ *       private AutoCloseable closeable;
+ *
+ *       &#064;Before public void openMocks() {
+ *           closeable = MockitoAnnotations.openMocks(this);
+ *       }
+ *
+ *       &#064;After public void releaseMocks() throws Exception {
+ *           closeable.close();
  *       }
  *   }
  * </code></pre>
@@ -141,11 +147,10 @@
  * </p>
  *
  * <p>
- * <strong><code>MockitoAnnotations.initMocks(this)</code></strong> method has to be called to initialize annotated objects.
- * In above example, <code>initMocks()</code> is called in &#064;Before (JUnit4) method of test's base class.
- * For JUnit3 <code>initMocks()</code> can go to <code>setup()</code> method of a base class.
- * <strong>Instead</strong> you can also put initMocks() in your JUnit runner (&#064;RunWith) or use the built-in
- * {@link MockitoJUnitRunner}.
+ * <strong><code>MockitoAnnotations.openMocks(this)</code></strong> method has to be called to initialize annotated objects.
+ * In above example, <code>openMocks()</code> is called in &#064;Before (JUnit4) method of test's base class.
+ * <strong>Instead</strong> you can also put openMocks() in your JUnit runner (&#064;RunWith) or use the built-in
+ * {@link MockitoJUnitRunner}. Also, make sure to release any mocks after disposing your test class with a corresponding hook.
  * </p>
  *
  * <p>
@@ -153,9 +158,14 @@
  * be it mocks/spies or real objects.
  * </p>
  *
+ * <p>
+ * Elements annotated with this annotation can also be spied upon by also adding the {@link Spy}
+ * annotation to the element.
+ * </p>
+ *
  * @see Mock
  * @see Spy
- * @see MockitoAnnotations#initMocks(Object)
+ * @see MockitoAnnotations#openMocks(Object)
  * @see MockitoJUnitRunner
  * @since 1.8.3
  */
diff --git a/mockito-core/src/main/java/org/mockito/Mock.java b/mockito-core/src/main/java/org/mockito/Mock.java
new file mode 100644
index 0000000000..4d94edfe26
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/Mock.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.plugins.MockMaker;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Mark a field as a mock.
+ *
+ * <ul>
+ * <li>Allows shorthand mock creation.</li>
+ * <li>Minimizes repetitive mock creation code.</li>
+ * <li>Makes the test class more readable.</li>
+ * <li>Makes the verification error easier to read because the <b>field name</b> is used to identify the mock.</li>
+ * <li>Automatically detects static mocks of type {@link MockedStatic} and infers the static mock type of the type parameter.</li>
+ * </ul>
+ *
+ * <pre class="code"><code class="java">
+ *   public class ArticleManagerTest extends SampleBaseTestCase {
+ *
+ *       &#064;Mock private ArticleCalculator calculator;
+ *       &#064;Mock(name = "database") private ArticleDatabase dbMock;
+ *       &#064;Mock(answer = RETURNS_MOCKS) private UserProvider userProvider;
+ *       &#064;Mock(extraInterfaces = {Queue.class, Observer.class}) private ArticleMonitor articleMonitor;
+ *       &#064;Mock(strictness = Mock.Strictness.LENIENT) private ArticleConsumer articleConsumer;
+ *       &#064;Mock(stubOnly = true) private Logger logger;
+ *
+ *       private ArticleManager manager;
+ *
+ *       &#064;Before public void setup() {
+ *           manager = new ArticleManager(userProvider, database, calculator, articleMonitor, articleConsumer, logger);
+ *       }
+ *   }
+ *
+ *   public class SampleBaseTestCase {
+ *
+ *       private AutoCloseable closeable;
+ *
+ *       &#064;Before public void openMocks() {
+ *           closeable = MockitoAnnotations.openMocks(this);
+ *       }
+ *
+ *       &#064;After public void releaseMocks() throws Exception {
+ *           closeable.close();
+ *       }
+ *   }
+ * </code></pre>
+ *
+ * <p>
+ * <strong><code>MockitoAnnotations.openMocks(this)</code></strong> method has to be called to initialize annotated objects.
+ * In above example, <code>openMocks()</code> is called in &#064;Before (JUnit4) method of test's base class.
+ * <strong>Instead</strong> you can also put openMocks() in your JUnit runner (&#064;RunWith) or use the built-in
+ * {@link MockitoJUnitRunner}. Also, make sure to release any mocks after disposing your test class with a corresponding hook.
+ * </p>
+ *
+ * @see Mockito#mock(Class)
+ * @see Spy
+ * @see InjectMocks
+ * @see MockitoAnnotations#openMocks(Object)
+ * @see MockitoJUnitRunner
+ */
+@Target({FIELD, PARAMETER})
+@Retention(RUNTIME)
+@Documented
+public @interface Mock {
+
+    /**
+     * Mock will have custom answer, see {@link MockSettings#defaultAnswer(Answer)}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     */
+    Answers answer() default Answers.RETURNS_DEFAULTS;
+
+    /**
+     * Mock will be 'stubOnly', see {@link MockSettings#stubOnly()}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     */
+    boolean stubOnly() default false;
+
+    /**
+     * Mock will have custom name (shown in verification errors), see {@link MockSettings#name(String)}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     */
+    String name() default "";
+
+    /**
+     * Mock will have extra interfaces, see {@link MockSettings#extraInterfaces(Class[])}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     */
+    Class<?>[] extraInterfaces() default {};
+
+    /**
+     * Mock will be serializable, see {@link MockSettings#serializable()}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     */
+    boolean serializable() default false;
+
+    /**
+     * @deprecated Use {@link Mock#strictness()} instead.
+     *
+     * Mock will be lenient, see {@link MockSettings#lenient()}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     *
+     * @since 2.23.3
+     */
+    @Deprecated
+    boolean lenient() default false;
+
+    /**
+     * Mock will have custom strictness, see {@link MockSettings#strictness(org.mockito.quality.Strictness)}.
+     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+     *
+     * @since 4.6.1
+     */
+    Strictness strictness() default Strictness.TEST_LEVEL_DEFAULT;
+
+    /**
+     * Mock will be created by the given {@link MockMaker}, see {@link MockSettings#mockMaker(String)}.
+     *
+     * @since 4.8.0
+     */
+    String mockMaker() default "";
+
+    /**
+     * Mock will not attempt to preserve all annotation metadata, see {@link MockSettings#withoutAnnotations()}.
+     *
+     * @since 5.3.0
+     */
+    boolean withoutAnnotations() default false;
+
+    enum Strictness {
+
+        /**
+         * Default value used to indicate the mock does not override the test level strictness.
+         *
+         * @since 4.6.1
+         */
+        TEST_LEVEL_DEFAULT,
+
+        /**
+         * See {@link org.mockito.quality.Strictness#LENIENT}
+         */
+        LENIENT,
+
+        /**
+         * See {@link org.mockito.quality.Strictness#WARN}
+         */
+        WARN,
+
+        /**
+         * See {@link org.mockito.quality.Strictness#STRICT_STUBS}
+         */
+        STRICT_STUBS
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/MockMakers.java b/mockito-core/src/main/java/org/mockito/MockMakers.java
new file mode 100644
index 0000000000..028a06a922
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/MockMakers.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.mockito.plugins.MockMaker;
+
+/**
+ * Constants for built-in implementations of {@code MockMaker}.
+ * You may use the constants of this class for {@link MockSettings#mockMaker(String)} or {@link Mock#mockMaker()}.
+ * The string values of these constants may also be used in the resource file <code>mockito-extensions/org.mockito.plugins.MockMaker</code>
+ * as described in the class documentation of {@link MockMaker}.
+ *
+ * @since 4.8.0
+ */
+public final class MockMakers {
+    /**
+     * Inline mock maker which can mock final types, enums and final methods.
+     * This mock maker cannot mock native methods,
+     * and it does not support {@link MockSettings#extraInterfaces(Class[]) extra interfaces}.
+     *
+     * @see <a href="Mockito.html#39">Mocking final types, enums and final methods</a>
+     */
+    public static final String INLINE = "mock-maker-inline";
+
+    /**
+     * Proxy mock maker which avoids code generation, but can only mock interfaces.
+     *
+     * @see <a href="Mockito.html#50">Avoiding code generation when restricting mocks to interfaces</a>
+     */
+    public static final String PROXY = "mock-maker-proxy";
+
+    /**
+     * Subclass mock maker which mocks types by creating subclasses.
+     * This is the first built-in mock maker which has been provided by Mockito.
+     * Since this mock maker relies on subclasses, it cannot mock final classes and methods.
+     */
+    public static final String SUBCLASS = "mock-maker-subclass";
+
+    private MockMakers() {}
+}
diff --git a/src/main/java/org/mockito/MockSettings.java b/mockito-core/src/main/java/org/mockito/MockSettings.java
similarity index 78%
rename from src/main/java/org/mockito/MockSettings.java
rename to mockito-core/src/main/java/org/mockito/MockSettings.java
index 30496d164c..e9c75c3a1e 100644
--- a/src/main/java/org/mockito/MockSettings.java
+++ b/mockito-core/src/main/java/org/mockito/MockSettings.java
@@ -5,6 +5,7 @@
 package org.mockito;
 
 import java.io.Serializable;
+import java.lang.reflect.Type;
 
 import org.mockito.exceptions.misusing.PotentialStubbingProblem;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
@@ -15,6 +16,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 
@@ -23,12 +25,12 @@
  * <p/>
  * Don't use it too often.
  * Consider writing simple tests that use simple mocks.
- * Repeat after me: simple tests push simple, KISSy, readable & maintainable code.
+ * Repeat after me: simple tests push simple, KISSy, readable and maintainable code.
  * If you cannot write a test in a simple way - refactor the code under test.
  * <p/>
  * Examples of mock settings:
  * <pre class="code"><code class="java">
- *   //Creates mock with different default answer & name
+ *   //Creates mock with different default answer and name
  *   Foo mock = mock(Foo.class, withSettings()
  *                                .defaultAnswer(RETURNS_SMART_NULLS)
  *                                .name("cool mockie")
@@ -42,7 +44,7 @@
  * </code></pre>
  * {@link MockSettings} has been introduced for two reasons.
  * Firstly, to make it easy to add another mock setting when the demand comes.
- * Secondly, to enable combining together different mock settings without introducing zillions of overloaded mock() methods.
+ * Secondly, to enable combining different mock settings without introducing zillions of overloaded mock() methods.
  */
 @NotExtensible
 public interface MockSettings extends Serializable {
@@ -51,8 +53,8 @@ public interface MockSettings extends Serializable {
      * Specifies extra interfaces the mock should implement. Might be useful for legacy code or some corner cases.
      * <p>
      * This mysterious feature should be used very occasionally.
-     * The object under test should know exactly its collaborators & dependencies.
-     * If you happen to use it often than please make sure you are really producing simple, clean & readable code.
+     * The object under test should know exactly its collaborators and dependencies.
+     * If you happen to use it often than please make sure you are really producing simple, clean and readable code.
      * <p>
      * Examples:
      * <pre class="code"><code class="java">
@@ -63,7 +65,7 @@ public interface MockSettings extends Serializable {
      *   Baz baz = (Baz) foo;
      * </code></pre>
      *
-     * @param interfaces extra interfaces the should implement.
+     * @param interfaces extra interfaces the mock should implement.
      * @return settings instance so that you can fluently specify other settings
      */
     MockSettings extraInterfaces(Class<?>... interfaces);
@@ -93,7 +95,7 @@ public interface MockSettings extends Serializable {
      *
      * Sets the instance that will be spied. Actually copies the internal fields of the passed instance to the mock.
      * <p>
-     * As usual you are going to read <b>the partial mock warning</b>:
+     * As usual, you are going to read <b>the partial mock warning</b>:
      * Object oriented programming is more or less about tackling complexity by dividing the complexity into separate, specific, SRPy objects.
      * How does partial mock fit into this paradigm? Well, it just doesn't...
      * Partial mock usually means that the complexity has been moved to a different method on the same object.
@@ -101,7 +103,7 @@ public interface MockSettings extends Serializable {
      * <p>
      * However, there are rare cases when partial mocks come handy:
      * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
-     * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+     * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
      * <p>
      * Enough warnings about partial mocks, see an example how spiedInstance() works:
      * <pre class="code"><code class="java">
@@ -132,10 +134,10 @@ public interface MockSettings extends Serializable {
 
     /**
      * Specifies default answers to interactions.
-     * It's quite advanced feature and typically you don't need it to write decent tests.
-     * However it can be helpful when working with legacy systems.
+     * It's quite advanced feature, and typically you don't need it to write decent tests.
+     * However, it can be helpful when working with legacy systems.
      * <p>
-     * It is the default answer so it will be used <b>only when you don't</b> stub the method call.
+     * It is the default answer, so it will be used <b>only when you don't</b> stub the method call.
      *
      * <pre class="code"><code class="java">
      *   Foo mock = mock(Foo.class, withSettings().defaultAnswer(RETURNS_SMART_NULLS));
@@ -208,7 +210,7 @@ public interface MockSettings extends Serializable {
     /**
      * Add stubbing lookup listener to the mock object.
      *
-     * Multiple listeners may be added and they will be notified orderly.
+     * Multiple listeners may be added, and they will be notified in an orderly fashion.
      *
      * For use cases and more info see {@link StubbingLookupListener}.
      *
@@ -227,7 +229,7 @@ public interface MockSettings extends Serializable {
      * Registers a listener for method invocations on this mock. The listener is
      * notified every time a method on this mock is called.
      * <p>
-     * Multiple listeners may be added and they will be notified in the order they were supplied.
+     * Multiple listeners may be added, and they will be notified in the order they were supplied.
      *
      * Example:
      * <pre class="code"><code class="java">
@@ -246,7 +248,7 @@ public interface MockSettings extends Serializable {
      * See {@link VerificationStartedListener} on how such listener can be useful.
      * <p>
      * When multiple listeners are added, they are notified in order they were supplied.
-     * There is no reason to supply multiple listeners but we wanted to keep the API
+     * There is no reason to supply multiple listeners, but we wanted to keep the API
      * simple and consistent with {@link #invocationListeners(InvocationListener...)}.
      * <p>
      * Throws exception when any of the passed listeners is null or when the entire vararg array is null.
@@ -255,7 +257,6 @@ public interface MockSettings extends Serializable {
      * @return settings instance so that you can fluently specify other settings
      * @since 2.11.0
      */
-    @Incubating
     MockSettings verificationStartedListeners(VerificationStartedListener... listeners);
 
     /**
@@ -296,7 +297,6 @@ public interface MockSettings extends Serializable {
      * @return settings instance so that you can fluently specify other settings
      * @since 2.7.14 (useConstructor with no arguments was supported since 1.10.12)
      */
-    @Incubating
     MockSettings useConstructor(Object... args);
 
     /**
@@ -311,18 +311,16 @@ public interface MockSettings extends Serializable {
      * @return settings instance so that you can fluently specify other settings
      * @since 1.10.12
      */
-    @Incubating
     MockSettings outerInstance(Object outerClassInstance);
 
     /**
-     * By default, Mockito makes an attempt to preserve all annotation meta data on the mocked
+     * By default, Mockito makes an attempt to preserve all annotation metadata on the mocked
      * type and its methods to mirror the mocked type as closely as possible. If this is not
      * desired, this option can be used to disable this behavior.
      *
      * @return settings instance so that you can fluently specify other settings
      * @since 1.10.13
      */
-    @Incubating
     MockSettings withoutAnnotations();
 
     /**
@@ -337,10 +335,25 @@ public interface MockSettings extends Serializable {
      * @return immutable view of mock settings
      * @since 2.10.0
      */
-    @Incubating
     <T> MockCreationSettings<T> build(Class<T> typeToMock);
 
     /**
+     * Creates immutable view of mock settings used later by Mockito, for use within a static mocking.
+     * Framework integrators can use this method to create instances of creation settings
+     * and use them in advanced use cases, for example to create invocations with {@link InvocationFactory},
+     * or to implement custom {@link MockHandler}.
+     * Since {@link MockCreationSettings} is {@link NotExtensible}, Mockito public API needs a creation method for this type.
+     *
+     * @param classToMock class to mock
+     * @param <T> type to mock
+     * @return immutable view of mock settings
+     * @since 2.10.0
+     */
+    <T> MockCreationSettings<T> buildStatic(Class<T> classToMock);
+
+    /**
+     * @deprecated Use {@link MockSettings#strictness(Strictness)} instead.
+     *
      * 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}.
@@ -351,6 +364,51 @@ public interface MockSettings extends Serializable {
      *
      * For more information and an elaborate example, see {@link Mockito#lenient()}.
      */
-    @Incubating
+    @Deprecated
     MockSettings lenient();
+
+    /**
+     * Specifies strictness level for the mock.
+     * The default strictness level is determined by the rule/runner used.
+     * If you are using no rule/runner, the default strictness level is LENIENT
+     *
+     * <pre class="code"><code class="java">
+     *   Foo defaultStrictMock = mock(Foo.class);
+     *   Foo explicitStrictMock = mock(Foo.class, withSettings().strictness(Strictness.STRICT_STUBS));
+     *   Foo lenientMock = mock(Foo.class, withSettings().strictness(Strictness.LENIENT));
+     * </code></pre>
+     *
+     * @param strictness the strictness level to set on mock
+     * @return settings instance so that you can fluently specify other settings
+     * @since 4.6.0
+     */
+    MockSettings strictness(Strictness strictness);
+
+    /**
+     * Specifies the {@code MockMaker} for the mock.
+     * The default depends on your project as described in the class documentation of {@link MockMaker}.
+     * You should usually use the default, this option primarily exists to ease migrations.
+     * You may specify either one of the constants from {@link MockMakers},
+     * <pre>
+     *     Object mock = Mockito.mock(Object.class, Mockito.withSettings()
+     *             .mockMaker(MockMakers.INLINE));
+     * </pre>
+     * or the {@link Class#getName() binary name} of a class which implements the {@code MockMaker} interface.
+     * <pre>
+     *     Object mock = Mockito.mock(Object.class, Mockito.withSettings()
+     *             .mockMaker("org.awesome.mockito.AwesomeMockMaker"));
+     * </pre>
+     *
+     * @param mockMaker the {@code MockMaker} to use for the mock
+     * @return settings instance so that you can fluently specify other settings
+     * @since 4.8.0
+     */
+    MockSettings mockMaker(String mockMaker);
+
+    /**
+     * Specifies the generic type of the mock, preserving the information lost to Java type erasure.
+     * @param genericTypeToMock
+     * @return
+     */
+    MockSettings genericTypeToMock(Type genericTypeToMock);
 }
diff --git a/mockito-core/src/main/java/org/mockito/MockedConstruction.java b/mockito-core/src/main/java/org/mockito/MockedConstruction.java
new file mode 100644
index 0000000000..ccf78c73a2
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/MockedConstruction.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import java.lang.reflect.Constructor;
+import java.util.List;
+
+/**
+ * Represents a mock of any object construction of the represented type. Within the scope of the
+ * mocked construction, the invocation of any interceptor will generate a mock which will be
+ * prepared as specified when generating this scope. The mock can also be received via this
+ * instance.
+ * <p>
+ * If the {@link Mock} annotation is used on fields or method parameters of this type, a mocked
+ * construction is created instead of a regular mock. The mocked construction is activated and
+ * released upon completing any relevant test.
+ *
+ * @param <T> The type for which the construction is being mocked.
+ */
+public interface MockedConstruction<T> extends ScopedMock {
+
+    /**
+     * Get the constructed mocks.
+     *
+     * @return the constructed mocks.
+     */
+    List<T> constructed();
+
+    /**
+     * The context for a construction mock.
+     */
+    interface Context {
+
+        int getCount();
+
+        /**
+         * Get the constructor that is invoked during the mock creation.
+         *
+         * @return the constructor.
+         */
+        Constructor<?> constructor();
+
+        /**
+         * Get the arguments that were passed to the constructor.
+         *
+         * @return the arguments passed to the constructor, as a list.
+         */
+        List<?> arguments();
+    }
+
+    /**
+     * Functional interface that consumes a newly created mock and the mock context.
+     * <p>
+     * Used to attach behaviours to new mocks.
+     *
+     * @param <T> the mock type.
+     */
+    @FunctionalInterface
+    interface MockInitializer<T> {
+
+        /**
+         * Configure the mock.
+         *
+         * @param mock the newly created mock.
+         * @param context the mock context.
+         * @throws Throwable any exception that may be thrown.
+         */
+        void prepare(T mock, Context context) throws Throwable;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/MockedStatic.java b/mockito-core/src/main/java/org/mockito/MockedStatic.java
new file mode 100644
index 0000000000..113bee2e3a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/MockedStatic.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.Mockito.times;
+
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.verification.VerificationMode;
+
+/**
+ * Represents an active mock of a type's static methods. The mocking only affects the thread
+ * on which this static mock was created and it is not safe to use this object from another
+ * thread. The static mock is released when this object's {@link MockedStatic#close()} method
+ * is invoked. If this object is never closed, the static mock will remain active on the
+ * initiating thread. It is therefore recommended to create this object within a try-with-resources
+ * statement unless when managed explicitly, for example by using a JUnit rule or extension.
+ * <p>
+ * If the {@link Mock} annotation is used on fields or method parameters of this type, a static mock
+ * is created instead of a regular mock. The static mock is activated and released upon completing any
+ * relevant test.
+ *
+ * @param <T> The type being mocked.
+ */
+public interface MockedStatic<T> extends ScopedMock {
+
+    /**
+     * See {@link Mockito#when(Object)}.
+     */
+    <S> OngoingStubbing<S> when(Verification verification);
+
+    /**
+     * See {@link Mockito#verify(Object)}.
+     */
+    default void verify(Verification verification) {
+        verify(verification, times(1));
+    }
+
+    /**
+     * See {@link Mockito#verify(Object, VerificationMode)}.
+     */
+    void verify(Verification verification, VerificationMode mode);
+
+    /**
+     * See {@link Mockito#reset(Object[])}.
+     */
+    void reset();
+
+    /**
+     * See {@link Mockito#clearInvocations(Object[])}.
+     */
+    void clearInvocations();
+
+    /**
+     * {@link Mockito#verifyNoMoreInteractions(Object...)}.
+     */
+    void verifyNoMoreInteractions();
+
+    /**
+     * See {@link Mockito#verifyNoInteractions(Object...)}.
+     */
+    void verifyNoInteractions();
+
+    /**
+     * Functional interface for a verification operation on a static mock.
+     */
+    @FunctionalInterface
+    interface Verification {
+
+        /**
+         * Apply the verification operation.
+         *
+         * @throws Throwable any exception that may be thrown.
+         */
+        void apply() throws Throwable;
+    }
+}
diff --git a/src/main/java/org/mockito/MockingDetails.java b/mockito-core/src/main/java/org/mockito/MockingDetails.java
similarity index 96%
rename from src/main/java/org/mockito/MockingDetails.java
rename to mockito-core/src/main/java/org/mockito/MockingDetails.java
index be7dc6352a..37a149100a 100644
--- a/src/main/java/org/mockito/MockingDetails.java
+++ b/mockito-core/src/main/java/org/mockito/MockingDetails.java
@@ -73,7 +73,7 @@ public interface MockingDetails {
      * What is 'stubbing'?
      * Stubbing is your when(x).then(y) declaration, e.g. configuring the mock to behave in a specific way,
      * when specific method with specific arguments is invoked on a mock.
-     * Typically stubbing is configuring mock to return X when method Y is invoked.
+     * Typically, stubbing is configuring mock to return X when method Y is invoked.
      * <p>
      * Why do you need to access stubbings of a mock?
      * In a normal workflow of creation clean tests, there is no need for this API.
@@ -102,8 +102,6 @@ public interface MockingDetails {
      * Don't write code that depends on the output of this method.
      * If you need to know about interactions and stubbings, use {@link #getStubbings()} and {@link #getInvocations()}.
      * <p>
-     * This method was moved from the deprecated and semi-hidden type {@link MockitoDebugger}.
-     * <p>
      * This method throws meaningful exception when object wrapped by MockingDetails is not a mock.
      *
      * @since 2.2.6
@@ -119,7 +117,6 @@ public interface MockingDetails {
      * @return mock handler instance of this mock
      * @since 2.10.0
      */
-    @Incubating
     MockHandler getMockHandler();
 
     /**
diff --git a/src/main/java/org/mockito/Mockito.java b/mockito-core/src/main/java/org/mockito/Mockito.java
similarity index 77%
rename from src/main/java/org/mockito/Mockito.java
rename to mockito-core/src/main/java/org/mockito/Mockito.java
index af1ceb22e9..452f8ee44e 100644
--- a/src/main/java/org/mockito/Mockito.java
+++ b/mockito-core/src/main/java/org/mockito/Mockito.java
@@ -6,18 +6,18 @@
 
 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;
-import org.mockito.internal.debugging.MockitoDebuggerImpl;
 import org.mockito.internal.framework.DefaultMockitoFramework;
 import org.mockito.internal.session.DefaultMockitoSessionBuilder;
+import org.mockito.internal.util.MockUtil;
 import org.mockito.internal.verification.VerificationModeFactory;
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.InvocationFactory;
 import org.mockito.invocation.MockHandler;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner.Strict;
 import org.mockito.junit.MockitoRule;
 import org.mockito.listeners.VerificationStartedEvent;
 import org.mockito.listeners.VerificationStartedListener;
@@ -33,7 +33,6 @@
 import org.mockito.stubbing.LenientStubber;
 import org.mockito.stubbing.OngoingStubbing;
 import org.mockito.stubbing.Stubber;
-import org.mockito.stubbing.Stubbing;
 import org.mockito.stubbing.VoidAnswer1;
 import org.mockito.verification.After;
 import org.mockito.verification.Timeout;
@@ -41,12 +40,15 @@
 import org.mockito.verification.VerificationMode;
 import org.mockito.verification.VerificationWithTimeout;
 
+import java.util.function.Consumer;
+import java.util.function.Function;
+
 /**
  * <p align="left"><img src="logo.png" srcset="logo@2x.png 2x" alt="Mockito logo"/></p>
  * The Mockito library enables mock creation, verification and stubbing.
  *
  * <p>
- * This javadoc content is also available on the <a href="http://mockito.org">http://mockito.org</a> web page.
+ * This javadoc content is also available on the <a href="https://site.mockito.org/">https://site.mockito.org/</a> web page.
  * All documentation is kept in javadocs because it guarantees consistency between what's on the web and what's in the source code.
  * It allows access to documentation straight from the IDE even if you work offline.
  * It motivates Mockito developers to keep documentation up-to-date with the code that they write,
@@ -56,8 +58,9 @@
  *
  * <b>
  *      <a href="#0">0. Migrating to Mockito 2</a><br/>
- *      <a href="#0.1">0.1 Mockito Android support</a></br/>
- *      <a href="#0.2">0.2 Configuration-free inline mock making</a></br/>
+ *      <a href="#0.1">0.1 Mockito Android support</a><br/>
+ *      <a href="#0.2">0.2 Configuration-free inline mock making</a><br/>
+ *      <a href="#0.3">0.3 Explicitly enabling instrumentation for inline mocking (Java 21+)</a><br/>
  *      <a href="#1">1. Let's verify some behaviour! </a><br/>
  *      <a href="#2">2. How about some stubbing? </a><br/>
  *      <a href="#3">3. Argument matchers </a><br/>
@@ -71,11 +74,11 @@
  *      <a href="#11">11. Stubbing with callbacks </a><br/>
  *      <a href="#12">12. <code>doReturn()</code>|<code>doThrow()</code>|<code>doAnswer()</code>|<code>doNothing()</code>|<code>doCallRealMethod()</code> family of methods</a><br/>
  *      <a href="#13">13. Spying on real objects </a><br/>
- *      <a href="#14">14. Changing default return values of unstubbed invocations (Since 1.7) </a><br/>
+ *      <a href="#14">14. Changing default return values of un-stubbed invocations (Since 1.7) </a><br/>
  *      <a href="#15">15. Capturing arguments for further assertions (Since 1.8.0) </a><br/>
  *      <a href="#16">16. Real partial mocks (Since 1.8.0) </a><br/>
  *      <a href="#17">17. Resetting mocks (Since 1.8.0) </a><br/>
- *      <a href="#18">18. Troubleshooting & validating framework usage (Since 1.8.0) </a><br/>
+ *      <a href="#18">18. Troubleshooting and validating framework usage (Since 1.8.0) </a><br/>
  *      <a href="#19">19. Aliases for behavior driven development (Since 1.8.0) </a><br/>
  *      <a href="#20">20. Serializable mocks (Since 1.8.1) </a><br/>
  *      <a href="#21">21. New annotations: <code>&#064;Captor</code>, <code>&#064;Spy</code>, <code>&#064;InjectMocks</code> (Since 1.8.3) </a><br/>
@@ -105,12 +108,19 @@
  *      <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/>
  *      <a href="#47">47. New API for clearing mock state in inline mocking (Since 2.25.0)</a><br/>
+ *      <a href="#48">48. New API for mocking static methods (Since 3.4.0)</a><br/>
+ *      <a href="#49">49. New API for mocking object construction (Since 3.5.0)</a><br/>
+ *      <a href="#50">50. Avoiding code generation when restricting mocks to interfaces (Since 3.12.2)</a><br/>
+ *      <a href="#51">51. New API for marking classes as unmockable (Since 4.1.0)</a><br/>
+ *      <a href="#52">52. New strictness attribute for @Mock annotation and <code>MockSettings.strictness()</code> methods (Since 4.6.0)</a><br/>
+ *      <a href="#53">53. Specifying mock maker for individual mocks (Since 4.8.0)</a><br/>
+ *      <a href="#54">54. Mocking/spying without specifying class (Since 4.10.0)</a><br/>
  * </b>
  *
  * <h3 id="0">0. <a class="meaningful_link" href="#mockito2" name="mockito2">Migrating to Mockito 2</a></h3>
  *
  * In order to continue improving Mockito and further improve the unit testing experience, we want you to upgrade to 2.1.0!
- * Mockito follows <a href="http://semver.org/">semantic versioning</a> and contains breaking changes only on major version upgrades.
+ * Mockito follows <a href="https://semver.org/">semantic versioning</a> and contains breaking changes only on major version upgrades.
  * In the lifecycle of a library, breaking changes are necessary
  * to roll out a set of brand new features that alter the existing behavior or even change the API.
  * For a comprehensive guide on the new release including incompatible changes,
@@ -124,7 +134,7 @@
  *
  * <pre class="code"><code>
  * repositories {
- *   jcenter()
+ *   mavenCentral()
  * }
  * dependencies {
  *   testCompile "org.mockito:mockito-core:+"
@@ -146,18 +156,112 @@
  *
  * <pre class="code"><code>
  * repositories {
- *   jcenter()
+ *   mavenCentral()
  * }
  * dependencies {
  *   testCompile "org.mockito:mockito-inline:+"
  * }
  * </code></pre>
  *
- * Be aware that this artifact may be abolished when the inline mock making feature is integrated into the default mock maker.
+ * Be aware that starting from 5.0.0 the <a href="#39">inline mock maker</a> became the default mock maker and this
+ * artifact may be abolished in future versions.
  *
  * <p>
  * For more information about inline mock making, see <a href="#39">section 39</a>.
  *
+ * <h3 id="0.3">0.3. <a class="meaningful_link" href="#mockito-instrumentation" name="mockito-instrumentation">Explicitly setting up instrumentation for inline mocking (Java 21+)</a></h3>
+ *
+ * Starting from Java 21, the <a href="https://openjdk.org/jeps/451">JDK restricts the ability of libraries
+ * to attach a Java agent to their own JVM</a>. As a result, the inline-mock-maker might not be able
+ * to function without an explicit setup to enable instrumentation, and the JVM will always display a warning.
+ *
+ * The following are examples about how to set up mockito-core as a Java agent, and it may be more appropriate to choose
+ * a different approach depending on your project constraints.
+ *
+ * <p>
+ * To explicitly attach Mockito during test execution, the library's jar file needs to be specified as <code>-javaagent</code>
+ * as an argument to the executing JVM. To enable this in Gradle, the following example adds Mockito to all test
+ * tasks using <strong>Kotlin DSL</strong>. Although omitted for simplicity, using a <code>CommandLineArgumentProvider</code> is recommended by Gradle to ensure task relocatability (<a href="https://docs.gradle.org/current/userguide/caching_java_projects.html#dealing_with_file_paths">documentation</a>):
+ *
+ * <pre class="code"><code class="kotlin">
+ * val mockitoAgent = configurations.create("mockitoAgent")
+ * dependencies {
+ *     testImplementation(libs.mockito)
+ *     mockitoAgent(libs.mockito) { isTransitive = false }
+ * }
+ * tasks {
+ *     test {
+ *         jvmArgs.add("-javaagent:${mockitoAgent.asPath}")
+ *     }
+ * }
+ * </code></pre>
+ *
+ * The same can be achieved using <strong>Groovy DSL</strong>:
+ *
+ * <pre class="code"><code class="groovy">
+ * configurations {
+ *     mockitoAgent
+ * }
+ * dependencies {
+ *     testImplementation(libs.mockito)
+ *     mockitoAgent(libs.mockito) {
+ *         transitive = false
+ *     }
+ * }
+ * tasks {
+ *     test {
+ *         jvmArgs += "-javaagent:${configurations.mockitoAgent.asPath}"
+ *     }
+ * }
+ * </code></pre>
+ *
+ * Supposing <code>Mockito</code> is declared in the version catalog as the following
+ *
+ * <pre class="code"><code class="toml">
+ * [versions]
+ * mockito = "5.14.0"
+ *
+ * [libraries]
+ * mockito = { module = "org.mockito:mockito-core", version.ref = "mockito" }
+ * </code></pre>
+ *
+ * To add Mockito as an agent to Maven's surefire plugin, the following configuration is needed:
+ *
+ * <pre class="code"><code class="xml">
+ * &lt;plugin&gt;
+ *     &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;
+ *     &lt;artifactId&gt;maven-dependency-plugin&lt;/artifactId&gt;
+ *     &lt;executions&gt;
+ *         &lt;execution&gt;
+ *             &lt;goals&gt;
+ *                 &lt;goal&gt;properties&lt;/goal&gt;
+ *             &lt;/goals&gt;
+ *         &lt;/execution&gt;
+ *     &lt;/executions&gt;
+ * &lt;/plugin&gt;
+ * &lt;plugin&gt;
+ *     &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;
+ *     &lt;artifactId&gt;maven-surefire-plugin&lt;/artifactId&gt;
+ *     &lt;configuration&gt;
+ *         &lt;argLine&gt;@{argLine} -javaagent:${org.mockito:mockito-core:jar}&lt;/argLine&gt;
+ *     &lt;/configuration&gt;
+ * &lt;/plugin&gt;
+ * </code></pre>
+ *
+ * <blockquote>
+ * Note however, that <code>@{argLine}</code> needs to exist when surefire performs its
+ * <a href="https://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html#argLine">late replacement</a> otherwise
+ * it will just use the value verbatim which will crash the VM,
+ * <code>The forked VM terminated without properly saying goodbye. VM crash or System.exit called.</code>, in this case,
+ * you may need to adapt your maven configuration, for example by adding an empty <code>&lt;argLine/&gt;</code> property
+ * to the POM file.
+ * </blockquote>
+ *
+ * <p>
+ * Alternatively, to enable support for dynamic attach, it is also possible to start a JVM with
+ * <code>-XX:+EnableDynamicAgentLoading</code> flag. Do however note that, since this option is not standardized, any future
+ * release of a JDK might prohibit this behaviour.
+ *
  * <h3 id="1">1. <a class="meaningful_link" href="#verification" name="verification">Let's verify some behaviour!</a></h3>
  *
  * The following examples mock a List, because most people are familiar with the interface (such as the
@@ -219,7 +323,7 @@
  *
  * <li> Stubbing can be overridden: for example common stubbing can go to
  * fixture setup but the test methods can override it.
- * Please note that overridding stubbing is a potential code smell that points out too much stubbing</li>
+ * Please note that overriding stubbing is a potential code smell that points out too much stubbing</li>
  *
  * <li> Once stubbed, the method will always return a stubbed value, regardless
  * of how many times it is called. </li>
@@ -252,7 +356,7 @@
  * verify(mockedList).get(anyInt());
  *
  * //<b>argument matchers can also be written as Java 8 Lambdas</b>
- * verify(mockedList).add(argThat(someString -> someString.length() > 5));
+ * verify(mockedList).add(argThat(someString -&gt; someString.length() &gt; 5));
  *
  * </code></pre>
  *
@@ -264,7 +368,7 @@
  * For information solely on <b>custom argument matchers</b> check out javadoc for {@link ArgumentMatcher} class.
  * <p>
  * Be reasonable with using complicated argument matching.
- * The natural matching style using <code>equals()</code> with occasional <code>anyX()</code> matchers tend to give clean & simple tests.
+ * The natural matching style using <code>equals()</code> with occasional <code>anyX()</code> matchers tend to give clean and simple tests.
  * Sometimes it's just better to refactor the code to allow <code>equals()</code> matching or even implement <code>equals()</code> method to help out with testing.
  * <p>
  * Also, read <a href="#15">section 15</a> or javadoc for {@link ArgumentCaptor} class.
@@ -275,7 +379,7 @@
  * If you are using argument matchers, <b>all arguments</b> have to be provided
  * by matchers.
  * <p>
- The following example shows verification but the same applies to stubbing:
+ * The following example shows verification but the same applies to stubbing:
  *
  * <pre class="code"><code class="java">
  *   verify(mock).someMethod(anyInt(), anyString(), <b>eq("third argument")</b>);
@@ -286,10 +390,10 @@
  * </code></pre>
  *
  * <p>
- * Matcher methods like <code>anyObject()</code>, <code>eq()</code> <b>do not</b> return matchers.
+ * Matcher methods like <code>any()</code>, <code>eq()</code> <b>do not</b> return matchers.
  * Internally, they record a matcher on a stack and return a dummy value (usually null).
  * This implementation is due to static type safety imposed by the java compiler.
- * The consequence is that you cannot use <code>anyObject()</code>, <code>eq()</code> methods outside of verified/stubbed method.
+ * The consequence is that you cannot use <code>any()</code>, <code>eq()</code> methods outside of verified/stubbed method.
  *
  *
  *
@@ -403,9 +507,6 @@
  * //verify that method was never called on a mock
  * verify(mockOne, never()).add("two");
  *
- * //verify that other mocks were not interacted
- * verifyZeroInteractions(mockTwo, mockThree);
- *
  * </code></pre>
  *
  *
@@ -455,13 +556,16 @@
  *       &#064;Mock private UserProvider userProvider;
  *
  *       private ArticleManager manager;
+ *
+ *       &#064;org.junit.jupiter.api.Test
+ *       void testSomethingInJunit5(&#064;Mock ArticleDatabase database) {
  * </code></pre>
  *
  * <b>Important!</b> This needs to be somewhere in the base class or a test
  * runner:
  *
  * <pre class="code"><code class="java">
- * MockitoAnnotations.initMocks(testClass);
+ * MockitoAnnotations.openMocks(testClass);
  * </code></pre>
  *
  * You can use built-in runner: {@link MockitoJUnitRunner} or a rule: {@link MockitoRule}.
@@ -525,7 +629,7 @@
  * Yet another controversial feature which was not included in Mockito
  * originally. We recommend simply stubbing with <code>thenReturn()</code> or
  * <code>thenThrow()</code>, which should be enough to test/test-drive
- * any clean & simple code. However, if you do have a need to stub with the generic Answer interface, here is an example:
+ * any clean and 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(
@@ -645,7 +749,7 @@
  * <li>Mockito <b>*does not*</b> delegate calls to the passed real instance, instead it actually creates a copy of it.
  * So if you keep the real instance and interact with it, don't expect the spied to be aware of those interaction
  * and their effect on real instance state.
- * The corollary is that when an <b>*unstubbed*</b> method is called <b>*on the spy*</b> but <b>*not on the real instance*</b>,
+ * The corollary is that when an <b>*un-stubbed*</b> method is called <b>*on the spy*</b> but <b>*not on the real instance*</b>,
  * you won't see any effects on the real instance.
  * </li>
  *
@@ -658,7 +762,7 @@
  *
  *
  *
- * <h3 id="14">14. Changing <a class="meaningful_link" href="#defaultreturn" name="defaultreturn">default return values of unstubbed invocations</a> (Since 1.7)</h3>
+ * <h3 id="14">14. Changing <a class="meaningful_link" href="#defaultreturn" name="defaultreturn">default return values of un-stubbed invocations</a> (Since 1.7)</h3>
  *
  * You can create a mock with specified strategy for its return values.
  * It's quite an advanced feature and typically you don't need it to write decent tests.
@@ -680,7 +784,7 @@
  * <h3 id="15">15. <a class="meaningful_link" href="#captors" name="captors">Capturing arguments</a> for further assertions (Since 1.8.0)</h3>
  *
  * Mockito verifies argument values in natural java style: by using an <code>equals()</code> method.
- * This is also the recommended way of matching arguments because it makes tests clean & simple.
+ * This is also the recommended way of matching arguments because it makes tests clean and simple.
  * In some situations though, it is helpful to assert on certain arguments after the actual verification.
  * For example:
  * <pre class="code"><code class="java">
@@ -707,7 +811,7 @@
  *
  * <h3 id="16">16. <a class="meaningful_link" href="#partial_mocks" name="partial_mocks">Real partial mocks</a> (Since 1.8.0)</h3>
  *
- *  Finally, after many internal debates & discussions on the mailing list, partial mock support was added to Mockito.
+ *  Finally, after many internal debates and discussions on the mailing list, partial mock support was added to Mockito.
  *  Previously we considered partial mocks as code smells. However, we found a legitimate use case for partial mocks.
  *  <p>
  *  <b>Before release 1.8</b> <code>spy()</code> was not producing real partial mocks and it was confusing for some users.
@@ -732,19 +836,19 @@
  * <p>
  * However, there are rare cases when partial mocks come handy:
  * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
- * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+ * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
  *
  *
  *
  *
  * <h3 id="17">17. <a class="meaningful_link" href="#resetting_mocks" name="resetting_mocks">Resetting mocks</a> (Since 1.8.0)</h3>
  *
- * Smart Mockito users hardly use this feature because they know it could be a sign of poor tests.
+ * Using this method could be an indication of poor testing.
  * Normally, you don't need to reset your mocks, just create new mocks for each test method.
  * <p>
  * Instead of <code>reset()</code> please consider writing simple, small and focused test methods over lengthy, over-specified tests.
  * <b>First potential code smell is <code>reset()</code> in the middle of the test method.</b> This probably means you're testing too much.
- * Follow the whisper of your test methods: "Please keep us small & focused on single behavior".
+ * Follow the whisper of your test methods: "Please keep us small and focused on single behavior".
  * There are several threads about it on mockito mailing list.
  * <p>
  * The only reason we added <code>reset()</code> method is to
@@ -758,19 +862,19 @@
  *   mock.add(1);
  *
  *   reset(mock);
- *   //at this point the mock forgot any interactions & stubbing
+ *   //at this point the mock forgot any interactions and stubbing
  * </code></pre>
  *
  *
  *
  *
- * <h3 id="18">18. <a class="meaningful_link" href="#framework_validation" name="framework_validation">Troubleshooting & validating framework usage</a> (Since 1.8.0)</h3>
+ * <h3 id="18">18. <a class="meaningful_link" href="#framework_validation" name="framework_validation">Troubleshooting and validating framework usage</a> (Since 1.8.0)</h3>
  *
  * First of all, in case of any trouble, I encourage you to read the Mockito FAQ:
  * <a href="https://github.com/mockito/mockito/wiki/FAQ">https://github.com/mockito/mockito/wiki/FAQ</a>
  * <p>
  * In case of questions you may also post to mockito mailing list:
- * <a href="http://groups.google.com/group/mockito">http://groups.google.com/group/mockito</a>
+ * <a href="https://groups.google.com/group/mockito">https://groups.google.com/group/mockito</a>
  * <p>
  * Next, you should know that Mockito validates if you use it correctly <b>all the time</b>.
  * However, there's a gotcha so please read the javadoc for {@link Mockito#validateMockitoUsage()}
@@ -783,7 +887,7 @@
  * Behavior Driven Development style of writing tests uses <b>//given //when //then</b> comments as fundamental parts of your test methods.
  * This is exactly how we write our tests and we warmly encourage you to do so!
  * <p>
- * Start learning about BDD here: <a href="http://en.wikipedia.org/wiki/Behavior_Driven_Development">http://en.wikipedia.org/wiki/Behavior_Driven_Development</a>
+ * Start learning about BDD here: <a href="https://en.wikipedia.org/wiki/Behavior-driven_development">https://en.wikipedia.org/wiki/Behavior-driven_development</a>
  * <p>
  * The problem is that current stubbing api with canonical role of <b>when</b> word does not integrate nicely with <b>//given //when //then</b> comments.
  * It's because stubbing belongs to <b>given</b> component of the test and not to the <b>when</b> component of the test.
@@ -826,7 +930,7 @@
  *   List serializableMock = mock(List.class, withSettings().serializable());
  * </code></pre>
  * <p>
- * The mock can be serialized assuming all the normal <a href='http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html'>
+ * The mock can be serialized assuming all the normal <a href='https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html'>
  * serialization requirements</a> are met by the class.
  * <p>
  * Making a real object spy serializable is a bit more effort as the spy(...) method does not have an overloaded version
@@ -863,7 +967,7 @@
  * should only use partial mocks as a last resort. See point 16 about partial mocks.
  *
  * <p>
- * All new annotations are <b>*only*</b> processed on {@link MockitoAnnotations#initMocks(Object)}.
+ * All new annotations are <b>*only*</b> processed on {@link MockitoAnnotations#openMocks(Object)}.
  * Just like for &#064;{@link Mock} annotation you can use the built-in runner: {@link MockitoJUnitRunner} or rule:
  * {@link MockitoRule}.
  * <p>
@@ -907,7 +1011,7 @@
  * Mockito will now try to instantiate &#064;{@link Spy} and will instantiate &#064;{@link InjectMocks} fields
  * using <b>constructor</b> injection, <b>setter</b> injection, or <b>field</b> injection.
  * <p>
- * To take advantage of this feature you need to use {@link MockitoAnnotations#initMocks(Object)}, {@link MockitoJUnitRunner}
+ * To take advantage of this feature you need to use {@link MockitoAnnotations#openMocks(Object)}, {@link MockitoJUnitRunner}
  * or {@link MockitoRule}.
  * <p>
  * Read more about available tricks and the rules of injection in the javadoc for {@link InjectMocks}
@@ -929,7 +1033,7 @@
  * Mockito will now allow you to create mocks when stubbing.
  * Basically, it allows to create a stub in one line of code.
  * This can be helpful to keep test code clean.
- * For example, some boring stub can be created & stubbed at field initialization in a test:
+ * For example, some boring stub can be created and stubbed at field initialization in a test:
  * <pre class="code"><code class="java">
  * public class CarTest {
  *   Car boringStubbedCar = when(mock(Car.class).shiftGear()).thenThrow(EngineNotStarted.class).getMock();
@@ -1076,7 +1180,7 @@
  * SomeAbstract spy = spy(SomeAbstract.class);
  *
  * //Mocking abstract methods, spying default methods of an interface (only available since 2.7.13)
- * Function<Foo, Bar> function = spy(Function.class);
+ * Function&lt;Foo, Bar&gt; function = spy(Function.class);
  *
  * //Robust API, via settings builder:
  * OtherAbstract spy = mock(OtherAbstract.class, withSettings()
@@ -1100,7 +1204,7 @@
  *
  * Mockito introduces serialization across classloader.
  *
- * Like with any other form of serialization, all types in the mock hierarchy have to serializable, inclusing answers.
+ * Like with any other form of serialization, all types in the mock hierarchy have to serializable, including answers.
  * As this serialization mode require considerably more work, this is an opt-in setting.
  *
  * <pre class="code"><code class="java">
@@ -1144,7 +1248,7 @@
  *
  * <ul>
  *     <li>Annotating the JUnit test class with a <code>&#064;{@link org.junit.runner.RunWith}({@link MockitoJUnitRunner}.class)</code></li>
- *     <li>Invoking <code>{@link MockitoAnnotations#initMocks(Object)}</code> in the <code>&#064;{@link org.junit.Before}</code> method</li>
+ *     <li>Invoking <code>{@link MockitoAnnotations#openMocks(Object)}</code> in the <code>&#064;{@link org.junit.Before}</code> method</li>
  * </ul>
  *
  * Now you can choose to use a rule :
@@ -1200,21 +1304,21 @@
  *
  * // verify a list only had strings of a certain length added to it
  * // note - this will only compile under Java 8
- * verify(list, times(2)).add(argThat(string -> string.length() < 5));
+ * verify(list, times(2)).add(argThat(string -&gt; string.length() &lt; 5));
  *
  * // Java 7 equivalent - not as neat
- * verify(list, times(2)).add(argThat(new ArgumentMatcher<String>(){
+ * verify(list, times(2)).add(argThat(new ArgumentMatcher&lt;String&gt;(){
  *     public boolean matches(String arg) {
- *         return arg.length() < 5;
+ *         return arg.length() &lt; 5;
  *     }
  * }));
  *
  * // more complex Java 8 example - where you can specify complex verification behaviour functionally
- * verify(target, times(1)).receiveComplexObject(argThat(obj -> obj.getSubObject().get(0).equals("expected")));
+ * verify(target, times(1)).receiveComplexObject(argThat(obj -&gt; obj.getSubObject().get(0).equals("expected")));
  *
  * // 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))).thenReturn(null);
+ * when(mock.someMethod(argThat(list -&gt; list.size()&lt;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>
@@ -1228,12 +1332,12 @@
  * <p>
  * <pre class="code"><code class="java">
  * // answer by returning 12 every time
- * doAnswer(invocation -> 12).when(mock).doSomething();
+ * doAnswer(invocation -&gt; 12).when(mock).doSomething();
  *
  * // answer by using one of the parameters - converting into the right
  * // type as your go - in this case, returning the length of the second string parameter
  * // as the answer. This gets long-winded quickly, with casting of parameters.
- * doAnswer(invocation -> ((String)invocation.getArgument(1)).length())
+ * doAnswer(invocation -&gt; ((String)invocation.getArgument(1)).length())
  *     .when(mock).doSomething(anyString(), anyString(), anyString());
  * </code></pre>
  *
@@ -1241,8 +1345,8 @@
  * as Java 8 lambdas. Even in Java 7 and lower these custom answers based on a typed interface can reduce boilerplate.
  * In particular, this approach will make it easier to test functions which use callbacks.
  *
- * The methods {@link AdditionalAnswers#answer(Answer1) answer} and {@link AdditionalAnswers#answerVoid(VoidAnswer1) answerVoid}
- * can be used to create the answer. They rely on the related answer interfaces in {@link org.mockito.stubbing} that
+ * The methods {@link AdditionalAnswers#answer(Answer1)}} and {@link AdditionalAnswers#answerVoid(VoidAnswer1)}
+ * can be used to create the answer. They rely on the related answer interfaces in org.mockito.stubbing that
  * support answers up to 5 parameters.
  *
  * <p>
@@ -1258,11 +1362,11 @@
  * void receive(String item);
  *
  * // Java 8 - style 1
- * doAnswer(AdditionalAnswers.<String,Callback>answerVoid((operand, callback) -> callback.receive("dummy"))
+ * doAnswer(AdditionalAnswers.&lt;String,Callback&gt;answerVoid((operand, callback) -&gt; callback.receive("dummy")))
  *     .when(mock).execute(anyString(), any(Callback.class));
  *
  * // Java 8 - style 2 - assuming static import of AdditionalAnswers
- * doAnswer(answerVoid((String operand, Callback callback) -> callback.receive("dummy"))
+ * doAnswer(answerVoid((String operand, Callback callback) -&gt; callback.receive("dummy")))
  *     .when(mock).execute(anyString(), any(Callback.class));
  *
  * // Java 8 - style 3 - where mocking function to is a static member of test class
@@ -1270,11 +1374,11 @@
  *     callback.receive("dummy");
  * }
  *
- * doAnswer(answerVoid(TestClass::dummyCallbackImpl)
+ * doAnswer(answerVoid(TestClass::dummyCallbackImpl))
  *     .when(mock).execute(anyString(), any(Callback.class));
  *
  * // Java 7
- * doAnswer(answerVoid(new VoidAnswer2<String, Callback>() {
+ * doAnswer(answerVoid(new VoidAnswer2&lt;String, Callback&gt;() {
  *     public void answer(String operation, Callback callback) {
  *         callback.receive("dummy");
  *     }})).when(mock).execute(anyString(), any(Callback.class));
@@ -1286,11 +1390,11 @@
  *
  * // this could be mocked
  * // Java 8
- * doAnswer(AdditionalAnswers.<Boolean,String,String>answer((input1, input2) -> input1.equals(input2))))
+ * doAnswer(AdditionalAnswers.&lt;Boolean,String,String&gt;answer((input1, input2) -&gt; input1.equals(input2)))
  *     .when(mock).execute(anyString(), anyString());
  *
  * // Java 7
- * doAnswer(answer(new Answer2<String, String, String>() {
+ * doAnswer(answer(new Answer2&lt;String, String, String&gt;() {
  *     public String answer(String input1, String input2) {
  *         return input1 + input2;
  *     }})).when(mock).execute(anyString(), anyString());
@@ -1320,12 +1424,11 @@
  *
  * <h3 id="39">39. <a class="meaningful_link" href="#Mocking_Final" name="Mocking_Final">Mocking final types, enums and final methods</a> (Since 2.1.0)</h3>
  *
- * Mockito now offers an {@link Incubating}, optional support for mocking final classes and methods.
+ * Mockito now offers support for mocking final classes and methods by default.
  * This is a fantastic improvement that demonstrates Mockito's everlasting quest for improving testing experience.
  * Our ambition is that Mockito "just works" with final classes and methods.
  * Previously they were considered <em>unmockable</em>, preventing the user from mocking.
- * We already started discussing how to make this feature enabled by default.
- * Currently, the feature is still optional as we wait for more feedback from the community.
+ * Since 5.0.0, this feature is enabled by default.
  *
  * <p>
  * This alternative mock maker which uses
@@ -1333,10 +1436,10 @@
  * a mock. This way, it becomes possible to mock final types and methods.
  *
  * <p>
- * This mock maker is <strong>turned off by default</strong> because it is based on completely different mocking mechanism
- * that requires more feedback from the community. It can be activated explicitly by the mockito extension mechanism,
- * just create in the classpath a file <code>/mockito-extensions/org.mockito.plugins.MockMaker</code>
- * containing the value <code>mock-maker-inline</code>.
+ * In versions preceding 5.0.0, this mock maker is <strong>turned off by default</strong> because it is based on
+ * completely different mocking mechanism that required more feedback from the community. It can be activated
+ * explicitly by the mockito extension mechanism, just create in the classpath a file
+ * <code>/mockito-extensions/org.mockito.plugins.MockMaker</code> containing the value <code>mock-maker-inline</code>.
  *
  * <p>
  * As a convenience, the Mockito team provides an artifact where this mock maker is preconfigured. Instead of using the
@@ -1360,7 +1463,7 @@
  *     </li>
  *     <li>This mock maker has been designed around Java Agent runtime attachment ; this require a compatible JVM,
  *     that is part of the JDK (or Java 9 VM). When running on a non-JDK VM prior to Java 9, it is however possible to
- *     manually add the <a href="http://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
+ *     manually add the <a href="https://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
  *     parameter upon starting the JVM.
  *     </li>
  * </ul>
@@ -1374,9 +1477,11 @@
  *
  * To quickly find out how "stricter" Mockito can make you more productive and get your tests cleaner, see:
  * <ul>
- *     <li>Strict stubbing with JUnit Rules - {@link MockitoRule#strictness(Strictness)} with {@link Strictness#STRICT_STUBS}</li>
- *     <li>Strict stubbing with JUnit Runner - {@link MockitoJUnitRunner.StrictStubs}</li>
- *     <li>Strict stubbing if you cannot use runner/rule (like TestNG) - {@link MockitoSession}</li>
+ *     <li>Strict stubbing with JUnit4 Rules - {@link MockitoRule#strictness(Strictness)} with {@link Strictness#STRICT_STUBS}</li>
+ *     <li>Strict stubbing with JUnit4 Runner - {@link Strict MockitoJUnitRunner.Strict}</li>
+ *     <li>Strict stubbing with JUnit5 Extension - <code>org.mockito.junit.jupiter.MockitoExtension</code></li>
+ *     <li>Strict stubbing with TestNG Listener <a href="https://github.com/mockito/mockito-testng">MockitoTestNGListener</a></li>
+ *     <li>Strict stubbing if you cannot use runner/rule - {@link MockitoSession}</li>
  *     <li>Unnecessary stubbing detection with {@link MockitoJUnitRunner}</li>
  *     <li>Stubbing argument mismatch warnings, documented in {@link MockitoHint}</li>
  * </ul>
@@ -1433,16 +1538,11 @@
  *      Provides access to invocation container object which has no methods (marker interface).
  *      Container is needed to hide the internal implementation and avoid leaking it to the public API.
  *     </li>
- *     <li>Changed {@link Stubbing} -
+ *     <li>Changed {@link org.mockito.stubbing.Stubbing} -
  *      it now extends {@link Answer} interface.
  *      It is backwards compatible because Stubbing interface is not extensible (see {@link NotExtensible}).
  *      The change should be seamless to our users.
  *     </li>
- *     <li>Deprecated {@link InternalMockHandler} -
- *       In order to accommodate API changes we needed to deprecate this interface.
- *       The interface was always documented as internal, we don't have evidence it was used by the community.
- *       The deprecation should be completely seamless for our users.
- *     </li>
  *     <li>{@link NotExtensible} -
  *       Public annotation that indicates to the user that she should not provide custom implementations of given type.
  *       Helps framework integrators and our users understand how to use Mockito API safely.
@@ -1502,14 +1602,14 @@
  *       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></h3>
  *
- * <p>{@link org.mockito.plugins.InstantiatorProvider} returned an internal API. Hence it was deprecated and replaced
- * by {@link org.mockito.plugins.InstantiatorProvider2}. Old {@link org.mockito.plugins.InstantiatorProvider
- * instantiator providers} will continue to work, but it is recommended to switch to the new API.</p>
+ * <p>org.mockito.plugins.InstantiatorProvider returned an internal API. Hence it was deprecated and replaced
+ * by {@link org.mockito.plugins.InstantiatorProvider2}. org.mockito.plugins.InstantiatorProvider
+ * has now been removed.</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/doc/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">the JavaDoc of <code>MockitoExtension</code></a>.
+ * For more information about the usage of the integration, see <a href="https://javadoc.io/doc/org.mockito/mockito-junit-jupiter/latest/org.mockito.junit.jupiter/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>
@@ -1541,7 +1641,136 @@
  * Hence, we introduced a new API to explicitly clear mock state (only make sense in inline mocking!).
  * See example usage in {@link MockitoFramework#clearInlineMocks()}.
  * If you have feedback or a better idea how to solve the problem please reach out.
+ *
+ *
+ * <h3 id="48">48. <a class="meaningful_link" href="#static_mocks" name="static_mocks">Mocking static methods</a> (since 3.4.0)</h3>
+ *
+ * When using the <a href="#0.2">inline mock maker</a>, it is possible to mock static method invocations within the current
+ * thread and a user-defined scope. This way, Mockito assures that concurrently and sequentially running tests do not interfere.
+ *
+ * To make sure a static mock remains temporary, it is recommended to define the scope within a try-with-resources construct.
+ * In the following example, the <code>Foo</code> type's static method would return <code>foo</code> unless mocked:
+ *
+ * <pre class="code"><code class="java">
+ * assertEquals("foo", Foo.method());
+ * try (MockedStatic<Foo> mocked = mockStatic(Foo.class)) {
+ * mocked.when(Foo::method).thenReturn("bar");
+ * assertEquals("bar", Foo.method());
+ * mocked.verify(Foo::method);
+ * }
+ * assertEquals("foo", Foo.method());
+ * </code></pre>
+ *
+ * Due to the defined scope of the static mock, it returns to its original behavior once the scope is released. To define mock
+ * behavior and to verify static method invocations, use the <code>MockedStatic</code> that is returned.
+ * <p>
+ *
+ * <h3 id="49">49. <a class="meaningful_link" href="#mocked_construction" name="mocked_construction">Mocking object construction</a> (since 3.5.0)</h3>
+ *
+ * When using the <a href="#0.2">inline mock maker</a>, it is possible to generate mocks on constructor invocations within the current
+ * thread and a user-defined scope. This way, Mockito assures that concurrently and sequentially running tests do not interfere.
+ *
+ * To make sure a constructor mocks remain temporary, it is recommended to define the scope within a try-with-resources construct.
+ * In the following example, the <code>Foo</code> type's construction would generate a mock:
+ *
+ * <pre class="code"><code class="java">
+ * assertEquals("foo", new Foo().method());
+ * try (MockedConstruction<Foo> mocked = mockConstruction(Foo.class)) {
+ * Foo foo = new Foo();
+ * when(foo.method()).thenReturn("bar");
+ * assertEquals("bar", foo.method());
+ * verify(foo).method();
+ * }
+ * assertEquals("foo", new Foo().method());
+ * </code></pre>
+ *
+ * Due to the defined scope of the mocked construction, object construction returns to its original behavior once the scope is
+ * released. To define mock behavior and to verify method invocations, use the <code>MockedConstruction</code> that is returned.
+ * <p>
+ *
+ * <h3 id="50">50. <a class="meaningful_link" href="#proxy_mock_maker" name="proxy_mock_maker">Avoiding code generation when only interfaces are mocked</a> (since 3.12.2)</h3>
+ *
+ * The JVM offers the {@link java.lang.reflect.Proxy} facility for creating dynamic proxies of interface types. For most applications, Mockito
+ * must be capable of mocking classes as supported by the default mock maker, or even final classes, as supported by the inline mock maker. To
+ * create such mocks, Mockito requires to setup diverse JVM facilities and must apply code generation. If only interfaces are supposed to be
+ * mocked, one can however choose to use a org.mockito.internal.creation.proxy.ProxyMockMaker that is based on the {@link java.lang.reflect.Proxy}
+ * API which avoids diverse overhead of the other mock makers but also limits mocking to interfaces.
+ *
+ * This mock maker can be activated explicitly by the mockito extension mechanism, just create in the classpath a file
+ * <code>/mockito-extensions/org.mockito.plugins.MockMaker</code> containing the value <code>mock-maker-proxy</code>.
+ *
+ * <h3 id="51">51. <a class="meaningful_link" href="#do_not_mock" name="do_not_mock">Mark classes as unmockable</a> (since 4.1.0)</h3>
+ *
+ * In some cases, mocking a class/interface can lead to unexpected runtime behavior. For example, mocking a <code>java.util.List</code>
+ * is difficult, given the requirements imposed by the interface. This means that on runtime, depending on what methods the application
+ * calls on the list, your mock might behave in such a way that it violates the interface.
+ *
+ * <p>
+ * For any class/interface you own that is problematic to mock, you can now mark the class with {@link org.mockito.DoNotMock @DoNotMock}. For usage
+ * of the annotation and how to ship your own (to avoid a compile time dependency on a test artifact), please see its JavaDoc.
+ * <p>
+ *
+ * <h3 id="52">52. <a class="meaningful_link" href="#mockito_strictness" name="mockito_strictness">
+ *  New strictness attribute for @Mock annotation and <code>MockSettings.strictness()</code> methods</a> (Since 4.6.0)</h3>
+ *
+ * You can now customize the strictness level for a single mock, either using `@Mock` annotation strictness attribute or
+ * using `MockSettings.strictness()`. This can be useful if you want all of your mocks to be strict,
+ * but one of the mocks to be lenient.
+ *
+ * <pre class="code"><code class="java">
+ *   &#064;Mock(strictness = Strictness.LENIENT)
+ *   Foo mock;
+ *   // using MockSettings.withSettings()
+ *   Foo mock = Mockito.mock(Foo.class, withSettings().strictness(Strictness.WARN));
+ * </code></pre>
+ *
+ * <h3 id="53">53. <a class="meaningful_link" href="#individual_mock_maker" name="individual_mock_maker">
+ *  Specifying mock maker for individual mocks</a> (Since 4.8.0)</h3>
+ *
+ * You may encounter situations where you want to use a different mock maker for a specific test only.
+ * In such case, you can (temporarily) use {@link MockSettings#mockMaker(String)} and {@link Mock#mockMaker()}
+ * to specify the mock maker for a specific mock which is causing the problem.
+ *
+ * <pre class="code"><code class="java">
+ *   // using annotation
+ *   &#064;Mock(mockMaker = MockMakers.SUBCLASS)
+ *   Foo mock;
+ *   // using MockSettings.withSettings()
+ *   Foo mock = Mockito.mock(Foo.class, withSettings().mockMaker(MockMakers.SUBCLASS));
+ * </code></pre>
+ *
+ * <h3 id="54">54. <a class="meaningful_link" href="#mock_without_class" name="mock_without_class">
+ *  Mocking/spying without specifying class</a> (Since 4.10.0)</h3>
+ *
+ * Instead of calling method {@link Mockito#mock(Class)} or {@link Mockito#spy(Class)} with Class parameter, you can
+ * now call method {@code mock()} or {@code spy()} <strong>without parameters</strong>:
+ *
+ * <pre class="code"><code class="java">
+ *   Foo foo = Mockito.mock();
+ *   Bar bar = Mockito.spy();
+ * </code></pre>
+ *
+ * Mockito will automatically detect the needed class.
+ * <p>
+ * It works only if you assign result of {@code mock()} or {@code spy()} to a variable or field with an explicit type.
+ * With an implicit type, the Java compiler is unable to automatically determine the type of a mock and you need
+ * to pass in the {@code Class} explicitly.
+ * </p>
+ *
+ * <h3 id="55">55. <a class="meaningful_link" href="#verification_with_assertions" name="verification_with_assertions">
+ *  Verification with assertions</a> (Since 5.3.0)</h3>
+ *
+ * To validate arguments during verification, instead of capturing them with {@link ArgumentCaptor}, you can now
+ * use {@link ArgumentMatchers#assertArg(Consumer)}}:
+ *
+ * <pre class="code"><code class="java">
+ *   verify(serviceMock).doStuff(assertArg(param -&gt; {
+ *     assertThat(param.getField1()).isEqualTo("foo");
+ *     assertThat(param.getField2()).isEqualTo("bar");
+ *   }));
+ * </code></pre>
  */
+@CheckReturnValue
 @SuppressWarnings("unchecked")
 public class Mockito extends ArgumentMatchers {
 
@@ -1550,9 +1779,9 @@ public class Mockito extends ArgumentMatchers {
     /**
      * The default <code>Answer</code> of every mock <b>if</b> the mock was not stubbed.
      *
-     * Typically it just returns some empty value.
+     * Typically, it just returns some empty value.
      * <p>
-     * {@link Answer} can be used to define the return values of unstubbed invocations.
+     * {@link Answer} can be used to define the return values of un-stubbed invocations.
      * <p>
      * This implementation first tries the global configuration and if there is no global configuration then
      * it will use a default answer that returns zeros, empty collections, nulls, etc.
@@ -1562,31 +1791,31 @@ public class Mockito extends ArgumentMatchers {
     /**
      * Optional <code>Answer</code> to be used with {@link Mockito#mock(Class, Answer)}.
      * <p>
-     * {@link Answer} can be used to define the return values of unstubbed invocations.
+     * {@link Answer} can be used to define the return values of un-stubbed invocations.
      * <p>
      * This implementation can be helpful when working with legacy code.
-     * Unstubbed methods often return null. If your code uses the object returned by an unstubbed call you get a NullPointerException.
+     * Un-stubbed methods often return null. If your code uses the object returned by an un-stubbed call,
+     * you get a NullPointerException.
      * This implementation of Answer <b>returns SmartNull instead of null</b>.
-     * <code>SmartNull</code> gives nicer exception message than NPE because it points out the line where unstubbed method was called. You just click on the stack trace.
+     * <code>SmartNull</code> gives nicer exception messages than NPEs, because it points out the
+     * line where the un-stubbed method was called. You just click on the stack trace.
      * <p>
      * <code>ReturnsSmartNulls</code> first tries to return ordinary values (zeros, empty collections, empty string, etc.)
      * then it tries to return SmartNull. If the return type is final then plain <code>null</code> is returned.
      * <p>
-     * <code>ReturnsSmartNulls</code> will be probably the default return values strategy in Mockito 4.0.0
-     * <p>
      * Example:
      * <pre class="code"><code class="java">
      *   Foo mock = mock(Foo.class, RETURNS_SMART_NULLS);
      *
-     *   //calling unstubbed method here:
+     *   //calling un-stubbed method here:
      *   Stuff stuff = mock.getStuff();
      *
-     *   //using object returned by unstubbed call:
+     *   //using object returned by un-stubbed call:
      *   stuff.doSomething();
      *
      *   //Above doesn't yield NullPointerException this time!
      *   //Instead, SmartNullPointerException is thrown.
-     *   //Exception's cause links to unstubbed <i>mock.getStuff()</i> - just click on the stack trace.
+     *   //Exception's cause links to un-stubbed <i>mock.getStuff()</i> - just click on the stack trace.
      * </code></pre>
      */
     public static final Answer<Object> RETURNS_SMART_NULLS = Answers.RETURNS_SMART_NULLS;
@@ -1594,7 +1823,7 @@ public class Mockito extends ArgumentMatchers {
     /**
      * Optional <code>Answer</code> to be used with {@link Mockito#mock(Class, Answer)}
      * <p>
-     * {@link Answer} can be used to define the return values of unstubbed invocations.
+     * {@link Answer} can be used to define the return values of un-stubbed invocations.
      * <p>
      * This implementation can be helpful when working with legacy code.
      * <p>
@@ -1695,21 +1924,21 @@ public class Mockito extends ArgumentMatchers {
      * Optional <code>Answer</code> to be used with {@link Mockito#mock(Class, Answer)}
      *
      * <p>
-     * {@link Answer} can be used to define the return values of unstubbed invocations.
+     * {@link Answer} can be used to define the return values of un-stubbed invocations.
      * <p>
      * This implementation can be helpful when working with legacy code.
-     * When this implementation is used, unstubbed methods will delegate to the real implementation.
+     * When this implementation is used, un-stubbed methods will delegate to the real implementation.
      * This is a way to create a partial mock object that calls real methods by default.
      * <p>
-     * As usual you are going to read <b>the partial mock warning</b>:
-     * Object oriented programming is more less tackling complexity by dividing the complexity into separate, specific, SRPy objects.
+     * As usual, you are going to read <b>the partial mock warning</b>:
+     * Object oriented programming is more-or-less tackling complexity by dividing the complexity into separate, specific, SRPy objects.
      * How does partial mock fit into this paradigm? Well, it just doesn't...
      * Partial mock usually means that the complexity has been moved to a different method on the same object.
      * In most cases, this is not the way you want to design your application.
      * <p>
      * However, there are rare cases when partial mocks come handy:
      * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
-     * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+     * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
      * <p>
      * Example:
      * <pre class="code"><code class="java">
@@ -1804,6 +2033,74 @@ public class Mockito extends ArgumentMatchers {
      */
     public static final Answer<Object> RETURNS_SELF = Answers.RETURNS_SELF;
 
+    /**
+     * Creates a mock object of the requested class or interface.
+     * <p>
+     * See examples in javadoc for the {@link Mockito} class.
+     *
+     * @param reified don't pass any values to it. It's a trick to detect the class/interface you
+     *                want to mock.
+     * @return the mock object.
+     * @since 4.10.0
+     */
+    @SafeVarargs
+    public static <T> T mock(T... reified) {
+        return mock(withSettings(), reified);
+    }
+
+    /**
+     * Creates a mock object of the requested class or interface with the given default answer.
+     * <p>
+     * See examples in javadoc for the {@link Mockito} class.
+     *
+     * @param defaultAnswer the default answer to use.
+     * @param reified       don't pass any values to it. It's a trick to detect the class/interface you
+     *                      want to mock.
+     * @return the mock object.
+     * @since 5.1.0
+     */
+    @SafeVarargs
+    public static <T> T mock(@SuppressWarnings("rawtypes") Answer defaultAnswer, T... reified) {
+        return mock(withSettings().defaultAnswer(defaultAnswer), reified);
+    }
+
+    /**
+     * Creates a mock object of the requested class or interface with the given name.
+     * <p>
+     * See examples in javadoc for the {@link Mockito} class.
+     *
+     * @param name     the mock name to use.
+     * @param reified  don't pass any values to it. It's a trick to detect the class/interface you
+     *                 want to mock.
+     * @return the mock object.
+     * @since 5.1.0
+     */
+    @SafeVarargs
+    public static <T> T mock(String name, T... reified) {
+        return mock(withSettings().name(name).defaultAnswer(RETURNS_DEFAULTS), reified);
+    }
+
+    /**
+     * Creates a mock object of the requested class or interface with the given settings.
+     * <p>
+     * See examples in javadoc for the {@link Mockito} class.
+     *
+     * @param settings the mock settings to use.
+     * @param reified  don't pass any values to it. It's a trick to detect the class/interface you
+     *                 want to mock.
+     * @return the mock object.
+     * @since 5.1.0
+     */
+    @SafeVarargs
+    public static <T> T mock(MockSettings settings, T... reified) {
+        if (reified == null || reified.length > 0) {
+            throw new IllegalArgumentException(
+                    "Please don't pass any values here. Java will detect class automagically.");
+        }
+
+        return mock(getClassOf(reified), settings);
+    }
+
     /**
      * Creates mock object of given class or interface.
      * <p>
@@ -1812,7 +2109,6 @@ public class Mockito extends ArgumentMatchers {
      * @param classToMock class or interface to mock
      * @return mock object
      */
-    @CheckReturnValue
     public static <T> T mock(Class<T> classToMock) {
         return mock(classToMock, withSettings());
     }
@@ -1832,11 +2128,8 @@ public static <T> T mock(Class<T> classToMock) {
      * @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)
-                .defaultAnswer(RETURNS_DEFAULTS));
+        return mock(classToMock, withSettings().name(name).defaultAnswer(RETURNS_DEFAULTS));
     }
 
     /**
@@ -1851,7 +2144,6 @@ public static <T> T mock(Class<T> classToMock, String name) {
      * @return A {@link org.mockito.MockingDetails} instance.
      * @since 1.9.5
      */
-    @CheckReturnValue
     public static MockingDetails mockingDetails(Object toInspect) {
         return MOCKITO_CORE.mockingDetails(toInspect);
     }
@@ -1871,11 +2163,10 @@ public static MockingDetails mockingDetails(Object toInspect) {
      * <p>See examples in javadoc for {@link Mockito} class</p>
      *
      * @param classToMock class or interface to mock
-     * @param defaultAnswer default answer for unstubbed methods
+     * @param defaultAnswer default answer for un-stubbed methods
      *
      * @return mock object
      */
-    @CheckReturnValue
     public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
         return mock(classToMock, withSettings().defaultAnswer(defaultAnswer));
     }
@@ -1883,7 +2174,7 @@ public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
     /**
      * Creates a mock with some non-standard settings.
      * <p>
-     * The number of configuration points for a mock grows
+     * The number of configuration points for a mock will grow,
      * so we need a fluent way to introduce new configuration without adding more and more overloaded Mockito.mock() methods.
      * Hence {@link MockSettings}.
      * <pre class="code"><code class="java">
@@ -1893,7 +2184,7 @@ public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
      * </code></pre>
      * <b>Use it carefully and occasionally</b>. What might be reason your test needs non-standard mocks?
      * Is the code under test so complicated that it requires non-standard mocks?
-     * Wouldn't you prefer to refactor the code under test so it is testable in a simple way?
+     * Wouldn't you prefer to refactor the code under test, so that it is testable in a simple way?
      * <p>
      * See also {@link Mockito#withSettings()}
      * <p>
@@ -1903,7 +2194,6 @@ public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
      * @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);
     }
@@ -1913,7 +2203,7 @@ public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
      * <p>
      * Real spies should be used <b>carefully and occasionally</b>, for example when dealing with legacy code.
      * <p>
-     * As usual you are going to read <b>the partial mock warning</b>:
+     * As usual, you are going to read <b>the partial mock warning</b>:
      * Object oriented programming tackles complexity by dividing the complexity into separate, specific, SRPy objects.
      * How does partial mock fit into this paradigm? Well, it just doesn't...
      * Partial mock usually means that the complexity has been moved to a different method on the same object.
@@ -1921,7 +2211,7 @@ public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
      * <p>
      * However, there are rare cases when partial mocks come handy:
      * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
-     * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+     * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
      * <p>
      * Example:
      *
@@ -1968,7 +2258,7 @@ public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
      * <li>Mockito <b>*does not*</b> delegate calls to the passed real instance, instead it actually creates a copy of it.
      * So if you keep the real instance and interact with it, don't expect the spied to be aware of those interaction
      * and their effect on real instance state.
-     * The corollary is that when an <b>*unstubbed*</b> method is called <b>*on the spy*</b> but <b>*not on the real instance*</b>,
+     * The corollary is that when an <b>*un-stubbed*</b> method is called <b>*on the spy*</b> but <b>*not on the real instance*</b>,
      * you won't see any effects on the real instance.</li>
      *
      * <li>Watch out for final methods.
@@ -1987,11 +2277,14 @@ public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
      *            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)
-                .defaultAnswer(CALLS_REAL_METHODS));
+        if (MockUtil.isMock(object)) {
+            throw new IllegalArgumentException(
+                    "Please don't pass mock here. Spy is not allowed on mock.");
+        }
+        return MOCKITO_CORE.mock(
+                (Class<T>) object.getClass(),
+                withSettings().spiedInstance(object).defaultAnswer(CALLS_REAL_METHODS));
     }
 
     /**
@@ -2021,12 +2314,244 @@ public static <T> T spy(T object) {
      * @return a spy of the provided class
      * @since 1.10.12
      */
-    @Incubating
-    @CheckReturnValue
     public static <T> T spy(Class<T> classToSpy) {
-        return MOCKITO_CORE.mock(classToSpy, withSettings()
-                .useConstructor()
-                .defaultAnswer(CALLS_REAL_METHODS));
+        return MOCKITO_CORE.mock(
+                classToSpy, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+    }
+
+    /**
+     * Please refer to the documentation of {@link #spy(Class)}.
+     *
+     * @param reified don't pass any values to it. It's a trick to detect the class/interface you want to mock.
+     * @return spy object
+     * @since 4.10.0
+     */
+    @SafeVarargs
+    public static <T> T spy(T... reified) {
+        if (reified.length > 0) {
+            throw new IllegalArgumentException(
+                    "Please don't pass any values here. Java will detect class automagically.");
+        }
+        return spy(getClassOf(reified));
+    }
+
+    private static <T> Class<T> getClassOf(T[] array) {
+        return (Class<T>) array.getClass().getComponentType();
+    }
+
+    /**
+     * Creates a thread-local mock controller for all static methods of the given class or interface.
+     * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+     * classes used by custom class loaders used to execute the block with the mocked class. A mock
+     * maker might forbid mocking static methods of know classes that are known to cause problems.
+     * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+     * explicitly forbidden.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock class or interface of which static mocks should be mocked.
+     * @return mock controller
+     */
+    public static <T> MockedStatic<T> mockStatic(Class<T> classToMock) {
+        return mockStatic(classToMock, withSettings());
+    }
+
+    /**
+     * Creates a thread-local mock controller for all static methods of the given class or interface.
+     * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+     * classes used by custom class loaders used to execute the block with the mocked class. A mock
+     * maker might forbid mocking static methods of know classes that are known to cause problems.
+     * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+     * explicitly forbidden.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock class or interface of which static mocks should be mocked.
+     * @param defaultAnswer the default answer when invoking static methods.
+     * @return mock controller
+     */
+    public static <T> MockedStatic<T> mockStatic(Class<T> classToMock, Answer defaultAnswer) {
+        return mockStatic(classToMock, withSettings().defaultAnswer(defaultAnswer));
+    }
+
+    /**
+     * Creates a thread-local mock controller for all static methods of the given class or interface.
+     * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+     * classes used by custom class loaders used to execute the block with the mocked class. A mock
+     * maker might forbid mocking static methods of know classes that are known to cause problems.
+     * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+     * explicitly forbidden.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock class or interface of which static mocks should be mocked.
+     * @param name the name of the mock to use in error messages.
+     * @return mock controller
+     */
+    public static <T> MockedStatic<T> mockStatic(Class<T> classToMock, String name) {
+        return mockStatic(classToMock, withSettings().name(name));
+    }
+
+    /**
+     * Creates a thread-local mock controller for all static methods of the given class or interface.
+     * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+     * classes used by custom class loaders used to execute the block with the mocked class. A mock
+     * maker might forbid mocking static methods of know classes that are known to cause problems.
+     * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+     * explicitly forbidden.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock class or interface of which static mocks should be mocked.
+     * @param mockSettings the settings to use where only name and default answer are considered.
+     * @return mock controller
+     */
+    public static <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings mockSettings) {
+        return MOCKITO_CORE.mockStatic(classToMock, mockSettings);
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @param defaultAnswer the default answer for the first created mock.
+     * @param additionalAnswers the default answer for all additional mocks. For any access mocks, the
+     *                         last answer is used. If this array is empty, the {@code defaultAnswer} is used.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstructionWithAnswer(
+            Class<T> classToMock, Answer defaultAnswer, Answer... additionalAnswers) {
+        return mockConstruction(
+                classToMock,
+                context -> {
+                    if (context.getCount() == 1 || additionalAnswers.length == 0) {
+                        return withSettings().defaultAnswer(defaultAnswer);
+                    } else if (context.getCount() > additionalAnswers.length) {
+                        return withSettings()
+                                .defaultAnswer(additionalAnswers[additionalAnswers.length - 1]);
+                    } else {
+                        return withSettings()
+                                .defaultAnswer(additionalAnswers[context.getCount() - 2]);
+                    }
+                },
+                (mock, context) -> {});
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock) {
+        return mockConstruction(classToMock, index -> withSettings(), (mock, context) -> {});
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @param mockInitializer a callback to prepare the methods on a mock after its instantiation.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstruction(
+            Class<T> classToMock, MockedConstruction.MockInitializer<T> mockInitializer) {
+        return mockConstruction(classToMock, withSettings(), mockInitializer);
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @param mockSettings the mock settings to use.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstruction(
+            Class<T> classToMock, MockSettings mockSettings) {
+        return mockConstruction(classToMock, context -> mockSettings);
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @param mockSettingsFactory the mock settings to use.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstruction(
+            Class<T> classToMock,
+            Function<MockedConstruction.Context, MockSettings> mockSettingsFactory) {
+        return mockConstruction(classToMock, mockSettingsFactory, (mock, context) -> {});
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @param mockSettings the settings to use.
+     * @param mockInitializer a callback to prepare the methods on a mock after its instantiation.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstruction(
+            Class<T> classToMock,
+            MockSettings mockSettings,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        return mockConstruction(classToMock, index -> mockSettings, mockInitializer);
+    }
+
+    /**
+     * Creates a thread-local mock controller for all constructions of the given class.
+     * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+     * test or the mock will remain active on the current thread.
+     * <p>
+     * See examples in javadoc for {@link Mockito} class
+     *
+     * @param classToMock non-abstract class of which constructions should be mocked.
+     * @param mockSettingsFactory a function to create settings to use.
+     * @param mockInitializer a callback to prepare the methods on a mock after its instantiation.
+     * @return mock controller
+     */
+    public static <T> MockedConstruction<T> mockConstruction(
+            Class<T> classToMock,
+            Function<MockedConstruction.Context, MockSettings> mockSettingsFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        return MOCKITO_CORE.mockConstruction(classToMock, mockSettingsFactory, mockInitializer);
     }
 
     /**
@@ -2070,7 +2595,7 @@ public static <T> T spy(Class<T> classToSpy) {
      * <p>
      * Stubbing can be overridden: for example common stubbing can go to fixture
      * setup but the test methods can override it.
-     * Please note that overridding stubbing is a potential code smell that points out too much stubbing.
+     * Please note that overriding stubbing is a potential code smell that points out too much stubbing.
      * <p>
      * Once stubbed, the method will always return stubbed value regardless
      * of how many times it is called.
@@ -2089,7 +2614,6 @@ public static <T> T spy(Class<T> classToSpy) {
      * @return OngoingStubbing object used to stub fluently.
      *         <strong>Do not</strong> create a reference to this returned object.
      */
-    @CheckReturnValue
     public static <T> OngoingStubbing<T> when(T methodCall) {
         return MOCKITO_CORE.when(methodCall);
     }
@@ -2112,7 +2636,7 @@ public static <T> OngoingStubbing<T> when(T methodCall) {
      * Although it is possible to verify a stubbed invocation, usually <b>it's just redundant</b>.
      * Let's say you've stubbed <code>foo.bar()</code>.
      * If your code cares what <code>foo.bar()</code> returns then something else breaks(often before even <code>verify()</code> gets executed).
-     * If your code doesn't care what <code>get(0)</code> returns then it should not be stubbed.
+     * If your code doesn't care what <code>foo.bar()</code> returns then it should not be stubbed.
      *
      * <p>
      * See examples in javadoc for {@link Mockito} class
@@ -2120,7 +2644,6 @@ public static <T> OngoingStubbing<T> when(T methodCall) {
      * @param mock to be verified
      * @return mock object itself
      */
-    @CheckReturnValue
     public static <T> T verify(T mock) {
         return MOCKITO_CORE.verify(mock, times(1));
     }
@@ -2147,7 +2670,6 @@ public static <T> T verify(T mock) {
      *
      * @return mock object itself
      */
-    @CheckReturnValue
     public static <T> T verify(T mock, VerificationMode mode) {
         return MOCKITO_CORE.verify(mock, mode);
     }
@@ -2158,7 +2680,7 @@ public static <T> T verify(T mock, VerificationMode mode) {
      * <p>
      * Instead of <code>#reset()</code> please consider writing simple, small and focused test methods over lengthy, over-specified tests.
      * <b>First potential code smell is <code>reset()</code> in the middle of the test method.</b> This probably means you're testing too much.
-     * Follow the whisper of your test methods: "Please keep us small & focused on single behavior".
+     * Follow the whisper of your test methods: "Please keep us small and focused on single behavior".
      * There are several threads about it on mockito mailing list.
      * <p>
      * The only reason we added <code>reset()</code> method is to
@@ -2172,16 +2694,27 @@ public static <T> T verify(T mock, VerificationMode mode) {
      *   mock.add(1);
      *
      *   reset(mock);
-     *   //at this point the mock forgot any interactions & stubbing
+     *   //at this point the mock forgot any interactions and stubbing
      * </code></pre>
      *
      * @param <T> The Type of the mocks
      * @param mocks to be reset
      */
-    public static <T> void reset(T ... mocks) {
+    public static <T> void reset(T... mocks) {
         MOCKITO_CORE.reset(mocks);
     }
 
+    /**
+     * Clears all mocks, type caches and instrumentations.
+     * <p>
+     * By clearing Mockito's state, previously created mocks might begin to malfunction. This option can be used if
+     * Mockito's caches take up too much space or if the inline mock maker's instrumentation is causing performance
+     * issues in code where mocks are no longer used. Normally, you would not need to use this option.
+     */
+    public static void clearAllCaches() {
+        MOCKITO_CORE.clearAllCaches();
+    }
+
     /**
      * Use this method in order to only clear invocations, when stubbing is non-trivial. Use-cases can be:
      * <ul>
@@ -2193,7 +2726,7 @@ public static <T> void reset(T ... mocks) {
      * @param <T> The type of the mocks
      * @param mocks The mocks to clear the invocations for
      */
-    public static <T> void clearInvocations(T ... mocks) {
+    public static <T> void clearInvocations(T... mocks) {
         MOCKITO_CORE.clearInvocations(mocks);
     }
 
@@ -2214,7 +2747,7 @@ public static <T> void clearInvocations(T ... mocks) {
      * Some users who did a lot of classic, expect-run-verify mocking tend to use <code>verifyNoMoreInteractions()</code> very often, even in every test method.
      * <code>verifyNoMoreInteractions()</code> is not recommended to use in every test method.
      * <code>verifyNoMoreInteractions()</code> is a handy assertion from the interaction testing toolkit. Use it only when it's relevant.
-     * Abusing it leads to overspecified, less maintainable tests.
+     * Abusing it leads to over-specified, less maintainable tests.
      * <p>
      * This method will also detect unverified invocations that occurred before the test method,
      * for example: in <code>setUp()</code>, <code>&#064;Before</code> method or in constructor.
@@ -2244,18 +2777,6 @@ public static void verifyNoMoreInteractions(Object... mocks) {
         MOCKITO_CORE.verifyNoMoreInteractions(mocks);
     }
 
-    /**
-     * Verifies that no interactions happened on given mocks beyond the previously verified interactions.<br/>
-     * This method has the same behavior as {@link #verifyNoMoreInteractions(Object...)}.
-     *
-     * @param mocks to be verified
-     * @deprecated Since 3.0.1. Please migrate your code to {@link #verifyNoInteractions(Object...)}
-     */
-    @Deprecated
-    public static void verifyZeroInteractions(Object... mocks) {
-        MOCKITO_CORE.verifyNoMoreInteractions(mocks);
-    }
-
     /**
      * Verifies that no interactions happened on given mocks.
      * <pre class="code"><code class="java">
@@ -2291,7 +2812,6 @@ public static void verifyNoInteractions(Object... mocks) {
      * @param toBeThrown to be thrown when the stubbed method is called
      * @return stubber - to select a method for stubbing
      */
-    @CheckReturnValue
     public static Stubber doThrow(Throwable... toBeThrown) {
         return MOCKITO_CORE.stubber().doThrow(toBeThrown);
     }
@@ -2314,14 +2834,14 @@ public static Stubber doThrow(Throwable... toBeThrown) {
      * @return stubber - to select a method for stubbing
      * @since 2.1.0
      */
-    @CheckReturnValue
     public static Stubber doThrow(Class<? extends Throwable> toBeThrown) {
         return MOCKITO_CORE.stubber().doThrow(toBeThrown);
     }
 
     /**
      * Same as {@link #doThrow(Class)} but sets consecutive exception classes to be thrown. Remember to use
-     * <code>doThrow()</code> when you want to stub the void method to throw several exception of specified class.
+     * <code>doThrow()</code> when you want to stub the void method to throw several exceptions
+     * that are instances of the specified class.
      * <p>
      * A new exception instance will be created for each method invocation.
      * <p>
@@ -2339,26 +2859,26 @@ public static Stubber doThrow(Class<? extends Throwable> toBeThrown) {
      * @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"})
-    @CheckReturnValue
-    public static Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... toBeThrownNext) {
+    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+    // creation
+    @SuppressWarnings({"unchecked", "varargs"})
+    public static Stubber doThrow(
+            Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... toBeThrownNext) {
         return MOCKITO_CORE.stubber().doThrow(toBeThrown, toBeThrownNext);
     }
 
-
     /**
      * Use <code>doCallRealMethod()</code> when you want to call the real implementation of a method.
      * <p>
-     * As usual you are going to read <b>the partial mock warning</b>:
-     * Object oriented programming is more less tackling complexity by dividing the complexity into separate, specific, SRPy objects.
+     * As usual, you are going to read <b>the partial mock warning</b>:
+     * Object oriented programming is more-or-less tackling complexity by dividing the complexity into separate, specific, SRPy objects.
      * How does partial mock fit into this paradigm? Well, it just doesn't...
      * Partial mock usually means that the complexity has been moved to a different method on the same object.
      * In most cases, this is not the way you want to design your application.
      * <p>
      * However, there are rare cases when partial mocks come handy:
      * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
-     * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+     * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
      * <p>
      * See also javadoc {@link Mockito#spy(Object)} to find out more about partial mocks.
      * <b>Mockito.spy() is a recommended way of creating partial mocks.</b>
@@ -2378,7 +2898,6 @@ public static Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? ext
      * @return stubber - to select a method for stubbing
      * @since 1.9.5
      */
-    @CheckReturnValue
     public static Stubber doCallRealMethod() {
         return MOCKITO_CORE.stubber().doCallRealMethod();
     }
@@ -2405,7 +2924,6 @@ public static Stubber doCallRealMethod() {
      * @param answer to answer when the stubbed method is called
      * @return stubber - to select a method for stubbing
      */
-    @CheckReturnValue
     public static Stubber doAnswer(Answer answer) {
         return MOCKITO_CORE.stubber().doAnswer(answer);
     }
@@ -2448,7 +2966,6 @@ public static Stubber doAnswer(Answer answer) {
      *
      * @return stubber - to select a method for stubbing
      */
-    @CheckReturnValue
     public static Stubber doNothing() {
         return MOCKITO_CORE.stubber().doNothing();
     }
@@ -2492,14 +3009,13 @@ public static Stubber doNothing() {
      *
      * Above scenarios shows a tradeoff of Mockito's elegant syntax. Note that the scenarios are very rare, though.
      * Spying should be sporadic and overriding exception-stubbing is very rare. Not to mention that in general
-     * overridding stubbing is a potential code smell that points out too much stubbing.
+     * overriding stubbing is a potential code smell that points out too much stubbing.
      * <p>
      * See examples in javadoc for {@link Mockito} class
      *
      * @param toBeReturned to be returned when the stubbed method is called
      * @return stubber - to select a method for stubbing
      */
-    @CheckReturnValue
     public static Stubber doReturn(Object toBeReturned) {
         return MOCKITO_CORE.stubber().doReturn(toBeReturned);
     }
@@ -2544,7 +3060,7 @@ public static Stubber doReturn(Object toBeReturned) {
      *
      * Above scenarios shows a trade-off of Mockito's elegant syntax. Note that the scenarios are very rare, though.
      * Spying should be sporadic and overriding exception-stubbing is very rare. Not to mention that in general
-     * overridding stubbing is a potential code smell that points out too much stubbing.
+     * overriding stubbing is a potential code smell that points out too much stubbing.
      * <p>
      * See examples in javadoc for {@link Mockito} class
      *
@@ -2554,7 +3070,6 @@ public static Stubber doReturn(Object toBeReturned) {
      * @since 2.1.0
      */
     @SuppressWarnings({"unchecked", "varargs"})
-    @CheckReturnValue
     public static Stubber doReturn(Object toBeReturned, Object... toBeReturnedNext) {
         return MOCKITO_CORE.stubber().doReturn(toBeReturned, toBeReturnedNext);
     }
@@ -2586,7 +3101,6 @@ public static Stubber doReturn(Object toBeReturned, Object... toBeReturnedNext)
      *
      * @return InOrder object to be used to verify in order
      */
-    @CheckReturnValue
     public static InOrder inOrder(Object... mocks) {
         return MOCKITO_CORE.inOrder(mocks);
     }
@@ -2597,7 +3111,7 @@ public static InOrder inOrder(Object... mocks) {
      * 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.
+     * Helps to avoid 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>
      * Bear in mind that Mockito does not recommend bombarding every test with <code>verifyNoMoreInteractions()</code>
@@ -2687,7 +3201,6 @@ public static Object[] ignoreStubs(Object... mocks) {
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode times(int wantedNumberOfInvocations) {
         return VerificationModeFactory.times(wantedNumberOfInvocations);
     }
@@ -2702,14 +3215,12 @@ public static VerificationMode times(int wantedNumberOfInvocations) {
      *
      * <p>
      * If you want to verify there were NO interactions with the mock
-     * check out {@link Mockito#verifyZeroInteractions(Object...)}
-     * or {@link Mockito#verifyNoMoreInteractions(Object...)}
+     * check out {@link Mockito#verifyNoMoreInteractions(Object...)}
      * <p>
      * See examples in javadoc for {@link Mockito} class
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode never() {
         return times(0);
     }
@@ -2725,7 +3236,6 @@ public static VerificationMode never() {
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode atLeastOnce() {
         return VerificationModeFactory.atLeastOnce();
     }
@@ -2742,7 +3252,6 @@ public static VerificationMode atLeastOnce() {
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode atLeast(int minNumberOfInvocations) {
         return VerificationModeFactory.atLeast(minNumberOfInvocations);
     }
@@ -2758,7 +3267,6 @@ public static VerificationMode atLeast(int minNumberOfInvocations) {
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode atMostOnce() {
         return VerificationModeFactory.atMostOnce();
     }
@@ -2775,7 +3283,6 @@ public static VerificationMode atMostOnce() {
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode atMost(int maxNumberOfInvocations) {
         return VerificationModeFactory.atMost(maxNumberOfInvocations);
     }
@@ -2793,9 +3300,8 @@ public static VerificationMode atMost(int maxNumberOfInvocations) {
      * @param wantedNumberOfInvocations number of invocations to verify
      * @return  verification mode
      */
-    @CheckReturnValue
-    public static VerificationMode calls( int wantedNumberOfInvocations ){
-        return VerificationModeFactory.calls( wantedNumberOfInvocations );
+    public static VerificationMode calls(int wantedNumberOfInvocations) {
+        return VerificationModeFactory.calls(wantedNumberOfInvocations);
     }
 
     /**
@@ -2814,7 +3320,6 @@ public static VerificationMode calls( int wantedNumberOfInvocations ){
      *
      * @return verification mode
      */
-    @CheckReturnValue
     public static VerificationMode only() {
         return VerificationModeFactory.only();
     }
@@ -2847,14 +3352,13 @@ public static VerificationMode only() {
      *
      * @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));
     }
 
     /**
      * 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.
+     * Useful when interactions with the mock object have yet to occur.
      * Extensive use of {@code after()} method can be a code smell - there are better ways of testing concurrent code.
      * <p>
      * Not yet implemented to work with InOrder verification.
@@ -2903,7 +3407,6 @@ public static VerificationWithTimeout timeout(long millis) {
      *
      * @return object that allows fluent specification of the verification
      */
-    @CheckReturnValue
     public static VerificationAfterDelay after(long millis) {
         return new After(millis, VerificationModeFactory.times(1));
     }
@@ -2911,7 +3414,7 @@ public static VerificationAfterDelay after(long millis) {
     /**
      * First of all, in case of any trouble, I encourage you to read the Mockito FAQ: <a href="https://github.com/mockito/mockito/wiki/FAQ">https://github.com/mockito/mockito/wiki/FAQ</a>
      * <p>
-     * In case of questions you may also post to mockito mailing list: <a href="http://groups.google.com/group/mockito">http://groups.google.com/group/mockito</a>
+     * In case of questions you may also post to mockito mailing list: <a href="https://groups.google.com/group/mockito">https://groups.google.com/group/mockito</a>
      * <p>
      * <code>validateMockitoUsage()</code> <b>explicitly validates</b> the framework state to detect invalid use of Mockito.
      * However, this feature is optional <b>because Mockito validates the usage all the time...</b> but there is a gotcha so read on.
@@ -2962,12 +3465,12 @@ public static void validateMockitoUsage() {
      * <p>
      * Don't use it too often.
      * Consider writing simple tests that use simple mocks.
-     * Repeat after me: simple tests push simple, KISSy, readable & maintainable code.
+     * Repeat after me: simple tests push simple, KISSy, readable and maintainable code.
      * If you cannot write a test in a simple way - refactor the code under test.
      * <p>
      * Examples of mock settings:
      * <pre class="code"><code class="java">
-     *   //Creates mock with different default answer & name
+     *   //Creates mock with different default answer and name
      *   Foo mock = mock(Foo.class, withSettings()
      *       .defaultAnswer(RETURNS_SMART_NULLS)
      *       .name("cool mockie"));
@@ -2987,7 +3490,6 @@ public static void validateMockitoUsage() {
      *
      * @return mock settings instance with defaults.
      */
-    @CheckReturnValue
     public static MockSettings withSettings() {
         return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS);
     }
@@ -3001,42 +3503,27 @@ public static MockSettings withSettings() {
      * @return verification mode
      * @since 2.1.0
      */
-    @CheckReturnValue
     public static VerificationMode description(String description) {
         return times(1).description(description);
     }
 
-    /**
-     * @deprecated - please use {@link MockingDetails#printInvocations()} instead.
-     * An instance of {@code MockingDetails} can be retrieved via {@link #mockingDetails(Object)}.
-     */
-    @Deprecated
-    @CheckReturnValue
-    static MockitoDebugger debug() {
-        return new MockitoDebuggerImpl();
-    }
-
     /**
      * For advanced users or framework integrators. See {@link MockitoFramework} class.
      *
      * @since 2.1.0
      */
-    @Incubating
-    @CheckReturnValue
     public static MockitoFramework framework() {
         return new DefaultMockitoFramework();
     }
 
     /**
      * {@code MockitoSession} is an optional, highly recommended feature
-     * that helps driving cleaner tests by eliminating boilerplate code and adding extra validation.
+     * that drives writing cleaner tests by eliminating boilerplate code and adding extra validation.
      * <p>
      * For more information, including use cases and sample code, see the javadoc for {@link MockitoSession}.
      *
      * @since 2.7.0
      */
-    @Incubating
-    @CheckReturnValue
     public static MockitoSessionBuilder mockitoSession() {
         return new DefaultMockitoSessionBuilder();
     }
@@ -3053,7 +3540,7 @@ public static MockitoSessionBuilder mockitoSession() {
      * 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 mock need to have lenient stubbings - use {@link MockSettings#strictness(Strictness)}</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>
      *
@@ -3104,7 +3591,6 @@ public static MockitoSessionBuilder mockitoSession() {
      *
      * @since 2.20.0
      */
-    @Incubating
     public static LenientStubber lenient() {
         return MOCKITO_CORE.lenient();
     }
diff --git a/mockito-core/src/main/java/org/mockito/MockitoAnnotations.java b/mockito-core/src/main/java/org/mockito/MockitoAnnotations.java
new file mode 100644
index 0000000000..5857478ca6
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/MockitoAnnotations.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.GlobalConfiguration;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.plugins.AnnotationEngine;
+
+/**
+ * MockitoAnnotations.openMocks(this); initializes fields annotated with Mockito annotations.
+ * See also {@link MockitoSession} which not only initializes mocks
+ * but also adds extra validation for cleaner tests!
+ * <p>
+ * <ul>
+ * <li>Allows shorthand creation of objects required for testing.</li>
+ * <li>Minimizes repetitive mock creation code.</li>
+ * <li>Makes the test class more readable.</li>
+ * <li>Makes the verification error easier to read because <b>field name</b> is used to identify the mock.</li>
+ * </ul>
+ *
+ * <pre class="code"><code class="java">
+ *   public class ArticleManagerTest extends SampleBaseTestCase {
+ *
+ *       &#064;Mock private ArticleCalculator calculator;
+ *       &#064;Mock private ArticleDatabase database;
+ *       &#064;Mock private UserProvider userProvider;
+ *
+ *       private ArticleManager manager;
+ *
+ *       &#064;Before public void setup() {
+ *           manager = new ArticleManager(userProvider, database, calculator);
+ *       }
+ *   }
+ *
+ *   public class SampleBaseTestCase {
+ *
+ *       private AutoCloseable closeable;
+ *
+ *       &#064;Before public void openMocks() {
+ *           closeable = MockitoAnnotations.openMocks(this);
+ *       }
+ *
+ *       &#064;After public void releaseMocks() throws Exception {
+ *           closeable.close();
+ *       }
+ *   }
+ * </code></pre>
+ * <p>
+ * Read also about other annotations &#064;{@link Spy}, &#064;{@link Captor}, &#064;{@link InjectMocks}
+ * <p>
+ * <b><code>MockitoAnnotations.openMocks(this)</code></b> method has to be called to initialize annotated fields.
+ * <p>
+ * In above example, <code>openMocks()</code> is called in &#064;Before (JUnit4) method of test's base class.
+ * You can also put openMocks() in your JUnit runner (&#064;RunWith) or use built-in runner: {@link MockitoJUnitRunner}.
+ * If static method mocks are used, it is required to close the initialization. Additionally, if using third-party
+ * mock-makers, other life-cycles might be handled by the open-release routine.
+ */
+public final class MockitoAnnotations {
+
+    /**
+     * Initializes objects annotated with Mockito annotations for given testClass:
+     *  &#064;{@link org.mockito.Mock}, &#064;{@link Spy}, &#064;{@link Captor}, &#064;{@link InjectMocks}
+     * <p>
+     * See examples in javadoc for {@link MockitoAnnotations} class.
+     *
+     * @return A closable to close when completing any tests in {@code testClass}.
+     */
+    public static AutoCloseable openMocks(Object testClass) {
+        if (testClass == null) {
+            throw new MockitoException(
+                    "testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class");
+        }
+
+        AnnotationEngine annotationEngine =
+                new GlobalConfiguration().tryGetPluginAnnotationEngine();
+        return annotationEngine.process(testClass.getClass(), testClass);
+    }
+
+    /**
+     * Initializes objects annotated with Mockito annotations for given testClass:
+     *  &#064;{@link org.mockito.Mock}, &#064;{@link Spy}, &#064;{@link Captor}, &#064;{@link InjectMocks}
+     * <p>
+     * See examples in javadoc for {@link MockitoAnnotations} class.
+     *
+     * @deprecated Use {@link MockitoAnnotations#openMocks(Object)} instead.
+     * This method is equivalent to {@code openMocks(testClass).close()}.
+     * The close method should however only be called after completed usage of {@code testClass}.
+     * If using static-mocks or custom {@link org.mockito.plugins.MockMaker}s, using this method might
+     * cause misbehavior of mocks injected into the test class.
+     */
+    @Deprecated
+    public static void initMocks(Object testClass) {
+        try {
+            openMocks(testClass).close();
+        } catch (Exception e) {
+            throw new MockitoException(
+                    join(
+                            "Failed to release mocks",
+                            "",
+                            "This should not happen unless you are using a third-party mock maker"),
+                    e);
+        }
+    }
+
+    private MockitoAnnotations() {}
+}
diff --git a/src/main/java/org/mockito/MockitoFramework.java b/mockito-core/src/main/java/org/mockito/MockitoFramework.java
similarity index 87%
rename from src/main/java/org/mockito/MockitoFramework.java
rename to mockito-core/src/main/java/org/mockito/MockitoFramework.java
index da03ef4d80..bf3843b902 100644
--- a/src/main/java/org/mockito/MockitoFramework.java
+++ b/mockito-core/src/main/java/org/mockito/MockitoFramework.java
@@ -4,6 +4,7 @@
  */
 package org.mockito;
 
+import org.mockito.exceptions.misusing.DisabledMockException;
 import org.mockito.exceptions.misusing.RedundantListenerException;
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.InvocationFactory;
@@ -19,7 +20,6 @@
  *
  * @since 2.1.0
  */
-@Incubating
 @NotExtensible
 public interface MockitoFramework {
 
@@ -27,13 +27,13 @@ public interface MockitoFramework {
      * Adds listener to Mockito.
      * For a list of supported listeners, see the interfaces that extend {@link MockitoListener}.
      * <p>
-     * Listeners can be useful for engs that extend Mockito framework.
+     * Listeners can be useful for components that extend Mockito framework.
      * They are used in the implementation of unused stubbings warnings ({@link org.mockito.quality.MockitoHint}).
      * <p>
      * Make sure you remove the listener when the job is complete, see {@link #removeListener(MockitoListener)}.
-     * Currently the listeners list is thread local so you need to remove listener from the same thread otherwise
+     * Currently, the listeners list is thread local, so you need to remove listener from the same thread otherwise
      * remove is ineffectual.
-     * In typical scenarios, it is not a problem, because adding & removing listeners typically happens in the same thread.
+     * In typical scenarios, it is not a problem, because adding and removing listeners typically happens in the same thread.
      * <p>
      * If you are trying to add the listener but a listener of the same type was already added (and not removed)
      * this method will throw {@link RedundantListenerException}.
@@ -53,14 +53,13 @@ public interface MockitoFramework {
      * @return this instance of mockito framework (fluent builder pattern)
      * @since 2.1.0
      */
-    @Incubating
     MockitoFramework addListener(MockitoListener listener) throws RedundantListenerException;
 
     /**
      * When you add listener using {@link #addListener(MockitoListener)} make sure to remove it.
-     * Currently the listeners list is thread local so you need to remove listener from the same thread otherwise
+     * Currently, the listeners list is thread local, so you need to remove listener from the same thread otherwise
      * remove is ineffectual.
-     * In typical scenarios, it is not a problem, because adding & removing listeners typically happens in the same thread.
+     * In typical scenarios, it is not a problem, because adding and removing listeners typically happens in the same thread.
      * <p>
      * For usage examples, see Mockito codebase.
      * If you have ideas and feature requests about Mockito listeners API
@@ -70,7 +69,6 @@ public interface MockitoFramework {
      * @return this instance of mockito framework (fluent builder pattern)
      * @since 2.1.0
      */
-    @Incubating
     MockitoFramework removeListener(MockitoListener listener);
 
     /**
@@ -81,7 +79,6 @@ public interface MockitoFramework {
      * @return object that gives access to mockito plugins
      * @since 2.10.0
      */
-    @Incubating
     MockitoPlugins getPlugins();
 
     /**
@@ -91,13 +88,14 @@ public interface MockitoFramework {
      * @return object that can construct invocations
      * @since 2.10.0
      */
-    @Incubating
     InvocationFactory getInvocationFactory();
 
     /**
-     * Clears up internal state of all inline mocks.
+     * Clears up internal state of all inline mocks.  Attempts to interact with mocks after this
+     * is called will throw {@link DisabledMockException}.
+     * <p>
      * This method is only meaningful if inline mock maker is in use.
-     * Otherwise this method is a no-op and need not be used.
+     * For all other intents and purposes, this method is a no-op and need not be used.
      * <p>
      * This method is useful to tackle subtle memory leaks that are possible due to the nature of inline mocking
      * (issue <a href="https://github.com/mockito/mockito/pull/1619">#1619</a>).
@@ -130,7 +128,6 @@ public interface MockitoFramework {
      * @since 2.25.0
      * @see #clearInlineMock(Object)
      */
-    @Incubating
     void clearInlineMocks();
 
     /**
@@ -142,6 +139,5 @@ public interface MockitoFramework {
      * @since 2.25.0
      * @see #clearInlineMocks()
      */
-    @Incubating
     void clearInlineMock(Object mock);
 }
diff --git a/src/main/java/org/mockito/MockitoSession.java b/mockito-core/src/main/java/org/mockito/MockitoSession.java
similarity index 91%
rename from src/main/java/org/mockito/MockitoSession.java
rename to mockito-core/src/main/java/org/mockito/MockitoSession.java
index 6a529fde43..f87e07dcd4 100644
--- a/src/main/java/org/mockito/MockitoSession.java
+++ b/mockito-core/src/main/java/org/mockito/MockitoSession.java
@@ -8,6 +8,7 @@
 import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner.StrictStubs;
 import org.mockito.junit.MockitoRule;
 import org.mockito.listeners.MockitoListener;
 import org.mockito.quality.MockitoHint;
@@ -16,18 +17,17 @@
 
 /**
  * {@code MockitoSession} is an optional, highly recommended feature
- * that helps driving cleaner tests by eliminating boilerplate code and adding extra validation.
+ * that drives writing cleaner tests by eliminating boilerplate code and adding extra validation.
  * If you already use {@link MockitoJUnitRunner} or {@link MockitoRule}
  * *you don't need* {@code MockitoSession} because it is used by the runner/rule.
  * <p>
  * {@code MockitoSession} is a session of mocking, during which the user creates and uses Mockito mocks.
- * Typically the session is an execution of a single test method.
+ * Typically, the session is an execution of a single test method.
  * {@code MockitoSession} initializes mocks, validates usage and detects incorrect stubbing.
  * When the session is started it must be concluded with {@link #finishMocking()}
  * otherwise {@link UnfinishedMockingSessionException} is triggered when the next session is created.
  * <p>
  * {@code MockitoSession} is useful when you cannot use {@link MockitoJUnitRunner} or {@link MockitoRule}.
- * For example, you work with TestNG instead of JUnit.
  * Another example is when different JUnit runner is in use (Jukito, Springockito)
  * and it cannot be combined with Mockito's own runner.
  * <p>
@@ -67,18 +67,18 @@
  * <p>
  * Why to use {@code MockitoSession}?
  * What's the difference between {@code MockitoSession}, {@link MockitoJUnitRunner}, {@link MockitoRule}
- * and traditional {@link MockitoAnnotations#initMocks(Object)}?
+ * and traditional {@link MockitoAnnotations#openMocks(Object)}?
  * <p>
  * Great questions!
  * There is no need to use {@code MockitoSession} if you already use {@link MockitoJUnitRunner} or {@link MockitoRule}.
  * If you are JUnit user who does not leverage Mockito rule or runner we strongly recommend to do so.
  * Both the runner and the rule support strict stubbing which can really help driving cleaner tests.
- * See {@link MockitoJUnitRunner.StrictStubs} and {@link MockitoRule#strictness(Strictness)}.
- * If you cannot use Mockito's JUnit support (for example, you are on TestNG) {@code MockitoSession} exactly is for you!
+ * See {@link StrictStubs MockitoJUnitRunner.StrictStubs} and {@link MockitoRule#strictness(Strictness)}.
+ * If you cannot use Mockito's JUnit support {@code MockitoSession} exactly is for you!
  * You can automatically take advantage of strict stubbing ({@link Strictness}),
  * automatic initialization of annotated mocks ({@link MockitoAnnotations}),
  * and extra validation ({@link Mockito#validateMockitoUsage()}).
- * If you use Mockito annotations with {@link MockitoAnnotations#initMocks(Object)}
+ * If you use Mockito annotations with {@link MockitoAnnotations#openMocks(Object)}
  * but not Mockito runner/rule please try out Mockito's JUnit support (runner or rule) or
  * start using {@code MockitoSession}. You'll get cleaner tests and better productivity.
  * <p>
@@ -87,7 +87,6 @@
  *
  * @since 2.7.0
  */
-@Incubating
 @NotExtensible
 public interface MockitoSession {
 
@@ -102,7 +101,6 @@ public interface MockitoSession {
      * @param strictness new strictness for this session.
      * @since 2.15.0
      */
-    @Incubating
     void setStrictness(Strictness strictness);
 
     /**
@@ -124,7 +122,6 @@ public interface MockitoSession {
      * @see #finishMocking(Throwable)
      * @since 2.7.0
      */
-    @Incubating
     void finishMocking();
 
     /**
@@ -141,6 +138,5 @@ public interface MockitoSession {
      * @see #finishMocking()
      * @since 2.15.0
      */
-    @Incubating
     void finishMocking(Throwable failure);
 }
diff --git a/src/main/java/org/mockito/NotExtensible.java b/mockito-core/src/main/java/org/mockito/NotExtensible.java
similarity index 90%
rename from src/main/java/org/mockito/NotExtensible.java
rename to mockito-core/src/main/java/org/mockito/NotExtensible.java
index de67a0a14e..f5110f5d57 100644
--- a/src/main/java/org/mockito/NotExtensible.java
+++ b/mockito-core/src/main/java/org/mockito/NotExtensible.java
@@ -19,12 +19,11 @@
  * Public types are all types that are *not* under "org.mockito.internal.*" package.
  * <p>
  * Absence of {@code NotExtensible} annotation on a type *does not* mean it is intended to be extended.
- * The annotation has been introduced late and therefore it is not used frequently in the codebase.
+ * The annotation has been introduced late, and therefore it is not used frequently in the codebase.
  * Many public types from Mockito API are not intended for extension, even though they do not have this annotation applied.
  *
  * @since 2.10.0
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
-public @interface NotExtensible {
-}
+public @interface NotExtensible {}
diff --git a/mockito-core/src/main/java/org/mockito/ScopedMock.java b/mockito-core/src/main/java/org/mockito/ScopedMock.java
new file mode 100644
index 0000000000..ab2b94c76d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/ScopedMock.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+/**
+ * Represents a mock with a thread-local explicit scope. Scoped mocks must be closed by the entity
+ * that activates the scoped mock.
+ */
+public interface ScopedMock extends AutoCloseable {
+
+    /**
+     * Checks if this mock is closed.
+     *
+     * @return {@code true} if this mock is closed.
+     */
+    boolean isClosed();
+
+    /**
+     * Closes this scoped mock and throws an exception if already closed.
+     */
+    @Override
+    void close();
+
+    /**
+     * Releases this scoped mock and is non-operational if already released.
+     */
+    void closeOnDemand();
+}
diff --git a/src/main/java/org/mockito/Spy.java b/mockito-core/src/main/java/org/mockito/Spy.java
similarity index 83%
rename from src/main/java/org/mockito/Spy.java
rename to mockito-core/src/main/java/org/mockito/Spy.java
index 2f9825f146..fa5e6e5ad0 100644
--- a/src/main/java/org/mockito/Spy.java
+++ b/mockito-core/src/main/java/org/mockito/Spy.java
@@ -14,7 +14,7 @@
 import org.mockito.junit.MockitoJUnitRunner;
 
 /**
- * Allows shorthand wrapping of field instances in an spy object.
+ * Allows shorthand wrapping of field instances in a spy object.
  *
  * <p>
  * Example:
@@ -25,9 +25,14 @@
  *    &#64;Spy Foo spyOnFoo = new Foo("argument");
  *    //Instance for spying is created by mockito via reflection (only default constructors supported):
  *    &#64;Spy Bar spyOnBar;
+ *    private AutoCloseable closeable;
  *    &#64;Before
- *    public void init(){
- *       MockitoAnnotations.initMocks(this);
+ *    public void init() {
+ *       closeable = MockitoAnnotations.openMocks(this);
+ *    }
+ *    &#64;After
+ *    public void release() throws Exception {
+ *       closeable.close();
  *    }
  *    ...
  * }
@@ -74,7 +79,7 @@
  * <li>Mockito <b>*does not*</b> delegate calls to the passed real instance, instead it actually creates a copy of it.
  * So if you keep the real instance and interact with it, don't expect the spied to be aware of those interaction
  * and their effect on real instance state.
- * The corollary is that when an <b>*unstubbed*</b> method is called <b>*on the spy*</b> but <b>*not on the real instance*</b>,
+ * The corollary is that when an <b>*un-stubbed*</b> method is called <b>*on the spy*</b> but <b>*not on the real instance*</b>,
  * you won't see any effects on the real instance.</li>
  *
  * <li>Watch out for final methods.
@@ -84,12 +89,13 @@
  * </ol>
  *
  * <p>
- * <strong>One last warning :</strong> if you call <code>MockitoAnnotations.initMocks(this)</code> in a
+ * <strong>One last warning :</strong> if you call <code>MockitoAnnotations.openMocks(this)</code> in a
  * super class <strong>constructor</strong> then this will not work. It is because fields
  * in subclass are only instantiated after super class constructor has returned.
  * It's better to use &#64;Before.
- * <strong>Instead</strong> you can also put initMocks() in your JUnit runner (&#064;RunWith) or use the built-in
- * {@link MockitoJUnitRunner}.
+ * <strong>Instead</strong> you can also put openMocks() in your JUnit runner (&#064;RunWith) or use the built-in
+ * {@link MockitoJUnitRunner}. Also, make sure to release any mocks after disposing your test class with a
+ * corresponding hook.
  * </p>
  *
  * <p>Note that the spy won't have any annotations of the spied type, because CGLIB won't rewrite them.
@@ -98,11 +104,11 @@
  * @see Mockito#spy(Object)
  * @see Mock
  * @see InjectMocks
- * @see MockitoAnnotations#initMocks(Object)
+ * @see MockitoAnnotations#openMocks(Object)
  * @see MockitoJUnitRunner
  * @since 1.8.3
  */
 @Retention(RUNTIME)
 @Target(FIELD)
 @Documented
-public @interface Spy { }
+public @interface Spy {}
diff --git a/mockito-core/src/main/java/org/mockito/ThrowingConsumer.java b/mockito-core/src/main/java/org/mockito/ThrowingConsumer.java
new file mode 100644
index 0000000000..cb496843a7
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/ThrowingConsumer.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import java.util.function.Consumer;
+
+@SuppressWarnings("FunctionalInterfaceMethodChanged")
+@FunctionalInterface
+public interface ThrowingConsumer<T> extends Consumer<T> {
+    @Override
+    default void accept(final T input) {
+        try {
+            acceptThrows(input);
+        } catch (final RuntimeException | AssertionError e) {
+            throw e;
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    void acceptThrows(T input) throws Throwable;
+}
diff --git a/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java b/mockito-core/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
similarity index 79%
rename from src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
rename to mockito-core/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
index cad13e7577..43882d49f1 100644
--- a/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
+++ b/mockito-core/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.configuration;
 
-import org.mockito.internal.configuration.InjectingAnnotationEngine;
 import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues;
 import org.mockito.stubbing.Answer;
 
@@ -17,20 +16,15 @@
  */
 public class DefaultMockitoConfiguration implements IMockitoConfiguration {
 
+    @Override
     public Answer<Object> getDefaultAnswer() {
         return new ReturnsEmptyValues();
     }
 
-    /* (non-Javadoc)
-     * @see org.mockito.IMockitoConfiguration#getAnnotationEngine()
-     */
-    public AnnotationEngine getAnnotationEngine() {
-        return new InjectingAnnotationEngine();
-    }
-
     /* (non-Javadoc)
      * @see org.mockito.configuration.IMockitoConfiguration#cleansStackTrace()
      */
+    @Override
     public boolean cleansStackTrace() {
         return true;
     }
@@ -38,9 +32,8 @@ public boolean cleansStackTrace() {
     /* (non-Javadoc)
      * @see org.mockito.configuration.IMockitoConfiguration#enableClassCache()
      */
+    @Override
     public boolean enableClassCache() {
         return true;
     }
-
-
 }
diff --git a/mockito-core/src/main/java/org/mockito/configuration/IMockitoConfiguration.java b/mockito-core/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
new file mode 100644
index 0000000000..6e16d350f1
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.configuration;
+
+import org.mockito.stubbing.Answer;
+
+/**
+ * Use it to configure Mockito. For now there are not many configuration options but it may change in future.
+ *
+ * <p>
+ * In most cases you don't really need to configure Mockito. For example in case of working with legacy code,
+ * when you might want to have different 'mocking style' this interface might be helpful.
+ * A reason of configuring Mockito might be if you disagree with the {@link org.mockito.Answers#RETURNS_DEFAULTS}
+ * un-stubbed mocks return.
+ *
+ * <p>
+ * To configure Mockito create exactly <b>org.mockito.configuration.MockitoConfiguration</b> class
+ * that implements this interface.
+ *
+ * <p>
+ * Configuring Mockito is completely <b>optional</b> - nothing happens if there isn't any
+ * <b>org.mockito.configuration.MockitoConfiguration</b> on the classpath.
+ *
+ * <p>
+ * <b>org.mockito.configuration.MockitoConfiguration</b> must implement <code>IMockitoConfiguration</code> or
+ * extend {@link DefaultMockitoConfiguration}
+ *
+ * <p>
+ * Mockito will store single instance of <code>org.mockito.configuration.MockitoConfiguration</code>
+ * per thread (using <code>ThreadLocal</code>).
+ * For sanity of your tests, don't make the implementation stateful.
+ *
+ * <p>
+ * If you have comments on Mockito configuration feature don't hesitate to write to mockito@googlegroups.com.
+ */
+public interface IMockitoConfiguration {
+
+    /**
+     * Allows configuring the default answers of un-stubbed invocations
+     * <p>
+     * See javadoc for {@link IMockitoConfiguration}
+     */
+    Answer<Object> getDefaultAnswer();
+
+    /**
+     * This should be turned on unless you're a Mockito developer and you wish
+     * to have verbose (read: messy) stack traces that only few understand (eg:
+     * Mockito developers)
+     * <p>
+     * See javadoc for {@link IMockitoConfiguration}
+     *
+     * @return if Mockito should clean stack traces
+     */
+    boolean cleansStackTrace();
+
+    /**
+     * Allow objenesis to cache classes. If you're in an environment where classes
+     * are dynamically reloaded, you can disable this to avoid classcast exceptions.
+     */
+    boolean enableClassCache();
+}
diff --git a/src/main/java/org/mockito/configuration/package-info.java b/mockito-core/src/main/java/org/mockito/configuration/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/configuration/package-info.java
rename to mockito-core/src/main/java/org/mockito/configuration/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/creation/instance/InstantiationException.java b/mockito-core/src/main/java/org/mockito/creation/instance/InstantiationException.java
new file mode 100644
index 0000000000..34548d5eb8
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/creation/instance/InstantiationException.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.creation.instance;
+
+import org.mockito.exceptions.base.MockitoException;
+
+/**
+ * Exception generated when {@link Instantiator#newInstance(Class)} failed.
+ *
+ * @since 2.15.4
+ */
+public class InstantiationException extends MockitoException {
+
+    /**
+     * @since 3.5.0
+     */
+    public InstantiationException(String message) {
+        super(message);
+    }
+
+    /**
+     * @since 2.15.4
+     */
+    public InstantiationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/creation/instance/Instantiator.java b/mockito-core/src/main/java/org/mockito/creation/instance/Instantiator.java
new file mode 100644
index 0000000000..a60ec7517d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/creation/instance/Instantiator.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.creation.instance;
+
+/**
+ * Provides instances of classes.
+ * See more information about Mockito plugin {@link org.mockito.plugins.InstantiatorProvider2}
+ *
+ * @since 2.15.4
+ */
+public interface Instantiator {
+
+    /**
+     * Creates instance of given class
+     *
+     * @since 2.15.4
+     */
+    <T> T newInstance(Class<T> cls);
+}
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java b/mockito-core/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
similarity index 82%
rename from src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
rename to mockito-core/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
index a3e046c479..5e463c7288 100644
--- a/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
+++ b/mockito-core/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
@@ -46,6 +46,18 @@ public MockitoAssertionError(MockitoAssertionError error, String message) {
         unfilteredStackTrace = error.getUnfilteredStackTrace();
     }
 
+    /**
+     * Creates a copy of the given assertion error with the custom failure message prepended.
+     * @param error The assertion error to copy
+     * @param message The custom message to prepend
+     * @since 3.3.13
+     */
+    public MockitoAssertionError(AssertionError error, String message) {
+        super(message + "\n" + error.getMessage());
+        unfilteredStackTrace = error.getStackTrace();
+        super.setStackTrace(unfilteredStackTrace);
+    }
+
     public StackTraceElement[] getUnfilteredStackTrace() {
         return unfilteredStackTrace;
     }
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoException.java b/mockito-core/src/main/java/org/mockito/exceptions/base/MockitoException.java
similarity index 99%
rename from src/main/java/org/mockito/exceptions/base/MockitoException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/base/MockitoException.java
index 24294e95a1..9293870771 100644
--- a/src/main/java/org/mockito/exceptions/base/MockitoException.java
+++ b/mockito-core/src/main/java/org/mockito/exceptions/base/MockitoException.java
@@ -6,7 +6,6 @@
 
 import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
 
-
 /**
  * Raised by mockito to emit an error either due to Mockito, or due to the User.
  * All exception classes that inherit from this class will have the stack trace filtered.
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java b/mockito-core/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java b/mockito-core/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java
rename to mockito-core/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java
diff --git a/src/main/java/org/mockito/exceptions/base/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/base/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/base/package-info.java
rename to mockito-core/src/main/java/org/mockito/exceptions/base/package-info.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/CannotStubVoidMethodWithReturnValue.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/CannotStubVoidMethodWithReturnValue.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/CannotStubVoidMethodWithReturnValue.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/CannotStubVoidMethodWithReturnValue.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/misusing/DisabledMockException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/DisabledMockException.java
new file mode 100644
index 0000000000..d51bdfdc1a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/misusing/DisabledMockException.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.misusing;
+
+import org.mockito.MockitoFramework;
+import org.mockito.exceptions.base.MockitoException;
+
+/**
+ * Thrown when a mock is accessed after it has been disabled by
+ * {@link MockitoFramework#clearInlineMocks()}.
+ */
+public class DisabledMockException extends MockitoException {
+    public DisabledMockException() {
+        super("Mock accessed after inline mocks were cleared");
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/misusing/DoNotMockException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/DoNotMockException.java
new file mode 100644
index 0000000000..4b4281b5f8
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/misusing/DoNotMockException.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.misusing;
+
+import org.mockito.exceptions.base.MockitoException;
+
+/**
+ * Thrown when attempting to mock a class that is annotated with {@link org.mockito.DoNotMock}.
+ */
+public class DoNotMockException extends MockitoException {
+    public DoNotMockException(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/InjectMocksException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/InjectMocksException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/InjectMocksException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/InjectMocksException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/MockitoConfigurationException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/MockitoConfigurationException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/MockitoConfigurationException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/MockitoConfigurationException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/NotAMockException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
similarity index 97%
rename from src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
index 5eb6a77ae8..f50c64256f 100644
--- a/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
+++ b/mockito-core/src/main/java/org/mockito/exceptions/misusing/PotentialStubbingProblem.java
@@ -26,7 +26,7 @@
  * given(mock.getSomething(100)).willReturn(something);
  *
  * //code under test:
- * Something something = mock.getSomething(50); // <-- stubbing argument mismatch
+ * Something something = mock.getSomething(50); // &lt;-- stubbing argument mismatch
  * </code></pre>
  * The stubbing argument mismatch typically indicates:
  * <ol>
diff --git a/src/main/java/org/mockito/exceptions/misusing/RedundantListenerException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/RedundantListenerException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/RedundantListenerException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/RedundantListenerException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnfinishedMockingSessionException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/UnfinishedMockingSessionException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/UnfinishedMockingSessionException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/UnfinishedMockingSessionException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
similarity index 85%
rename from src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
index 2d4605b4f6..1a5895fb35 100644
--- a/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
+++ b/mockito-core/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
@@ -30,15 +30,16 @@
  *
  * //test:
  * ...
- * when(translator.translate("one")).thenReturn("jeden"); // <- stubbing realized during code execution
- * when(translator.translate("two")).thenReturn("dwa"); // <- stubbing never realized
+ * when(translator.translate("one")).thenReturn("jeden"); // &lt;- stubbing realized during code execution
+ * when(translator.translate("two")).thenReturn("dwa"); // &lt;- stubbing never realized
  * ...
+ * </code>
  * </pre>
  * Notice that one of the stubbed methods were never realized in the code under test, during test execution.
  * The stray stubbing might be an oversight of the developer, the artifact of copy-paste
- * or the effect not understanding the test/code.
+ * or the effect of not understanding the test/code.
  * Either way, the developer ends up with unnecessary test code.
- * In order to keep the codebase clean & maintainable it is necessary to remove unnecessary code.
+ * In order to keep the codebase clean and maintainable it is necessary to remove unnecessary code.
  * Otherwise tests are harder to read and reason about.
  * <p>
  * Mockito JUnit Runner triggers <code>UnnecessaryStubbingException</code> only when none of the test methods use the stubbings.
diff --git a/src/main/java/org/mockito/exceptions/misusing/WrongTypeOfReturnValue.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/WrongTypeOfReturnValue.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/WrongTypeOfReturnValue.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/WrongTypeOfReturnValue.java
diff --git a/src/main/java/org/mockito/exceptions/misusing/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/misusing/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/misusing/package-info.java
rename to mockito-core/src/main/java/org/mockito/exceptions/misusing/package-info.java
diff --git a/src/main/java/org/mockito/exceptions/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/package-info.java
rename to mockito-core/src/main/java/org/mockito/exceptions/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java b/mockito-core/src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java
new file mode 100644
index 0000000000..467809aa01
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.stacktrace;
+
+/**
+ * Decides if particular StackTraceElement is excluded from the human-readable stack trace output.
+ * Mockito stack trace filtering mechanism uses this information.
+ * <p>
+ * Excluding an element will make it not show in the cleaned stack trace.
+ * Not-excluding an element does not guarantee it will be shown (e.g. it depends on the implementation of
+ * {@linkplain org.mockito.internal.exceptions.stacktrace.StackTraceFilter Mockito internal cleaner}).
+ * <p>
+ * The implementations are required to be thread safe ; for example, make them stateless.
+ * <p>
+ * See also the {@linkplain org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleaner Mockito default implementation}
+ */
+public interface StackTraceCleaner {
+
+    /**
+     * Decides if element is included.
+     *
+     * @param candidate element of the actual stack trace
+     * @return whether the element should be excluded from cleaned stack trace.
+     */
+    boolean isIn(StackTraceElement candidate);
+
+    /**
+     * It's recommended to override this method in subclasses to avoid potentially costly re-boxing operations.
+     */
+    default boolean isIn(StackFrameMetadata candidate) {
+        return isIn(
+                new StackTraceElement(
+                        candidate.getClassName(),
+                        candidate.getMethodName(),
+                        candidate.getFileName(),
+                        candidate.getLineNumber()));
+    }
+
+    /**
+     * Very similar to the StackFrame class declared on the StackWalker api.
+     */
+    interface StackFrameMetadata {
+        String getClassName();
+
+        String getMethodName();
+
+        String getFileName();
+
+        int getLineNumber();
+    }
+}
diff --git a/src/main/java/org/mockito/exceptions/stacktrace/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/stacktrace/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/stacktrace/package-info.java
rename to mockito-core/src/main/java/org/mockito/exceptions/stacktrace/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
new file mode 100644
index 0000000000..ac572f40a5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.verification;
+
+import static org.mockito.internal.util.StringUtil.removeFirstLine;
+
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+public class ArgumentsAreDifferent extends MockitoAssertionError {
+
+    private static final long serialVersionUID = 1L;
+
+    public ArgumentsAreDifferent(String message) {
+        super(message);
+    }
+
+    /**
+     * Three-arg constructor for compatibility with ExceptionFactory's three-arg
+     * create method. This implementation simply ignores the second and third
+     * arguments.
+     *
+     * @param message
+     * @param wanted ignored
+     * @param actual ignored
+     */
+    public ArgumentsAreDifferent(String message, String wanted, String actual) {
+        this(message);
+    }
+
+    @Override
+    public String getMessage() {
+        return removeFirstLine(super.getMessage());
+    }
+}
diff --git a/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
diff --git a/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java
diff --git a/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java
diff --git a/src/main/java/org/mockito/exceptions/verification/SmartNullPointerException.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/SmartNullPointerException.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/SmartNullPointerException.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/SmartNullPointerException.java
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java
new file mode 100644
index 0000000000..bf7c01851d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2019 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;
+
+/**
+ * @since 2.27.5
+ */
+public class TooFewActualInvocations extends MockitoAssertionError {
+
+    private static final long serialVersionUID = 1L;
+
+    public TooFewActualInvocations(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java
diff --git a/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java
diff --git a/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
new file mode 100644
index 0000000000..94da89d4c5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.verification.junit;
+
+import static org.mockito.internal.util.StringUtil.removeFirstLine;
+
+import junit.framework.ComparisonFailure;
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+
+public class ArgumentsAreDifferent extends ComparisonFailure {
+
+    private static final long serialVersionUID = 1L;
+    private final String message;
+    private final StackTraceElement[] unfilteredStackTrace;
+
+    public ArgumentsAreDifferent(String message, String wanted, String actual) {
+        super(message, wanted, actual);
+        this.message = message;
+
+        unfilteredStackTrace = getStackTrace();
+        ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
+        filter.filter(this);
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    public StackTraceElement[] getUnfilteredStackTrace() {
+        return unfilteredStackTrace;
+    }
+
+    @Override
+    public String toString() {
+        return removeFirstLine(super.toString());
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/verification/junit/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
new file mode 100644
index 0000000000..23d184846f
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * JUnit integration to provide better support for JUnit 4 and
+ * earlier in IDEs.
+ *
+ * See also org.mockito.exceptions.verification.opentest4j
+ */
+package org.mockito.exceptions.verification.junit;
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
new file mode 100644
index 0000000000..281052026a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.verification.opentest4j;
+
+import static org.mockito.internal.util.StringUtil.removeFirstLine;
+
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.opentest4j.AssertionFailedError;
+
+public class ArgumentsAreDifferent extends AssertionFailedError {
+
+    private static final long serialVersionUID = 1L;
+    private final String message;
+    private final StackTraceElement[] unfilteredStackTrace;
+
+    public ArgumentsAreDifferent(String message, String wanted, String actual) {
+        super(message, wanted, actual);
+        this.message = message;
+
+        unfilteredStackTrace = getStackTrace();
+        ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
+        filter.filter(this);
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    public StackTraceElement[] getUnfilteredStackTrace() {
+        return unfilteredStackTrace;
+    }
+
+    @Override
+    public String toString() {
+        return removeFirstLine(super.toString());
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java
new file mode 100644
index 0000000000..311253f4f9
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * Integration to provide better support for IDEs that support OpenTest4J.
+ *
+ * See also org.mockito.exceptions.verification.junit
+ */
+package org.mockito.exceptions.verification.opentest4j;
diff --git a/src/main/java/org/mockito/exceptions/verification/package-info.java b/mockito-core/src/main/java/org/mockito/exceptions/verification/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/exceptions/verification/package-info.java
rename to mockito-core/src/main/java/org/mockito/exceptions/verification/package-info.java
diff --git a/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java b/mockito-core/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
similarity index 78%
rename from src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
rename to mockito-core/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
index d4b4304033..3624ba20c4 100644
--- a/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
+++ b/mockito-core/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
@@ -42,10 +42,28 @@
  * Due to how java works we don't really have a clean way of detecting this scenario and protecting the user from this problem.
  * Hopefully, the javadoc describes the problem and solution well.
  * If you have an idea how to fix the problem, let us know via the mailing list or the issue tracker.
+ * <p/>
+ * By default, a matcher passed to a varargs parameter will match against the first element in the varargs array.
+ * To match against the raw varargs array pass the type of the varargs parameter to {@link MockitoHamcrest#argThat(Matcher, Class)}
+ * <p/>
+ * For example, to match any number of {@code String} values:
+ * <pre>
+ *     import static org.hamcrest.CoreMatchers.isA;
+ *     import static org.mockito.hamcrest.MockitoHamcrest.argThat;
+ *
+ *     // Given:
+ *     void varargMethod(String... args);
+ *
+ *     //stubbing
+ *     when(mock.varargMethod(argThat(isA(String[].class), String[].class));
+ *
+ *     //verification
+ *     verify(mock).giveMe(argThat(isA(String[].class), String[].class));
+ * </pre>
  *
  * @since 2.1.0
  */
-public class MockitoHamcrest {
+public final class MockitoHamcrest {
 
     /**
      * Allows matching arguments with hamcrest matchers.
@@ -59,7 +77,27 @@ public class MockitoHamcrest {
     @SuppressWarnings("unchecked")
     public static <T> T argThat(Matcher<T> matcher) {
         reportMatcher(matcher);
-        return  (T) defaultValue(genericTypeOfMatcher(matcher.getClass()));
+        return (T) defaultValue(genericTypeOfMatcher(matcher.getClass()));
+    }
+
+    /**
+     * Allows matching arguments with hamcrest matchers.
+     * <p/>
+     * This variant can be used to pass an explicit {@code type},
+     * which can be useful to provide a matcher that matches against all
+     * elements in a varargs parameter.
+     * <p/>
+     * See examples in javadoc for {@link MockitoHamcrest} class
+     *
+     * @param matcher decides whether argument matches
+     * @param type the type the matcher matches.
+     * @return <code>null</code> or default value for primitive (0, false, etc.)
+     * @since 5.0.0
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T argThat(Matcher<T> matcher, Class<T> type) {
+        reportMatcher(matcher, type);
+        return (T) defaultValue(genericTypeOfMatcher(matcher.getClass()));
     }
 
     /**
@@ -175,6 +213,16 @@ public static double doubleThat(Matcher<Double> matcher) {
     }
 
     private static <T> void reportMatcher(Matcher<T> matcher) {
-        mockingProgress().getArgumentMatcherStorage().reportMatcher(new HamcrestArgumentMatcher<T>(matcher));
+        reportMatcher(new HamcrestArgumentMatcher<T>(matcher));
+    }
+
+    private static <T> void reportMatcher(Matcher<T> matcher, Class<T> type) {
+        reportMatcher(new HamcrestArgumentMatcher<T>(matcher, type));
     }
+
+    private static <T> void reportMatcher(final HamcrestArgumentMatcher<T> matcher) {
+        mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher);
+    }
+
+    private MockitoHamcrest() {}
 }
diff --git a/src/main/java/org/mockito/hamcrest/package-info.java b/mockito-core/src/main/java/org/mockito/hamcrest/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/hamcrest/package-info.java
rename to mockito-core/src/main/java/org/mockito/hamcrest/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/InOrderImpl.java b/mockito-core/src/main/java/org/mockito/internal/InOrderImpl.java
new file mode 100644
index 0000000000..93f5991af0
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/InOrderImpl.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import static org.mockito.internal.exceptions.Reporter.inOrderRequiresFamiliarMock;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.InOrder;
+import org.mockito.MockedStatic;
+import org.mockito.MockingDetails;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.verification.InOrderContextImpl;
+import org.mockito.internal.verification.InOrderWrapper;
+import org.mockito.internal.verification.VerificationModeFactory;
+import org.mockito.internal.verification.VerificationWrapper;
+import org.mockito.internal.verification.VerificationWrapperInOrderWrapper;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.internal.verification.api.VerificationInOrderMode;
+import org.mockito.invocation.Invocation;
+import org.mockito.verification.VerificationMode;
+
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.internal.exceptions.Reporter.*;
+
+/**
+ * Allows verifying in order. This class should not be exposed, hence default access.
+ */
+public class InOrderImpl implements InOrder, InOrderContext {
+
+    private final MockitoCore mockitoCore = new MockitoCore();
+    private final List<Object> mocksToBeVerifiedInOrder = new ArrayList<>();
+    private final InOrderContext inOrderContext = new InOrderContextImpl();
+
+    public List<Object> getMocksToBeVerifiedInOrder() {
+        return mocksToBeVerifiedInOrder;
+    }
+
+    public InOrderImpl(List<?> mocksToBeVerifiedInOrder) {
+        this.mocksToBeVerifiedInOrder.addAll(mocksToBeVerifiedInOrder);
+    }
+
+    @Override
+    public <T> T verify(T mock) {
+        return this.verify(mock, VerificationModeFactory.times(1));
+    }
+
+    @Override
+    public <T> T verify(T mock, VerificationMode mode) {
+        if (mock == null) {
+            throw nullPassedToVerify();
+        }
+        MockingDetails mockingDetails = mockingDetails(mock);
+        if (!mockingDetails.isMock()) {
+            throw notAMockPassedToVerify(mock.getClass());
+        }
+        if (!this.objectIsMockToBeVerified(mock)) {
+            throw inOrderRequiresFamiliarMock();
+        }
+        if (mode instanceof VerificationWrapper) {
+            return mockitoCore.verify(
+                    mock,
+                    new VerificationWrapperInOrderWrapper((VerificationWrapper<?>) mode, this));
+        } else if (!(mode instanceof VerificationInOrderMode)) {
+            throw new MockitoException(
+                    mode.getClass().getSimpleName() + " is not implemented to work with InOrder");
+        }
+        return mockitoCore.verify(mock, new InOrderWrapper((VerificationInOrderMode) mode, this));
+    }
+
+    @Override
+    public void verify(
+            MockedStatic<?> mockedStatic,
+            MockedStatic.Verification verification,
+            VerificationMode mode) {
+        if (mode instanceof VerificationWrapper) {
+            mockedStatic.verify(
+                    verification,
+                    new VerificationWrapperInOrderWrapper((VerificationWrapper<?>) mode, this));
+        } else if (mode instanceof VerificationInOrderMode) {
+            mockedStatic.verify(
+                    verification, new InOrderWrapper((VerificationInOrderMode) mode, this));
+        } else {
+            throw new MockitoException(
+                    mode.getClass().getSimpleName() + " is not implemented to work with InOrder");
+        }
+    }
+
+    // We can't use `this.mocksToBeVerifiedInOrder.contains`, since that in turn calls `.equals` on
+    // the mock. Since mocks can be spies and spies get their real equals method calls called, the
+    // result is that Mockito incorrectly would register an invocation on a mock. This normally
+    // wouldn't be a problem, unless the user explicitly verifies that no interactions are performed
+    // on the mock, which would start to fail for the equals invocation.
+    private boolean objectIsMockToBeVerified(Object mock) {
+        for (Object inOrderMock : this.mocksToBeVerifiedInOrder) {
+            if (inOrderMock == mock) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isVerified(Invocation i) {
+        return inOrderContext.isVerified(i);
+    }
+
+    @Override
+    public void markVerified(Invocation i) {
+        inOrderContext.markVerified(i);
+    }
+
+    @Override
+    public void verifyNoMoreInteractions() {
+        mockitoCore.verifyNoMoreInteractionsInOrder(mocksToBeVerifiedInOrder, this);
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/MockedConstructionImpl.java b/mockito-core/src/main/java/org/mockito/internal/MockedConstructionImpl.java
new file mode 100644
index 0000000000..5541ba07cd
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/MockedConstructionImpl.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.mockito.MockedConstruction;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.invocation.Location;
+import org.mockito.plugins.MockMaker;
+
+public final class MockedConstructionImpl<T> implements MockedConstruction<T> {
+
+    private final MockMaker.ConstructionMockControl<T> control;
+
+    private boolean closed;
+
+    private final Location location = LocationFactory.create();
+
+    protected MockedConstructionImpl(MockMaker.ConstructionMockControl<T> control) {
+        this.control = control;
+    }
+
+    @Override
+    public List<T> constructed() {
+        return Collections.unmodifiableList(control.getMocks());
+    }
+
+    @Override
+    public boolean isClosed() {
+        return closed;
+    }
+
+    @Override
+    public void close() {
+        assertNotClosed();
+
+        closed = true;
+        control.disable();
+    }
+
+    @Override
+    public void closeOnDemand() {
+        if (!closed) {
+            close();
+        }
+    }
+
+    private void assertNotClosed() {
+        if (closed) {
+            throw new MockitoException(
+                    join(
+                            "The static mock created at",
+                            location.toString(),
+                            "is already resolved and cannot longer be used"));
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/MockedStaticImpl.java b/mockito-core/src/main/java/org/mockito/internal/MockedStaticImpl.java
new file mode 100644
index 0000000000..f6705fb81a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/MockedStaticImpl.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import static org.mockito.internal.exceptions.Reporter.missingMethodInvocation;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import static org.mockito.internal.util.MockUtil.getInvocationContainer;
+import static org.mockito.internal.util.MockUtil.resetMock;
+import static org.mockito.internal.util.StringUtil.join;
+import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
+import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
+
+import org.mockito.MockedStatic;
+import org.mockito.MockingDetails;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.listeners.VerificationStartedNotifier;
+import org.mockito.internal.progress.MockingProgress;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockito.internal.verification.MockAwareVerificationMode;
+import org.mockito.internal.verification.VerificationDataImpl;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MockHandler;
+import org.mockito.plugins.MockMaker;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.verification.VerificationMode;
+
+public final class MockedStaticImpl<T> implements MockedStatic<T> {
+
+    private final MockMaker.StaticMockControl<T> control;
+
+    private boolean closed;
+
+    private final Location location = LocationFactory.create();
+
+    protected MockedStaticImpl(MockMaker.StaticMockControl<T> control) {
+        this.control = control;
+    }
+
+    @Override
+    public <S> OngoingStubbing<S> when(Verification verification) {
+        assertNotClosed();
+
+        try {
+            verification.apply();
+        } catch (MockitoException exception) {
+            throw exception;
+        } catch (Throwable ignored) {
+        }
+
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.stubbingStarted();
+        @SuppressWarnings("unchecked")
+        OngoingStubbing<S> stubbing = (OngoingStubbing<S>) mockingProgress.pullOngoingStubbing();
+        if (stubbing == null) {
+            mockingProgress.reset();
+            throw missingMethodInvocation();
+        }
+        return stubbing;
+    }
+
+    @Override
+    public void verify(Verification verification, VerificationMode mode) {
+        assertNotClosed();
+
+        MockingDetails mockingDetails = Mockito.mockingDetails(control.getType());
+        MockHandler handler = mockingDetails.getMockHandler();
+
+        VerificationStartedNotifier.notifyVerificationStarted(
+                handler.getMockSettings().getVerificationStartedListeners(), mockingDetails);
+
+        MockingProgress mockingProgress = mockingProgress();
+        VerificationMode actualMode = mockingProgress.maybeVerifyLazily(mode);
+        mockingProgress.verificationStarted(
+                new MockAwareVerificationMode(
+                        control.getType(), actualMode, mockingProgress.verificationListeners()));
+
+        try {
+            verification.apply();
+        } catch (MockitoException | MockitoAssertionError e) {
+            throw e;
+        } catch (Throwable t) {
+            throw new MockitoException(
+                    join(
+                            "An unexpected error occurred while verifying a static stub",
+                            "",
+                            "To correctly verify a stub, invoke a single static method of "
+                                    + control.getType().getName()
+                                    + " in the provided lambda.",
+                            "For example, if a method 'sample' was defined, provide a lambda or anonymous class containing the code",
+                            "",
+                            "() -> " + control.getType().getSimpleName() + ".sample()",
+                            "or",
+                            control.getType().getSimpleName() + "::sample"),
+                    t);
+        }
+    }
+
+    @Override
+    public void reset() {
+        assertNotClosed();
+
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.validateState();
+        mockingProgress.reset();
+        mockingProgress.resetOngoingStubbing();
+
+        resetMock(control.getType());
+    }
+
+    @Override
+    public void clearInvocations() {
+        assertNotClosed();
+
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.validateState();
+        mockingProgress.reset();
+        mockingProgress.resetOngoingStubbing();
+
+        getInvocationContainer(control.getType()).clearInvocations();
+    }
+
+    @Override
+    public void verifyNoMoreInteractions() {
+        assertNotClosed();
+
+        mockingProgress().validateState();
+        InvocationContainerImpl invocations = getInvocationContainer(control.getType());
+        VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+        noMoreInteractions().verify(data);
+    }
+
+    @Override
+    public void verifyNoInteractions() {
+        assertNotClosed();
+
+        mockingProgress().validateState();
+        InvocationContainerImpl invocations = getInvocationContainer(control.getType());
+        VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+        noInteractions().verify(data);
+    }
+
+    @Override
+    public boolean isClosed() {
+        return closed;
+    }
+
+    @Override
+    public void close() {
+        assertNotClosed();
+
+        closed = true;
+        control.disable();
+    }
+
+    @Override
+    public void closeOnDemand() {
+        if (!closed) {
+            close();
+        }
+    }
+
+    private void assertNotClosed() {
+        if (closed) {
+            throw new MockitoException(
+                    join(
+                            "The static mock created at",
+                            location.toString(),
+                            "is already resolved and cannot longer be used"));
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "static mock for " + control.getType().getName();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/MockitoCore.java b/mockito-core/src/main/java/org/mockito/internal/MockitoCore.java
new file mode 100644
index 0000000000..94dbdec711
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/MockitoCore.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import static org.mockito.internal.exceptions.Reporter.missingMethodInvocation;
+import static org.mockito.internal.exceptions.Reporter.mocksHaveToBePassedToVerifyNoMoreInteractions;
+import static org.mockito.internal.exceptions.Reporter.mocksHaveToBePassedWhenCreatingInOrder;
+import static org.mockito.internal.exceptions.Reporter.notAMockPassedToVerify;
+import static org.mockito.internal.exceptions.Reporter.notAMockPassedToVerifyNoMoreInteractions;
+import static org.mockito.internal.exceptions.Reporter.notAMockPassedWhenCreatingInOrder;
+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.createConstructionMock;
+import static org.mockito.internal.util.MockUtil.createMock;
+import static org.mockito.internal.util.MockUtil.createStaticMock;
+import static org.mockito.internal.util.MockUtil.getInvocationContainer;
+import static org.mockito.internal.util.MockUtil.getMockHandler;
+import static org.mockito.internal.util.MockUtil.isMock;
+import static org.mockito.internal.util.MockUtil.resetMock;
+import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
+import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+import org.mockito.InOrder;
+import org.mockito.MockSettings;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+import org.mockito.MockingDetails;
+import org.mockito.exceptions.misusing.DoNotMockException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.MockSettingsImpl;
+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;
+import org.mockito.internal.util.DefaultMockingDetails;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.verification.MockAwareVerificationMode;
+import org.mockito.internal.verification.VerificationDataImpl;
+import org.mockito.internal.verification.VerificationModeFactory;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.internal.verification.api.VerificationDataInOrder;
+import org.mockito.internal.verification.api.VerificationDataInOrderImpl;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
+import org.mockito.plugins.MockMaker;
+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;
+
+@SuppressWarnings("unchecked")
+public class MockitoCore {
+
+    private static final DoNotMockEnforcerWithType DO_NOT_MOCK_ENFORCER =
+            Plugins.getDoNotMockEnforcer();
+
+    public <T> T mock(Class<T> typeToMock, MockSettings settings) {
+        if (!(settings instanceof MockSettingsImpl)) {
+            throw new IllegalArgumentException(
+                    "Unexpected implementation of '"
+                            + settings.getClass().getCanonicalName()
+                            + "'\n"
+                            + "At the moment, you cannot provide your own implementations of that class.");
+        }
+        MockSettingsImpl impl = (MockSettingsImpl) settings;
+        MockCreationSettings<T> creationSettings = impl.build(typeToMock);
+        checkDoNotMockAnnotation(creationSettings);
+        T mock = createMock(creationSettings);
+        mockingProgress().mockingStarted(mock, creationSettings);
+        return mock;
+    }
+
+    public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings settings) {
+        if (!MockSettingsImpl.class.isInstance(settings)) {
+            throw new IllegalArgumentException(
+                    "Unexpected implementation of '"
+                            + settings.getClass().getCanonicalName()
+                            + "'\n"
+                            + "At the moment, you cannot provide your own implementations of that class.");
+        }
+        MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
+        MockCreationSettings<T> creationSettings = impl.buildStatic(classToMock);
+        checkDoNotMockAnnotation(creationSettings);
+        MockMaker.StaticMockControl<T> control = createStaticMock(classToMock, creationSettings);
+        control.enable();
+        mockingProgress().mockingStarted(classToMock, creationSettings);
+        return new MockedStaticImpl<>(control);
+    }
+
+    private void checkDoNotMockAnnotation(MockCreationSettings<?> creationSettings) {
+        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(creationSettings);
+        if (warning != null) {
+            throw new DoNotMockException(warning);
+        }
+    }
+
+    public <T> MockedConstruction<T> mockConstruction(
+            Class<T> typeToMock,
+            Function<MockedConstruction.Context, ? extends MockSettings> settingsFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        Function<MockedConstruction.Context, MockCreationSettings<T>> creationSettings =
+                context -> {
+                    MockSettings value = settingsFactory.apply(context);
+                    if (!MockSettingsImpl.class.isInstance(value)) {
+                        throw new IllegalArgumentException(
+                                "Unexpected implementation of '"
+                                        + value.getClass().getCanonicalName()
+                                        + "'\n"
+                                        + "At the moment, you cannot provide your own implementations of that class.");
+                    }
+                    MockSettingsImpl impl = MockSettingsImpl.class.cast(value);
+                    String mockMaker = impl.getMockMaker();
+                    if (mockMaker != null) {
+                        throw new IllegalArgumentException(
+                                "Unexpected MockMaker '"
+                                        + mockMaker
+                                        + "'\n"
+                                        + "At the moment, you cannot override the MockMaker for construction mocks.");
+                    }
+                    return impl.build(typeToMock);
+                };
+        MockMaker.ConstructionMockControl<T> control =
+                createConstructionMock(typeToMock, creationSettings, mockInitializer);
+        control.enable();
+        return new MockedConstructionImpl<>(control);
+    }
+
+    public <T> OngoingStubbing<T> when(T methodCall) {
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.stubbingStarted();
+        @SuppressWarnings("unchecked")
+        OngoingStubbing<T> stubbing = (OngoingStubbing<T>) mockingProgress.pullOngoingStubbing();
+        if (stubbing == null) {
+            mockingProgress.reset();
+            throw missingMethodInvocation();
+        }
+        return stubbing;
+    }
+
+    public <T> T verify(T mock, VerificationMode mode) {
+        if (mock == null) {
+            throw nullPassedToVerify();
+        }
+        MockingDetails mockingDetails = mockingDetails(mock);
+        if (!mockingDetails.isMock()) {
+            throw notAMockPassedToVerify(mock.getClass());
+        }
+        assertNotStubOnlyMock(mock);
+        MockHandler handler = mockingDetails.getMockHandler();
+        mock =
+                (T)
+                        VerificationStartedNotifier.notifyVerificationStarted(
+                                handler.getMockSettings().getVerificationStartedListeners(),
+                                mockingDetails);
+
+        MockingProgress mockingProgress = mockingProgress();
+        VerificationMode actualMode = mockingProgress.maybeVerifyLazily(mode);
+        mockingProgress.verificationStarted(
+                new MockAwareVerificationMode(
+                        mock, actualMode, mockingProgress.verificationListeners()));
+        return mock;
+    }
+
+    public <T> void reset(T... mocks) {
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.validateState();
+        mockingProgress.reset();
+        mockingProgress.resetOngoingStubbing();
+
+        for (T m : mocks) {
+            resetMock(m);
+        }
+    }
+
+    public <T> void clearInvocations(T... mocks) {
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.validateState();
+        mockingProgress.reset();
+        mockingProgress.resetOngoingStubbing();
+
+        for (T m : mocks) {
+            getInvocationContainer(m).clearInvocations();
+        }
+    }
+
+    public void verifyNoMoreInteractions(Object... mocks) {
+        assertMocksNotEmpty(mocks);
+        mockingProgress().validateState();
+        for (Object mock : mocks) {
+            try {
+                if (mock == null) {
+                    throw nullPassedToVerifyNoMoreInteractions();
+                }
+                InvocationContainerImpl invocations = getInvocationContainer(mock);
+                assertNotStubOnlyMock(mock);
+                VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+                noMoreInteractions().verify(data);
+            } catch (NotAMockException e) {
+                throw notAMockPassedToVerifyNoMoreInteractions();
+            }
+        }
+    }
+
+    public void verifyNoInteractions(Object... mocks) {
+        assertMocksNotEmpty(mocks);
+        mockingProgress().validateState();
+        for (Object mock : mocks) {
+            try {
+                if (mock == null) {
+                    throw nullPassedToVerifyNoMoreInteractions();
+                }
+                InvocationContainerImpl invocations = getInvocationContainer(mock);
+                assertNotStubOnlyMock(mock);
+                VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+                noInteractions().verify(data);
+            } catch (NotAMockException e) {
+                throw notAMockPassedToVerifyNoMoreInteractions();
+            }
+        }
+    }
+
+    public void verifyNoMoreInteractionsInOrder(List<Object> mocks, InOrderContext inOrderContext) {
+        mockingProgress().validateState();
+        VerificationDataInOrder data =
+                new VerificationDataInOrderImpl(
+                        inOrderContext, VerifiableInvocationsFinder.find(mocks), null);
+        VerificationModeFactory.noMoreInteractions().verifyInOrder(data);
+    }
+
+    private void assertMocksNotEmpty(Object[] mocks) {
+        if (mocks == null || mocks.length == 0) {
+            throw mocksHaveToBePassedToVerifyNoMoreInteractions();
+        }
+    }
+
+    private void assertNotStubOnlyMock(Object mock) {
+        if (getMockHandler(mock).getMockSettings().isStubOnly()) {
+            throw stubPassedToVerify(mock);
+        }
+    }
+
+    public InOrder inOrder(Object... mocks) {
+        if (mocks == null || mocks.length == 0) {
+            throw mocksHaveToBePassedWhenCreatingInOrder();
+        }
+        for (Object mock : mocks) {
+            if (mock == null) {
+                throw nullPassedWhenCreatingInOrder();
+            }
+            if (!isMock(mock)) {
+                throw notAMockPassedWhenCreatingInOrder();
+            }
+            assertNotStubOnlyMock(mock);
+        }
+        return new InOrderImpl(Arrays.asList(mocks));
+    }
+
+    public Stubber stubber() {
+        return stubber(null);
+    }
+
+    public Stubber stubber(Strictness strictness) {
+        MockingProgress mockingProgress = mockingProgress();
+        mockingProgress.stubbingStarted();
+        mockingProgress.resetOngoingStubbing();
+        return new StubberImpl(strictness);
+    }
+
+    public void validateMockitoUsage() {
+        mockingProgress().validateState();
+    }
+
+    /**
+     * For testing purposes only. Is not the part of main API.
+     *
+     * @return last invocation
+     */
+    public Invocation getLastInvocation() {
+        OngoingStubbingImpl ongoingStubbing =
+                ((OngoingStubbingImpl) mockingProgress().pullOngoingStubbing());
+        List<Invocation> allInvocations = ongoingStubbing.getRegisteredInvocations();
+        return allInvocations.get(allInvocations.size() - 1);
+    }
+
+    public Object[] ignoreStubs(Object... mocks) {
+        for (Object m : mocks) {
+            InvocationContainerImpl container = getInvocationContainer(m);
+            List<Invocation> ins = container.getInvocations();
+            for (Invocation in : ins) {
+                if (in.stubInfo() != null) {
+                    in.ignoreForVerification();
+                }
+            }
+        }
+        return mocks;
+    }
+
+    public MockingDetails mockingDetails(Object toInspect) {
+        return new DefaultMockingDetails(toInspect);
+    }
+
+    public LenientStubber lenient() {
+        return new DefaultLenientStubber();
+    }
+
+    public void clearAllCaches() {
+        MockUtil.clearAllCaches();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/PremainAttach.java b/mockito-core/src/main/java/org/mockito/internal/PremainAttach.java
new file mode 100644
index 0000000000..9fc29a534b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/PremainAttach.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import java.lang.instrument.Instrumentation;
+
+/**
+ * Allows users to specify Mockito as a Java agent where the {@link Instrumentation}
+ * instance is stored for use by the inline mock maker.
+ *
+ * The <a href="https://openjdk.org/jeps/451">JEP 451</a>, delivered with JDK 21,
+ * is the first milestone to disallow dynamic loading of by default which will happen
+ * in a future version of the JDK.
+ */
+public class PremainAttach {
+
+    private static volatile Instrumentation instrumentation;
+
+    public static void premain(String arg, Instrumentation instrumentation) {
+        if (PremainAttach.instrumentation != null) {
+            return;
+        }
+        PremainAttach.instrumentation = instrumentation;
+    }
+
+    public static Instrumentation getInstrumentation() {
+        return instrumentation;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java b/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java
new file mode 100644
index 0000000000..b63614d451
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.agent.ByteBuddyAgent;
+import net.bytebuddy.agent.Installer;
+
+import java.lang.instrument.Instrumentation;
+import java.util.List;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+public class PremainAttachAccess {
+
+    private static volatile Instrumentation inst;
+
+    public static Instrumentation getInstrumentation() {
+        if (inst != null) {
+            return inst;
+        }
+        // A Java agent is always added to the system class loader. If Mockito is executed from a
+        // different class loader we need to make sure to resolve the instrumentation instance
+        // from there, or fail the resolution, if this class does not exist on the system class
+        // loader.
+        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
+        Instrumentation instrumentation =
+                doGetInstrumentation(PremainAttach.class, "getInstrumentation", systemClassLoader);
+        if (instrumentation == null) {
+            try {
+                // At this point, we do not want to attempt dynamic attach but check the Byte Buddy
+                // agent as a fallback if the Mockito agent is not attached.
+                instrumentation =
+                        doGetInstrumentation(
+                                Installer.class, "getInstrumentation", systemClassLoader);
+            } catch (IllegalStateException ignored) {
+            }
+        }
+        if (instrumentation == null) {
+            if (ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V21)) {
+                boolean dynamicAgentLoading;
+                try {
+                    Object runtimeMXBean =
+                            Class.forName("java.lang.management.ManagementFactory")
+                                    .getMethod("getRuntimeMXBean")
+                                    .invoke(null);
+
+                    @SuppressWarnings("unchecked")
+                    List<String> arguments =
+                            (List<String>)
+                                    Class.forName("java.lang.management.RuntimeMXBean")
+                                            .getMethod("getInputArguments")
+                                            .invoke(runtimeMXBean);
+                    dynamicAgentLoading =
+                            arguments.stream()
+                                    .anyMatch(
+                                            argument ->
+                                                    argument.contains(
+                                                            "-XX:+EnableDynamicAgentLoading"));
+                } catch (Exception ignored) {
+                    dynamicAgentLoading = false;
+                }
+                if (!dynamicAgentLoading) {
+                    // Cannot use `Plugins.getMockitoLogger().warn(...)` at this time due to a
+                    // circular dependency on `Plugins.registry`.
+                    // The `PluginRegistry` is not yet fully initialized (in `Plugins`), because it
+                    // is currently initializing the `MockMaker` which is a
+                    // InlineByteBuddyMockMaker, and it is later calling this
+                    // method to access the instrumentation.
+                    System.err.println(
+                            "Mockito is currently self-attaching to enable the inline-mock-maker. This "
+                                    + "will no longer work in future releases of the JDK. Please add Mockito as an agent to your "
+                                    + "build as described in Mockito's documentation: "
+                                    + "https://javadoc.io/doc/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html#0.3");
+                }
+            }
+            // Attempt to dynamically attach, as a last resort.
+            instrumentation = ByteBuddyAgent.install();
+        }
+        if (!instrumentation.isRetransformClassesSupported()) {
+            throw new IllegalStateException(
+                    join(
+                            "Mockito requires retransformation for creating inline mocks. This feature is unavailable on the current VM.",
+                            "",
+                            "You cannot use this mock maker on this VM"));
+        }
+        inst = instrumentation;
+        return instrumentation;
+    }
+
+    private static Instrumentation doGetInstrumentation(
+            Class<?> type, String method, ClassLoader systemClassLoader) {
+        try {
+            return (Instrumentation)
+                    Class.forName(type.getName(), true, systemClassLoader)
+                            .getMethod(method)
+                            .invoke(null);
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/SuppressSignatureCheck.java b/mockito-core/src/main/java/org/mockito/internal/SuppressSignatureCheck.java
new file mode 100644
index 0000000000..2a47d005e7
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/SuppressSignatureCheck.java
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+@Documented
+public @interface SuppressSignatureCheck {}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java b/mockito-core/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
new file mode 100644
index 0000000000..90710b48d9
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Parameter;
+
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.reflection.GenericMaster;
+
+/**
+ * Instantiate {@link ArgumentCaptor} a field annotated by &#64;Captor.
+ */
+public class CaptorAnnotationProcessor implements FieldAnnotationProcessor<Captor> {
+    @Override
+    public Object process(Captor annotation, Field field) {
+        Class<?> type = field.getType();
+        if (!ArgumentCaptor.class.isAssignableFrom(type)) {
+            throw new MockitoException(
+                    "@Captor field must be of the type ArgumentCaptor.\n"
+                            + "Field: '"
+                            + field.getName()
+                            + "' has wrong type\n"
+                            + "For info how to use @Captor annotations see examples in javadoc for MockitoAnnotations class.");
+        }
+        Class<?> cls = new GenericMaster().getGenericType(field);
+        return ArgumentCaptor.forClass(cls);
+    }
+
+    public static Object process(Parameter parameter) {
+        Class<?> type = parameter.getType();
+        if (!ArgumentCaptor.class.isAssignableFrom(type)) {
+            throw new MockitoException(
+                    "@Captor field must be of the type ArgumentCaptor.\n"
+                            + "Field: '"
+                            + parameter.getName()
+                            + "' has wrong type\n"
+                            + "For info how to use @Captor annotations see examples in javadoc for MockitoAnnotations class.");
+        }
+        Class<?> cls = new GenericMaster().getGenericType(parameter);
+        return ArgumentCaptor.forClass(cls);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java b/mockito-core/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
similarity index 76%
rename from src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
index 67b20405cb..0f031ee58a 100644
--- a/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
@@ -8,7 +8,6 @@
 import org.mockito.exceptions.misusing.MockitoConfigurationException;
 import org.mockito.plugins.MockMaker;
 
-
 /**
  * Loads configuration or extension points available in the classpath.
  *
@@ -47,7 +46,8 @@
  */
 public class ClassPathLoader {
 
-    public static final String MOCKITO_CONFIGURATION_CLASS_NAME = "org.mockito.configuration.MockitoConfiguration";
+    public static final String MOCKITO_CONFIGURATION_CLASS_NAME =
+            "org.mockito.configuration.MockitoConfiguration";
 
     /**
      * @return configuration loaded from classpath or null
@@ -59,16 +59,24 @@ public IMockitoConfiguration loadConfiguration() {
         try {
             configClass = Class.forName(MOCKITO_CONFIGURATION_CLASS_NAME);
         } catch (ClassNotFoundException e) {
-            //that's ok, it means there is no global config, using default one.
+            // that's ok, it means there is no global config, using default one.
             return null;
         }
 
         try {
-            return (IMockitoConfiguration) configClass.newInstance();
+            return (IMockitoConfiguration) configClass.getDeclaredConstructor().newInstance();
         } catch (ClassCastException e) {
-            throw new MockitoConfigurationException("MockitoConfiguration class must implement " + IMockitoConfiguration.class.getName() + " interface.", e);
+            throw new MockitoConfigurationException(
+                    "MockitoConfiguration class must implement "
+                            + IMockitoConfiguration.class.getName()
+                            + " interface.",
+                    e);
         } catch (Exception e) {
-            throw new MockitoConfigurationException("Unable to instantiate " + MOCKITO_CONFIGURATION_CLASS_NAME +" class. Does it have a safe, no-arg constructor?", e);
+            throw new MockitoConfigurationException(
+                    "Unable to instantiate "
+                            + MOCKITO_CONFIGURATION_CLASS_NAME
+                            + " class. Does it have a safe, no-arg constructor?",
+                    e);
         }
     }
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/DefaultDoNotMockEnforcer.java b/mockito-core/src/main/java/org/mockito/internal/configuration/DefaultDoNotMockEnforcer.java
new file mode 100644
index 0000000000..ada97d6569
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/DefaultDoNotMockEnforcer.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import java.lang.annotation.Annotation;
+
+import org.mockito.DoNotMock;
+import org.mockito.plugins.DoNotMockEnforcer;
+
+public class DefaultDoNotMockEnforcer implements DoNotMockEnforcer {
+
+    @Override
+    public String checkTypeForDoNotMockViolation(Class<?> type) {
+        for (Annotation annotation : type.getAnnotations()) {
+            if (annotation.annotationType().getName().endsWith("org.mockito.DoNotMock")) {
+                String exceptionMessage =
+                        type + " is annotated with @org.mockito.DoNotMock and can't be mocked.";
+                if (DoNotMock.class.equals(annotation.annotationType())) {
+                    exceptionMessage += " " + type.getAnnotation(DoNotMock.class).reason();
+                }
+
+                return exceptionMessage;
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java b/mockito-core/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
similarity index 85%
rename from src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
index e5e98a1a20..f6b35959b6 100644
--- a/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
@@ -16,7 +16,8 @@
  */
 public class DefaultInjectionEngine {
 
-    public void injectMocksOnFields(Set<Field> needingInjection, Set<Object> mocks, Object testClassInstance) {
+    public void injectMocksOnFields(
+            Set<Field> needingInjection, Set<Object> mocks, Object testClassInstance) {
         MockInjection.onFields(needingInjection, testClassInstance)
                 .withMocks(mocks)
                 .tryConstructorInjection()
@@ -24,5 +25,4 @@ public void injectMocksOnFields(Set<Field> needingInjection, Set<Object> mocks,
                 .handleSpyAnnotation()
                 .apply();
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/configuration/FieldAnnotationProcessor.java b/mockito-core/src/main/java/org/mockito/internal/configuration/FieldAnnotationProcessor.java
similarity index 100%
rename from src/main/java/org/mockito/internal/configuration/FieldAnnotationProcessor.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/FieldAnnotationProcessor.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java b/mockito-core/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
new file mode 100644
index 0000000000..d5ad75c93b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import java.io.Serializable;
+
+import org.mockito.configuration.DefaultMockitoConfiguration;
+import org.mockito.configuration.IMockitoConfiguration;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Thread-safe wrapper on user-defined org.mockito.configuration.MockitoConfiguration implementation
+ */
+public class GlobalConfiguration implements IMockitoConfiguration, Serializable {
+    private static final long serialVersionUID = -2860353062105505938L;
+
+    private static final ThreadLocal<IMockitoConfiguration> GLOBAL_CONFIGURATION =
+            new ThreadLocal<>();
+
+    // back door for testing
+    IMockitoConfiguration getIt() {
+        return GLOBAL_CONFIGURATION.get();
+    }
+
+    public GlobalConfiguration() {
+        // Configuration should be loaded only once but I cannot really test it
+        if (GLOBAL_CONFIGURATION.get() == null) {
+            GLOBAL_CONFIGURATION.set(createConfig());
+        }
+    }
+
+    private IMockitoConfiguration createConfig() {
+        IMockitoConfiguration defaultConfiguration = new DefaultMockitoConfiguration();
+        IMockitoConfiguration config = new ClassPathLoader().loadConfiguration();
+        if (config != null) {
+            return config;
+        } else {
+            return defaultConfiguration;
+        }
+    }
+
+    public static void validate() {
+        GlobalConfiguration unused = new GlobalConfiguration();
+    }
+
+    public org.mockito.plugins.AnnotationEngine tryGetPluginAnnotationEngine() {
+        return Plugins.getAnnotationEngine();
+    }
+
+    @Override
+    public boolean cleansStackTrace() {
+        return GLOBAL_CONFIGURATION.get().cleansStackTrace();
+    }
+
+    @Override
+    public boolean enableClassCache() {
+        return GLOBAL_CONFIGURATION.get().enableClassCache();
+    }
+
+    @Override
+    public Answer<Object> getDefaultAnswer() {
+        return GLOBAL_CONFIGURATION.get().getDefaultAnswer();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java b/mockito-core/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
new file mode 100644
index 0000000000..a7950da9f9
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.mockito.internal.exceptions.Reporter.moreThanOneAnnotationNotAllowed;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.ScopedMock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.AnnotationEngine;
+import org.mockito.plugins.MemberAccessor;
+
+/**
+ * Initializes fields annotated with &#64;{@link org.mockito.Mock} or &#64;{@link org.mockito.Captor}.
+ *
+ * <p>
+ * The {@link #process(Class, Object)} method implementation <strong>does not</strong> process super classes!
+ *
+ * @see MockitoAnnotations
+ */
+@SuppressWarnings("unchecked")
+public class IndependentAnnotationEngine implements AnnotationEngine {
+    private final Map<Class<? extends Annotation>, FieldAnnotationProcessor<?>>
+            annotationProcessorMap = new HashMap<>();
+
+    public IndependentAnnotationEngine() {
+        registerAnnotationProcessor(Mock.class, new MockAnnotationProcessor());
+        registerAnnotationProcessor(Captor.class, new CaptorAnnotationProcessor());
+    }
+
+    private Object createMockFor(Annotation annotation, Field field) {
+        return forAnnotation(annotation).process(annotation, field);
+    }
+
+    private <A extends Annotation> FieldAnnotationProcessor<A> forAnnotation(A annotation) {
+        if (annotationProcessorMap.containsKey(annotation.annotationType())) {
+            return (FieldAnnotationProcessor<A>)
+                    annotationProcessorMap.get(annotation.annotationType());
+        }
+        return new FieldAnnotationProcessor<A>() {
+            @Override
+            public Object process(A annotation, Field field) {
+                return null;
+            }
+        };
+    }
+
+    private <A extends Annotation> void registerAnnotationProcessor(
+            Class<A> annotationClass, FieldAnnotationProcessor<A> fieldAnnotationProcessor) {
+        annotationProcessorMap.put(annotationClass, fieldAnnotationProcessor);
+    }
+
+    @Override
+    public AutoCloseable process(Class<?> clazz, Object testInstance) {
+        List<ScopedMock> scopedMocks = new ArrayList<>();
+        Field[] fields = clazz.getDeclaredFields();
+        for (Field field : fields) {
+            boolean alreadyAssigned = false;
+            for (Annotation annotation : field.getAnnotations()) {
+                Object mock = createMockFor(annotation, field);
+                if (mock instanceof ScopedMock) {
+                    scopedMocks.add((ScopedMock) mock);
+                }
+                if (mock != null) {
+                    throwIfAlreadyAssigned(field, alreadyAssigned);
+                    alreadyAssigned = true;
+                    final MemberAccessor accessor = Plugins.getMemberAccessor();
+                    try {
+                        accessor.set(field, testInstance, mock);
+                    } catch (Exception e) {
+                        for (ScopedMock scopedMock : scopedMocks) {
+                            scopedMock.close();
+                        }
+                        throw new MockitoException(
+                                "Problems setting field "
+                                        + field.getName()
+                                        + " annotated with "
+                                        + annotation,
+                                e);
+                    }
+                }
+            }
+        }
+        return () -> {
+            for (ScopedMock scopedMock : scopedMocks) {
+                scopedMock.closeOnDemand();
+            }
+        };
+    }
+
+    void throwIfAlreadyAssigned(Field field, boolean alreadyAssigned) {
+        if (alreadyAssigned) {
+            throw moreThanOneAnnotationNotAllowed(field.getName());
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java b/mockito-core/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
new file mode 100644
index 0000000000..eeb019ade5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.MockitoAnnotations;
+import org.mockito.ScopedMock;
+import org.mockito.internal.configuration.injection.scanner.InjectMocksScanner;
+import org.mockito.internal.configuration.injection.scanner.MockScanner;
+import org.mockito.plugins.AnnotationEngine;
+
+/**
+ * See {@link MockitoAnnotations}
+ */
+public class InjectingAnnotationEngine implements AnnotationEngine {
+    private final AnnotationEngine delegate = new IndependentAnnotationEngine();
+    private final AnnotationEngine spyAnnotationEngine = new SpyAnnotationEngine();
+
+    /**
+     * Process the fields of the test instance and create Mocks, Spies, Captors and inject them on fields
+     * annotated &#64;InjectMocks.
+     *
+     * <p>
+     * This code process the test class and the super classes.
+     * <ol>
+     * <li>First create Mocks, Spies, Captors.</li>
+     * <li>Then try to inject them.</li>
+     * </ol>
+     *
+     * @param clazz Not used
+     * @param testInstance The instance of the test, should not be null.
+     *
+     * @see org.mockito.plugins.AnnotationEngine#process(Class, Object)
+     */
+    @Override
+    public AutoCloseable process(Class<?> clazz, Object testInstance) {
+        List<AutoCloseable> closeables = new ArrayList<>();
+        closeables.addAll(processIndependentAnnotations(testInstance.getClass(), testInstance));
+        closeables.add(injectCloseableMocks(testInstance));
+        return () -> {
+            for (AutoCloseable closeable : closeables) {
+                closeable.close();
+            }
+        };
+    }
+
+    private List<AutoCloseable> processIndependentAnnotations(
+            final Class<?> clazz, final Object testInstance) {
+        List<AutoCloseable> closeables = new ArrayList<>();
+        Class<?> classContext = clazz;
+        while (classContext != Object.class) {
+            // this will create @Mocks, @Captors, etc:
+            closeables.add(delegate.process(classContext, testInstance));
+            // this will create @Spies:
+            closeables.add(spyAnnotationEngine.process(classContext, testInstance));
+
+            classContext = classContext.getSuperclass();
+        }
+        return closeables;
+    }
+
+    /**
+     * Required by PowerMockito and retained to avoid API breakage despite being internal API.
+     *
+     * @deprecated Use {@link InjectingAnnotationEngine#injectCloseableMocks(Object)}.
+     */
+    @Deprecated
+    public void injectMocks(Object testClassInstance) {
+        try {
+            injectCloseableMocks(testClassInstance).close();
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    /**
+     * Initializes mock/spies dependencies for objects annotated with
+     * &#064;InjectMocks for given testClassInstance.
+     * <p>
+     * See examples in javadoc for {@link MockitoAnnotations} class.
+     *
+     * @param testClassInstance
+     *            Test class, usually <code>this</code>
+     */
+    private AutoCloseable injectCloseableMocks(final Object testClassInstance) {
+        Class<?> clazz = testClassInstance.getClass();
+        Set<Field> mockDependentFields = new HashSet<>();
+        Set<Object> mocks = newMockSafeHashSet();
+
+        while (clazz != Object.class) {
+            new InjectMocksScanner(clazz).addTo(mockDependentFields);
+            new MockScanner(testClassInstance, clazz).addPreparedMocks(mocks);
+            onInjection(testClassInstance, clazz, mockDependentFields, mocks);
+            clazz = clazz.getSuperclass();
+        }
+
+        new DefaultInjectionEngine()
+                .injectMocksOnFields(mockDependentFields, mocks, testClassInstance);
+
+        return () -> {
+            for (Object mock : mocks) {
+                if (mock instanceof ScopedMock) {
+                    ((ScopedMock) mock).closeOnDemand();
+                }
+            }
+        };
+    }
+
+    protected void onInjection(
+            Object testClassInstance,
+            Class<?> clazz,
+            Set<Field> mockDependentFields,
+            Set<Object> mocks) {}
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java b/mockito-core/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
new file mode 100644
index 0000000000..f61f4a7bd9
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+import org.mockito.Mock;
+import org.mockito.MockSettings;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.Supplier;
+import org.mockito.quality.Strictness;
+
+/**
+ * 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::getGenericType, field.getName());
+    }
+
+    @SuppressWarnings("deprecation")
+    public static Object processAnnotationForMock(
+            Mock annotation, Class<?> type, Supplier<Type> genericType, String name) {
+        MockSettings mockSettings = Mockito.withSettings();
+        if (annotation.extraInterfaces().length > 0) { // never null
+            mockSettings.extraInterfaces(annotation.extraInterfaces());
+        }
+        if ("".equals(annotation.name())) {
+            mockSettings.name(name);
+        } else {
+            mockSettings.name(annotation.name());
+        }
+        if (annotation.serializable()) {
+            mockSettings.serializable();
+        }
+        if (annotation.stubOnly()) {
+            mockSettings.stubOnly();
+        }
+        if (annotation.lenient()) {
+            mockSettings.lenient();
+        }
+        if (annotation.strictness() != Mock.Strictness.TEST_LEVEL_DEFAULT) {
+            mockSettings.strictness(Strictness.valueOf(annotation.strictness().toString()));
+        }
+        if (!annotation.mockMaker().isEmpty()) {
+            mockSettings.mockMaker(annotation.mockMaker());
+        }
+        if (annotation.withoutAnnotations()) {
+            mockSettings.withoutAnnotations();
+        }
+
+        mockSettings.genericTypeToMock(genericType.get());
+
+        // see @Mock answer default value
+        mockSettings.defaultAnswer(annotation.answer());
+
+        if (type == MockedStatic.class) {
+            return Mockito.mockStatic(
+                    inferParameterizedType(
+                            genericType.get(), name, MockedStatic.class.getSimpleName()),
+                    mockSettings);
+        } else if (type == MockedConstruction.class) {
+            return Mockito.mockConstruction(
+                    inferParameterizedType(
+                            genericType.get(), name, MockedConstruction.class.getSimpleName()),
+                    mockSettings);
+        } else {
+            return Mockito.mock(type, mockSettings);
+        }
+    }
+
+    static Class<?> inferParameterizedType(Type type, String name, String sort) {
+        if (type instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            Type[] arguments = parameterizedType.getActualTypeArguments();
+            if (arguments.length == 1) {
+                if (arguments[0] instanceof Class<?>) {
+                    return (Class<?>) arguments[0];
+                }
+            }
+        }
+        throw new MockitoException(
+                join(
+                        "Mockito cannot infer a static mock from a raw type for " + name,
+                        "",
+                        "Instead of @Mock " + sort + " you need to specify a parameterized type",
+                        "For example, if you would like to mock Sample.class, specify",
+                        "",
+                        "@Mock " + sort + "<Sample>",
+                        "",
+                        "as the type parameter. If the type is itself parameterized, it should be specified as raw type."));
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java b/mockito-core/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
new file mode 100644
index 0000000000..cd51942581
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.withSettings;
+import static org.mockito.internal.exceptions.Reporter.unsupportedCombinationOfAnnotations;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockSettings;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.plugins.AnnotationEngine;
+import org.mockito.plugins.MemberAccessor;
+
+/**
+ * Process fields annotated with &#64;Spy.
+ * <p/>
+ * <p>
+ * Will try transform the field in a spy as with <code>Mockito.spy()</code>.
+ * </p>
+ * <p/>
+ * <p>
+ * If the field is not initialized, will try to initialize it, with a no-arg constructor.
+ * </p>
+ * <p/>
+ * <p>
+ * If the field is also annotated with the <strong>compatible</strong> &#64;InjectMocks then the field will be ignored,
+ * The injection engine will handle this specific case.
+ * </p>
+ * <p/>
+ * <p>This engine will fail, if the field is also annotated with incompatible Mockito annotations.
+ */
+@SuppressWarnings({"unchecked"})
+public class SpyAnnotationEngine implements AnnotationEngine {
+
+    @Override
+    public AutoCloseable process(Class<?> context, Object testInstance) {
+        Field[] fields = context.getDeclaredFields();
+        MemberAccessor accessor = Plugins.getMemberAccessor();
+        for (Field field : fields) {
+            if (field.isAnnotationPresent(Spy.class)
+                    && !field.isAnnotationPresent(InjectMocks.class)) {
+                assertNoIncompatibleAnnotations(Spy.class, field, Mock.class, Captor.class);
+                Object instance;
+                try {
+                    instance = accessor.get(field, testInstance);
+                    if (MockUtil.isMock(instance)) {
+                        // instance has been spied earlier
+                        // for example happens when MockitoAnnotations.openMocks is called two
+                        // times.
+                        Mockito.reset(instance);
+                    } else if (instance != null) {
+                        accessor.set(field, testInstance, spyInstance(field, instance));
+                    } else {
+                        accessor.set(field, testInstance, spyNewInstance(testInstance, field));
+                    }
+                } catch (Exception e) {
+                    throw new MockitoException(
+                            "Unable to initialize @Spy annotated field '"
+                                    + field.getName()
+                                    + "'.\n"
+                                    + e.getMessage(),
+                            e);
+                }
+            }
+        }
+        return new NoAction();
+    }
+
+    private static Object spyInstance(Field field, Object instance) {
+        // TODO: Add mockMaker option for @Spy annotation (#2740)
+        return Mockito.mock(
+                instance.getClass(),
+                withSettings()
+                        .genericTypeToMock(field.getGenericType())
+                        .spiedInstance(instance)
+                        .defaultAnswer(CALLS_REAL_METHODS)
+                        .name(field.getName()));
+    }
+
+    private static Object spyNewInstance(Object testInstance, Field field)
+            throws InstantiationException, IllegalAccessException, InvocationTargetException {
+        // TODO: Add mockMaker option for @Spy annotation (#2740)
+        MockSettings settings =
+                withSettings()
+                        .genericTypeToMock(field.getGenericType())
+                        .defaultAnswer(CALLS_REAL_METHODS)
+                        .name(field.getName());
+        Class<?> type = field.getType();
+        if (type.isInterface()) {
+            return Mockito.mock(type, settings.useConstructor());
+        }
+        int modifiers = type.getModifiers();
+        if (typeIsPrivateAbstractInnerClass(type, modifiers)) {
+            throw new MockitoException(
+                    join(
+                            "@Spy annotation can't initialize private abstract inner classes.",
+                            "  inner class: '" + type.getSimpleName() + "'",
+                            "  outer class: '" + type.getEnclosingClass().getSimpleName() + "'",
+                            "",
+                            "You should augment the visibility of this inner class"));
+        }
+        if (typeIsNonStaticInnerClass(type, modifiers)) {
+            Class<?> enclosing = type.getEnclosingClass();
+            if (!enclosing.isInstance(testInstance)) {
+                throw new MockitoException(
+                        join(
+                                "@Spy annotation can only initialize inner classes declared in the test.",
+                                "  inner class: '" + type.getSimpleName() + "'",
+                                "  outer class: '" + enclosing.getSimpleName() + "'",
+                                ""));
+            }
+            return Mockito.mock(type, settings.useConstructor().outerInstance(testInstance));
+        }
+
+        Constructor<?> constructor = noArgConstructorOf(type);
+        if (Modifier.isPrivate(constructor.getModifiers())) {
+            MemberAccessor accessor = Plugins.getMemberAccessor();
+            return Mockito.mock(type, settings.spiedInstance(accessor.newInstance(constructor)));
+        } else {
+            return Mockito.mock(type, settings.useConstructor());
+        }
+    }
+
+    private static Constructor<?> noArgConstructorOf(Class<?> type) {
+        Constructor<?> constructor;
+        try {
+            constructor = type.getDeclaredConstructor();
+        } catch (NoSuchMethodException e) {
+            throw new MockitoException(
+                    "Please ensure that the type '"
+                            + type.getSimpleName()
+                            + "' has a no-arg constructor.",
+                    e);
+        }
+        return constructor;
+    }
+
+    private static boolean typeIsNonStaticInnerClass(Class<?> type, int modifiers) {
+        return !Modifier.isStatic(modifiers) && type.getEnclosingClass() != null;
+    }
+
+    private static boolean typeIsPrivateAbstractInnerClass(Class<?> type, int modifiers) {
+        return Modifier.isPrivate(modifiers)
+                && Modifier.isAbstract(modifiers)
+                && type.getEnclosingClass() != null;
+    }
+
+    // TODO duplicated elsewhere
+    private static void assertNoIncompatibleAnnotations(
+            Class<? extends Annotation> annotation,
+            Field field,
+            Class<? extends Annotation>... undesiredAnnotations) {
+        for (Class<? extends Annotation> u : undesiredAnnotations) {
+            if (field.isAnnotationPresent(u)) {
+                throw unsupportedCombinationOfAnnotations(
+                        annotation.getSimpleName(), u.getSimpleName());
+            }
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
similarity index 80%
rename from src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
index 380fb93da1..f1577d7ecf 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
@@ -37,23 +37,25 @@
  */
 public class ConstructorInjection extends MockInjectionStrategy {
 
-    public ConstructorInjection() { }
+    public ConstructorInjection() {}
 
+    @Override
     public boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
         try {
-            SimpleArgumentResolver simpleArgumentResolver = new SimpleArgumentResolver(mockCandidates);
-            FieldInitializationReport report = new FieldInitializer(fieldOwner, field, simpleArgumentResolver).initialize();
+            SimpleArgumentResolver simpleArgumentResolver =
+                    new SimpleArgumentResolver(mockCandidates);
+            FieldInitializationReport report =
+                    new FieldInitializer(fieldOwner, field, simpleArgumentResolver).initialize();
 
             return report.fieldWasInitializedUsingContructorArgs();
         } catch (MockitoException e) {
-            if(e.getCause() instanceof InvocationTargetException) {
+            if (e.getCause() instanceof InvocationTargetException) {
                 Throwable realCause = e.getCause().getCause();
                 throw fieldInitialisationThrewException(field, realCause);
             }
             // other causes should be fine
             return false;
         }
-
     }
 
     /**
@@ -66,8 +68,9 @@ public SimpleArgumentResolver(Set<Object> objects) {
             this.objects = objects;
         }
 
+        @Override
         public Object[] resolveTypeInstances(Class<?>... argTypes) {
-            List<Object> argumentInstances = new ArrayList<Object>(argTypes.length);
+            List<Object> argumentInstances = new ArrayList<>(argTypes.length);
             for (Class<?> argType : argTypes) {
                 argumentInstances.add(objectThatIsAssignableFrom(argType));
             }
@@ -76,10 +79,11 @@ public Object[] resolveTypeInstances(Class<?>... argTypes) {
 
         private Object objectThatIsAssignableFrom(Class<?> argType) {
             for (Object object : objects) {
-                if(argType.isAssignableFrom(object.getClass())) return object;
+                if (argType.isAssignableFrom(object.getClass())) {
+                    return object;
+                }
             }
             return null;
         }
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
similarity index 93%
rename from src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
index 550599625e..342391e33b 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
@@ -16,12 +16,9 @@
 /**
  * Internal injection configuration utility.
  *
- * <p>
- * Allow the user of this class to configure the way the injection of mocks will happen.
- * </p>
- *
+ * <p>Allow the user of this class to configure the way the injection of mocks will happen.
  */
-public class MockInjection {
+public final class MockInjection {
 
     /**
      * Create a new configuration setup for a field
@@ -51,7 +48,7 @@ public static OngoingMockInjection onFields(Set<Field> fields, Object ofInstance
      * Ongoing configuration of the mock injector.
      */
     public static class OngoingMockInjection {
-        private final Set<Field> fields = new HashSet<Field>();
+        private final Set<Field> fields = new HashSet<>();
         private final Set<Object> mocks = newMockSafeHashSet();
         private final Object fieldOwner;
         private final MockInjectionStrategy injectionStrategies = MockInjectionStrategy.nop();
@@ -93,4 +90,6 @@ public void apply() {
             }
         }
     }
+
+    private MockInjection() {}
 }
diff --git a/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
similarity index 83%
rename from src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
index 3b4eed7f97..1ce4c058e5 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
@@ -17,13 +17,14 @@ public abstract class MockInjectionStrategy {
      */
     public static MockInjectionStrategy nop() {
         return new MockInjectionStrategy() {
-            protected boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
+            @Override
+            protected boolean processInjection(
+                    Field field, Object fieldOwner, Set<Object> mockCandidates) {
                 return false;
             }
         };
     }
 
-
     private MockInjectionStrategy nextStrategy;
 
     /**
@@ -37,7 +38,7 @@ protected boolean processInjection(Field field, Object fieldOwner, Set<Object> m
      * @return The passed strategy instance to allow chaining.
      */
     public MockInjectionStrategy thenTry(MockInjectionStrategy strategy) {
-        if(nextStrategy != null) {
+        if (nextStrategy != null) {
             nextStrategy.thenTry(strategy);
         } else {
             nextStrategy = strategy;
@@ -64,7 +65,7 @@ public MockInjectionStrategy thenTry(MockInjectionStrategy strategy) {
      * @return <code>true</code> if successful, <code>false</code> otherwise.
      */
     public boolean process(Field onField, Object fieldOwnedBy, Set<Object> mockCandidates) {
-        if(processInjection(onField, fieldOwnedBy, mockCandidates)) {
+        if (processInjection(onField, fieldOwnedBy, mockCandidates)) {
             return true;
         }
         return relayProcessToNextStrategy(onField, fieldOwnedBy, mockCandidates);
@@ -82,9 +83,11 @@ public boolean process(Field onField, Object fieldOwnedBy, Set<Object> mockCandi
      * @param mockCandidates Pool of mocks to inject.
      * @return <code>true</code> if injection occurred, <code>false</code> otherwise
      */
-    protected abstract boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates);
+    protected abstract boolean processInjection(
+            Field field, Object fieldOwner, Set<Object> mockCandidates);
 
-    private boolean relayProcessToNextStrategy(Field field, Object fieldOwner, Set<Object> mockCandidates) {
+    private boolean relayProcessToNextStrategy(
+            Field field, Object fieldOwner, Set<Object> mockCandidates) {
         return nextStrategy != null && nextStrategy.process(field, fieldOwner, mockCandidates);
     }
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
new file mode 100644
index 0000000000..ed32c8eea4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.injection;
+
+import static org.mockito.internal.exceptions.Reporter.cannotInitializeForInjectMocksAnnotation;
+import static org.mockito.internal.exceptions.Reporter.fieldInitialisationThrewException;
+import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
+import static org.mockito.internal.util.reflection.SuperTypesLastSorter.sortSuperTypesLast;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;
+import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;
+import org.mockito.internal.configuration.injection.filter.TerminalMockCandidateFilter;
+import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;
+import org.mockito.internal.util.reflection.FieldInitializationReport;
+import org.mockito.internal.util.reflection.FieldInitializer;
+
+/**
+ * Inject mocks using first setters then fields, if no setters available.
+ *
+ * <p>
+ * <u>Algorithm :<br></u>
+ * for each field annotated by @InjectMocks
+ *   <ul>
+ *   <li>initialize field annotated by @InjectMocks
+ *   <li>for each fields of a class in @InjectMocks type hierarchy
+ *     <ul>
+ *     <li>make a copy of mock candidates
+ *     <li>order fields from sub-type to super-type, then by field name
+ *     <li>for the list of fields in a class try two passes of :
+ *         <ul>
+ *             <li>find mock candidate by type
+ *             <li>if more than <b>*one*</b> candidate find mock candidate on name
+ *             <li>if one mock candidate then
+ *                 <ul>
+ *                     <li>set mock by property setter if possible
+ *                     <li>else set mock by field injection
+ *                 </ul>
+ *             <li>remove mock from mocks copy (mocks are just injected once in a class)
+ *             <li>remove injected field from list of class fields
+ *         </ul>
+ *     <li>else don't fail, user will then provide dependencies
+ *     </ul>
+ *   </ul>
+ * </p>
+ *
+ * <p>
+ * <u>Note:</u> If the field needing injection is not initialized, the strategy tries
+ * to create one using a no-arg constructor of the field type.
+ * </p>
+ */
+public class PropertyAndSetterInjection extends MockInjectionStrategy {
+
+    private final MockCandidateFilter mockCandidateFilter =
+            new TypeBasedCandidateFilter(
+                    new NameBasedCandidateFilter(new TerminalMockCandidateFilter()));
+
+    @Override
+    public boolean processInjection(
+            Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {
+        FieldInitializationReport report =
+                initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);
+
+        // for each field in the class hierarchy
+        boolean injectionOccurred = false;
+        Class<?> fieldClass = report.fieldClass();
+        Object fieldInstanceNeedingInjection = report.fieldInstance();
+        while (fieldClass != Object.class) {
+            injectionOccurred |=
+                    injectMockCandidates(
+                            fieldClass,
+                            fieldInstanceNeedingInjection,
+                            injectMocksField,
+                            newMockSafeHashSet(mockCandidates));
+            fieldClass = fieldClass.getSuperclass();
+        }
+        return injectionOccurred;
+    }
+
+    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {
+        try {
+            return new FieldInitializer(fieldOwner, field).initialize();
+        } catch (MockitoException e) {
+            if (e.getCause() instanceof InvocationTargetException) {
+                Throwable realCause = e.getCause().getCause();
+                throw fieldInitialisationThrewException(field, realCause);
+            }
+            throw cannotInitializeForInjectMocksAnnotation(field.getName(), e.getMessage());
+        }
+    }
+
+    private boolean injectMockCandidates(
+            Class<?> awaitingInjectionClazz,
+            Object injectee,
+            Field injectMocksField,
+            Set<Object> mocks) {
+        boolean injectionOccurred;
+        List<Field> orderedCandidateInjecteeFields =
+                orderedInstanceFieldsFrom(awaitingInjectionClazz);
+        // pass 1
+        injectionOccurred =
+                injectMockCandidatesOnFields(
+                        mocks, injectee, injectMocksField, false, orderedCandidateInjecteeFields);
+        // pass 2
+        injectionOccurred |=
+                injectMockCandidatesOnFields(
+                        mocks,
+                        injectee,
+                        injectMocksField,
+                        injectionOccurred,
+                        orderedCandidateInjecteeFields);
+        return injectionOccurred;
+    }
+
+    private boolean injectMockCandidatesOnFields(
+            Set<Object> mocks,
+            Object injectee,
+            Field injectMocksField,
+            boolean injectionOccurred,
+            List<Field> orderedCandidateInjecteeFields) {
+        for (Iterator<Field> it = orderedCandidateInjecteeFields.iterator(); it.hasNext(); ) {
+            Field candidateField = it.next();
+            Object injected =
+                    mockCandidateFilter
+                            .filterCandidate(
+                                    mocks,
+                                    candidateField,
+                                    orderedCandidateInjecteeFields,
+                                    injectee,
+                                    injectMocksField)
+                            .thenInject();
+            if (injected != null) {
+                injectionOccurred |= true;
+                mocks.remove(injected);
+                it.remove();
+            }
+        }
+        return injectionOccurred;
+    }
+
+    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {
+        return sortSuperTypesLast(
+                Arrays.stream(awaitingInjectionClazz.getDeclaredFields())
+                        .filter(
+                                field ->
+                                        !Modifier.isFinal(field.getModifiers())
+                                                && !Modifier.isStatic(field.getModifiers()))
+                        .collect(Collectors.toList()));
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
new file mode 100644
index 0000000000..bbfe88b85a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.injection;
+
+import static org.mockito.Mockito.withSettings;
+
+import java.lang.reflect.Field;
+import java.util.Set;
+
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.reflection.FieldReader;
+import org.mockito.plugins.MemberAccessor;
+
+/**
+ * Handler for field annotated with &#64;InjectMocks and &#64;Spy.
+ *
+ * <p>
+ * The handler assumes that field initialization AND injection already happened.
+ * So if the field is still null, then nothing will happen there.
+ * </p>
+ */
+public class SpyOnInjectedFieldsHandler extends MockInjectionStrategy {
+
+    private final MemberAccessor accessor = Plugins.getMemberAccessor();
+
+    @Override
+    protected boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
+        FieldReader fieldReader = new FieldReader(fieldOwner, field);
+
+        // TODO refactor : code duplicated in SpyAnnotationEngine
+        if (!fieldReader.isNull() && field.isAnnotationPresent(Spy.class)) {
+            try {
+                Object instance = fieldReader.read();
+                if (MockUtil.isMock(instance)) {
+                    // A. instance has been spied earlier
+                    // B. protect against multiple use of MockitoAnnotations.openMocks()
+                    Mockito.reset(instance);
+                } else {
+                    // TODO: Add mockMaker option for @Spy annotation (#2740)
+                    Object mock =
+                            Mockito.mock(
+                                    instance.getClass(),
+                                    withSettings()
+                                            .spiedInstance(instance)
+                                            .defaultAnswer(Mockito.CALLS_REAL_METHODS)
+                                            .name(field.getName()));
+                    accessor.set(field, fieldOwner, mock);
+                }
+            } catch (Exception e) {
+                throw new MockitoException("Problems initiating spied field " + field.getName(), e);
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
similarity index 87%
rename from src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
index 454d3be981..82c913695e 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
@@ -13,6 +13,6 @@ OngoingInjector filterCandidate(
             Collection<Object> mocks,
             Field candidateFieldToBeInjected,
             List<Field> allRemainingCandidateFields,
-            Object injectee
-    );
+            Object injectee,
+            Field injectMocksField);
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
new file mode 100644
index 0000000000..b2cc6c75d5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.injection.filter;
+
+import static org.mockito.internal.util.MockUtil.getMockName;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class NameBasedCandidateFilter implements MockCandidateFilter {
+    private final MockCandidateFilter next;
+
+    public NameBasedCandidateFilter(MockCandidateFilter next) {
+        this.next = next;
+    }
+
+    @Override
+    public OngoingInjector filterCandidate(
+            final Collection<Object> mocks,
+            final Field candidateFieldToBeInjected,
+            final List<Field> allRemainingCandidateFields,
+            final Object injectee,
+            final Field injectMocksField) {
+        if (mocks.size() == 1
+                && anotherCandidateMatchesMockName(
+                        mocks, candidateFieldToBeInjected, allRemainingCandidateFields)) {
+            return OngoingInjector.nop;
+        }
+
+        return next.filterCandidate(
+                tooMany(mocks) ? selectMatchingName(mocks, candidateFieldToBeInjected) : mocks,
+                candidateFieldToBeInjected,
+                allRemainingCandidateFields,
+                injectee,
+                injectMocksField);
+    }
+
+    private boolean tooMany(Collection<Object> mocks) {
+        return mocks.size() > 1;
+    }
+
+    private List<Object> selectMatchingName(
+            Collection<Object> mocks, Field candidateFieldToBeInjected) {
+        List<Object> mockNameMatches = new ArrayList<>();
+        for (Object mock : mocks) {
+            if (candidateFieldToBeInjected.getName().equals(getMockName(mock).toString())) {
+                mockNameMatches.add(mock);
+            }
+        }
+        return mockNameMatches;
+    }
+
+    /*
+     * In this case we have to check whether we have conflicting naming
+     * fields. E.g. 2 fields of the same type, but we have to make sure
+     * we match on the correct name.
+     *
+     * Therefore we have to go through all other fields and make sure
+     * whenever we find a field that does match its name with the mock
+     * name, we should take that field instead.
+     */
+    private boolean anotherCandidateMatchesMockName(
+            final Collection<Object> mocks,
+            final Field candidateFieldToBeInjected,
+            final List<Field> allRemainingCandidateFields) {
+        String mockName = getMockName(mocks.iterator().next()).toString();
+
+        for (Field otherCandidateField : allRemainingCandidateFields) {
+            if (!otherCandidateField.equals(candidateFieldToBeInjected)
+                    && otherCandidateField.getType().equals(candidateFieldToBeInjected.getType())
+                    && otherCandidateField.getName().equals(mockName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
similarity index 75%
rename from src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
index 4550e1f558..a10d04167f 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
@@ -23,9 +23,11 @@ public interface OngoingInjector {
     /**
      * Injector that will do nothing, and will return <code>null</code> as no mocks will be injected
      */
-    OngoingInjector nop = new OngoingInjector() {
-        public Object thenInject() {
-            return null;
-        }
-    };
+    OngoingInjector nop =
+            new OngoingInjector() {
+                @Override
+                public Object thenInject() {
+                    return null;
+                }
+            };
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
new file mode 100644
index 0000000000..5726ee2015
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.injection.filter;
+
+import static org.mockito.internal.exceptions.Reporter.cannotInjectDependency;
+
+import java.lang.reflect.Field;
+import java.util.Collection;
+import java.util.List;
+
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.reflection.BeanPropertySetter;
+import org.mockito.plugins.MemberAccessor;
+
+/**
+ * This node returns an actual injecter which will be either :
+ *
+ * <ul>
+ * <li>an {@link OngoingInjector} that do nothing if a candidate couldn't be found</li>
+ * <li>an {@link OngoingInjector} that will try to inject the candidate trying first the property setter then if not possible try the field access</li>
+ * </ul>
+ */
+public class TerminalMockCandidateFilter implements MockCandidateFilter {
+    @Override
+    public OngoingInjector filterCandidate(
+            final Collection<Object> mocks,
+            final Field candidateFieldToBeInjected,
+            final List<Field> allRemainingCandidateFields,
+            final Object injectee,
+            final Field injectMocksField) {
+        if (mocks.size() == 1) {
+            final Object matchingMock = mocks.iterator().next();
+
+            MemberAccessor accessor = Plugins.getMemberAccessor();
+            return () -> {
+                try {
+                    if (!new BeanPropertySetter(injectee, candidateFieldToBeInjected)
+                            .set(matchingMock)) {
+                        accessor.set(candidateFieldToBeInjected, injectee, matchingMock);
+                    }
+                } catch (RuntimeException | IllegalAccessException e) {
+                    throw cannotInjectDependency(candidateFieldToBeInjected, matchingMock, e);
+                }
+                return matchingMock;
+            };
+        }
+
+        return OngoingInjector.nop;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
new file mode 100644
index 0000000000..cf93d97d19
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.injection.filter;
+
+import static org.mockito.internal.exceptions.Reporter.moreThanOneMockCandidate;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.mockito.internal.util.MockUtil;
+
+public class TypeBasedCandidateFilter implements MockCandidateFilter {
+
+    private final MockCandidateFilter next;
+
+    public TypeBasedCandidateFilter(MockCandidateFilter next) {
+        this.next = next;
+    }
+
+    protected boolean isCompatibleTypes(Type typeToMock, Type mockType, Field injectMocksField) {
+        boolean result = false;
+        if (typeToMock instanceof ParameterizedType) {
+            if (mockType instanceof ParameterizedType) {
+                // ParameterizedType.equals() is documented as:
+                // "Instances of classes that implement this interface must implement
+                // an equals() method that equates any two instances that share the
+                // same generic type declaration and have equal type parameters."
+                // Unfortunately, e.g. Wildcard parameter "?" doesn't equal java.lang.String,
+                // and e.g. Set doesn't equal TreeSet, so roll our own comparison if
+                // ParameterizedTypeImpl.equals() returns false
+                if (typeToMock.equals(mockType)) {
+                    result = true;
+                } else {
+                    ParameterizedType genericTypeToMock = (ParameterizedType) typeToMock;
+                    ParameterizedType genericMockType = (ParameterizedType) mockType;
+                    Type[] actualTypeArguments = genericTypeToMock.getActualTypeArguments();
+                    Type[] actualTypeArguments2 = genericMockType.getActualTypeArguments();
+                    if (actualTypeArguments.length == actualTypeArguments2.length) {
+                        // Recurse on type parameters, so we properly test whether e.g. Wildcard
+                        // bounds have a match
+                        result =
+                                recurseOnTypeArguments(
+                                        injectMocksField,
+                                        actualTypeArguments,
+                                        actualTypeArguments2);
+                    } else {
+                        // the two ParameterizedTypes cannot match because they have unequal
+                        // number of type arguments
+                        result = false;
+                    }
+                }
+            } else {
+                // mockType is a non-parameterized Class, i.e. a concrete class.
+                // so walk concrete class' type hierarchy
+                Class<?> concreteMockClass = (Class<?>) mockType;
+                Stream<Type> mockSuperTypes = getSuperTypes(concreteMockClass);
+                result =
+                        mockSuperTypes.anyMatch(
+                                mockSuperType ->
+                                        isCompatibleTypes(
+                                                typeToMock, mockSuperType, injectMocksField));
+            }
+        } else if (typeToMock instanceof WildcardType) {
+            WildcardType wildcardTypeToMock = (WildcardType) typeToMock;
+            Type[] upperBounds = wildcardTypeToMock.getUpperBounds();
+            result =
+                    Arrays.stream(upperBounds)
+                            .anyMatch(t -> isCompatibleTypes(t, mockType, injectMocksField));
+        } else if (typeToMock instanceof Class && mockType instanceof Class) {
+            result = ((Class<?>) typeToMock).isAssignableFrom((Class<?>) mockType);
+        } // no need to check for GenericArrayType, as Mockito cannot mock this anyway
+
+        return result;
+    }
+
+    private Stream<Type> getSuperTypes(Class<?> concreteMockClass) {
+        Stream<Type> mockInterfaces = Arrays.stream(concreteMockClass.getGenericInterfaces());
+        Type genericSuperclass = concreteMockClass.getGenericSuperclass();
+        // for java.lang.Object, genericSuperclass is null
+        if (genericSuperclass != null) {
+            Stream<Type> mockSuperTypes =
+                    Stream.concat(mockInterfaces, Stream.of(genericSuperclass));
+            return mockSuperTypes;
+        } else {
+            return mockInterfaces;
+        }
+    }
+
+    private boolean recurseOnTypeArguments(
+            Field injectMocksField, Type[] actualTypeArguments, Type[] actualTypeArguments2) {
+        boolean isCompatible = true;
+        for (int i = 0; i < actualTypeArguments.length; i++) {
+            Type actualTypeArgument = actualTypeArguments[i];
+            Type actualTypeArgument2 = actualTypeArguments2[i];
+            if (actualTypeArgument instanceof TypeVariable) {
+                TypeVariable<?> typeVariable = (TypeVariable<?>) actualTypeArgument;
+                // this is a TypeVariable declared by the class under test that turned
+                // up in one of its fields,
+                // e.g. class ClassUnderTest<T1, T2> { List<T1> tList; Set<T2> tSet}
+                // The TypeVariable`s actual type is declared by the field containing
+                // the object under test, i.e. the field annotated with @InjectMocks
+                // e.g. @InjectMocks ClassUnderTest<String, Integer> underTest = ..
+
+                Type genericType = injectMocksField.getGenericType();
+                if (genericType instanceof ParameterizedType) {
+                    Type[] injectMocksFieldTypeParameters =
+                            ((ParameterizedType) genericType).getActualTypeArguments();
+                    // Find index of given TypeVariable where it was defined, e.g. 0 for T1 in
+                    // ClassUnderTest<T1, T2>
+                    // (we're always able to find it, otherwise test class wouldn't have compiled))
+                    TypeVariable<?>[] genericTypeParameters =
+                            injectMocksField.getType().getTypeParameters();
+                    int variableIndex = -1;
+                    for (int i2 = 0; i2 < genericTypeParameters.length; i2++) {
+                        if (genericTypeParameters[i2].equals(typeVariable)) {
+                            variableIndex = i2;
+                            break;
+                        }
+                    }
+                    // now test whether actual type for the type variable is compatible, e.g. for
+                    //   class ClassUnderTest<T1, T2> {..}
+                    // T1 would be the String in
+                    //   ClassUnderTest<String, Integer> underTest = ..
+                    isCompatible &=
+                            isCompatibleTypes(
+                                    injectMocksFieldTypeParameters[variableIndex],
+                                    actualTypeArgument2,
+                                    injectMocksField);
+                } else {
+                    // must be a concrete class, recurse on super types that may have type
+                    // parameters
+                    isCompatible &=
+                            getSuperTypes((Class<?>) genericType)
+                                    .anyMatch(
+                                            superType ->
+                                                    isCompatibleTypes(
+                                                            superType,
+                                                            actualTypeArgument2,
+                                                            injectMocksField));
+                }
+            } else {
+                isCompatible &=
+                        isCompatibleTypes(
+                                actualTypeArgument, actualTypeArgument2, injectMocksField);
+            }
+        }
+        return isCompatible;
+    }
+
+    @Override
+    public OngoingInjector filterCandidate(
+            final Collection<Object> mocks,
+            final Field candidateFieldToBeInjected,
+            final List<Field> allRemainingCandidateFields,
+            final Object injectee,
+            final Field injectMocksField) {
+        List<Object> mockTypeMatches = new ArrayList<>();
+        for (Object mock : mocks) {
+            if (candidateFieldToBeInjected.getType().isAssignableFrom(mock.getClass())) {
+                Type mockType = MockUtil.getMockSettings(mock).getGenericTypeToMock();
+                Type typeToMock = candidateFieldToBeInjected.getGenericType();
+                boolean bothHaveTypeInfo = typeToMock != null && mockType != null;
+                if (bothHaveTypeInfo) {
+                    // be more specific if generic type information is available
+                    if (isCompatibleTypes(typeToMock, mockType, injectMocksField)) {
+                        mockTypeMatches.add(mock);
+                    } // else filter out mock, as generic types don't match
+                } else {
+                    // field is assignable from mock class, but no generic type information
+                    // is available (can happen with programmatically created Mocks where no
+                    // genericTypeToMock was supplied)
+                    mockTypeMatches.add(mock);
+                }
+            } // else filter out mock
+            // BTW mocks may contain Spy objects with their original class (seemingly before
+            // being wrapped), and MockUtil.getMockSettings() throws exception for those
+        }
+
+        boolean wasMultipleMatches = mockTypeMatches.size() > 1;
+
+        OngoingInjector result =
+                next.filterCandidate(
+                        mockTypeMatches,
+                        candidateFieldToBeInjected,
+                        allRemainingCandidateFields,
+                        injectee,
+                        injectMocksField);
+
+        if (wasMultipleMatches) {
+            // we had found multiple mocks matching by type, see whether following filters
+            // were able to reduce this to single match (e.g. by filtering for matching field names)
+            if (result == OngoingInjector.nop) {
+                // nope, following filters cannot reduce this to a single match
+                throw moreThanOneMockCandidate(candidateFieldToBeInjected, mocks);
+            }
+        }
+        return result;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/package-info.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/configuration/injection/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/package-info.java
diff --git a/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
similarity index 84%
rename from src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
index 167196a528..b206f1847e 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
@@ -30,7 +30,6 @@ public InjectMocksScanner(Class<?> clazz) {
         this.clazz = clazz;
     }
 
-
     /**
      * Add the fields annotated by @{@link InjectMocks}
      *
@@ -47,7 +46,7 @@ public void addTo(Set<Field> mockDependentFields) {
      */
     @SuppressWarnings("unchecked")
     private Set<Field> scan() {
-        Set<Field> mockDependentFields = new HashSet<Field>();
+        Set<Field> mockDependentFields = new HashSet<>();
         Field[] fields = clazz.getDeclaredFields();
         for (Field field : fields) {
             if (null != field.getAnnotation(InjectMocks.class)) {
@@ -59,10 +58,12 @@ private Set<Field> scan() {
         return mockDependentFields;
     }
 
-    private static void assertNoAnnotations(Field field, Class<? extends Annotation>... annotations) {
+    private static void assertNoAnnotations(
+            Field field, Class<? extends Annotation>... annotations) {
         for (Class<? extends Annotation> annotation : annotations) {
             if (field.isAnnotationPresent(annotation)) {
-                throw unsupportedCombinationOfAnnotations(annotation.getSimpleName(), InjectMocks.class.getSimpleName());
+                throw unsupportedCombinationOfAnnotations(
+                        annotation.getSimpleName(), InjectMocks.class.getSimpleName());
             }
         }
     }
diff --git a/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
similarity index 96%
rename from src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
index b7da87246b..97984444c7 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
@@ -80,7 +80,6 @@ private boolean isAnnotatedByMockOrSpy(Field field) {
     }
 
     private boolean isMockOrSpy(Object instance) {
-        return MockUtil.isMock(instance)
-                || MockUtil.isSpy(instance);
+        return MockUtil.isMock(instance) || MockUtil.isSpy(instance);
     }
 }
diff --git a/src/main/java/org/mockito/internal/configuration/package-info.java b/mockito-core/src/main/java/org/mockito/internal/configuration/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/configuration/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
new file mode 100644
index 0000000000..96da9debdc
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.mockito.MockMakers;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.plugins.AnnotationEngine;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
+import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MemberAccessor;
+import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.plugins.MockitoPlugins;
+import org.mockito.plugins.PluginSwitch;
+import org.mockito.plugins.StackTraceCleanerProvider;
+
+public class DefaultMockitoPlugins implements MockitoPlugins {
+
+    private static final Map<String, String> DEFAULT_PLUGINS = new HashMap<>();
+    static final String INLINE_ALIAS = MockMakers.INLINE;
+    static final String PROXY_ALIAS = MockMakers.PROXY;
+    static final String SUBCLASS_ALIAS = MockMakers.SUBCLASS;
+    public static final Set<String> MOCK_MAKER_ALIASES = new HashSet<>();
+    static final String MODULE_ALIAS = "member-accessor-module";
+    static final String REFLECTION_ALIAS = "member-accessor-reflection";
+    public static final Set<String> MEMBER_ACCESSOR_ALIASES = new HashSet<>();
+
+    static {
+        // Keep the mapping: plugin interface name -> plugin implementation class name
+        DEFAULT_PLUGINS.put(PluginSwitch.class.getName(), DefaultPluginSwitch.class.getName());
+        DEFAULT_PLUGINS.put(
+                MockMaker.class.getName(),
+                "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
+        DEFAULT_PLUGINS.put(
+                StackTraceCleanerProvider.class.getName(),
+                "org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleanerProvider");
+        DEFAULT_PLUGINS.put(
+                InstantiatorProvider2.class.getName(),
+                "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
+        DEFAULT_PLUGINS.put(
+                AnnotationEngine.class.getName(),
+                "org.mockito.internal.configuration.InjectingAnnotationEngine");
+        DEFAULT_PLUGINS.put(
+                INLINE_ALIAS, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
+        DEFAULT_PLUGINS.put(PROXY_ALIAS, "org.mockito.internal.creation.proxy.ProxyMockMaker");
+        DEFAULT_PLUGINS.put(
+                SUBCLASS_ALIAS, "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker");
+        DEFAULT_PLUGINS.put(
+                MockitoLogger.class.getName(), "org.mockito.internal.util.ConsoleMockitoLogger");
+        DEFAULT_PLUGINS.put(
+                MemberAccessor.class.getName(),
+                "org.mockito.internal.util.reflection.ModuleMemberAccessor");
+        DEFAULT_PLUGINS.put(
+                MODULE_ALIAS, "org.mockito.internal.util.reflection.ModuleMemberAccessor");
+        DEFAULT_PLUGINS.put(
+                REFLECTION_ALIAS, "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
+        DEFAULT_PLUGINS.put(
+                DoNotMockEnforcerWithType.class.getName(),
+                "org.mockito.internal.configuration.DefaultDoNotMockEnforcer");
+
+        MOCK_MAKER_ALIASES.add(INLINE_ALIAS);
+        MOCK_MAKER_ALIASES.add(PROXY_ALIAS);
+        MOCK_MAKER_ALIASES.add(SUBCLASS_ALIAS);
+
+        MEMBER_ACCESSOR_ALIASES.add(MODULE_ALIAS);
+        MEMBER_ACCESSOR_ALIASES.add(REFLECTION_ALIAS);
+    }
+
+    @Override
+    public <T> T getDefaultPlugin(Class<T> pluginType) {
+        String className = DEFAULT_PLUGINS.get(pluginType.getName());
+        return create(pluginType, className);
+    }
+
+    public static String getDefaultPluginClass(String classOrAlias) {
+        return DEFAULT_PLUGINS.get(classOrAlias);
+    }
+
+    /**
+     * Creates an instance of given plugin type, using specific implementation class.
+     */
+    private <T> T create(Class<T> pluginType, String className) {
+        if (className == null) {
+            throw new IllegalStateException(
+                    "No default implementation for requested Mockito plugin type: "
+                            + pluginType.getName()
+                            + "\n"
+                            + "Is this a valid Mockito plugin type? If yes, please report this problem to Mockito team.\n"
+                            + "Otherwise, please check if you are passing valid plugin type.\n"
+                            + "Examples of valid plugin types: MockMaker, StackTraceCleanerProvider.");
+        }
+        try {
+            // Default implementation. Use our own ClassLoader instead of the context
+            // ClassLoader, as the default implementation is assumed to be part of
+            // Mockito and may not be available via the context ClassLoader.
+            return pluginType.cast(Class.forName(className).getDeclaredConstructor().newInstance());
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                    "Internal problem occurred, please report it. "
+                            + "Mockito is unable to load the default implementation of class that is a part of Mockito distribution. "
+                            + "Failed to load "
+                            + pluginType,
+                    e);
+        }
+    }
+
+    @Override
+    public MockMaker getInlineMockMaker() {
+        return create(MockMaker.class, DEFAULT_PLUGINS.get(INLINE_ALIAS));
+    }
+
+    @Override
+    public MockMaker getMockMaker(String mockMaker) {
+        return MockUtil.getMockMaker(mockMaker);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
similarity index 96%
rename from src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
index e332cd9d5a..61fded6322 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
@@ -7,6 +7,7 @@
 import org.mockito.plugins.PluginSwitch;
 
 class DefaultPluginSwitch implements PluginSwitch {
+    @Override
     public boolean isEnabled(String pluginClassName) {
         return true;
     }
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
similarity index 93%
rename from src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
index 1dc63cabbd..c1e2cbbbe8 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
@@ -11,7 +11,7 @@
 class PluginFileReader {
 
     String readPluginClass(InputStream input) {
-        for(String line: IOUtil.readLines(input)) {
+        for (String line : IOUtil.readLines(input)) {
             String stripped = stripCommentAndWhitespace(line);
             if (stripped.length() > 0) {
                 return stripped;
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
new file mode 100644
index 0000000000..3ca2ac5cd4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.io.IOUtil;
+import org.mockito.plugins.PluginSwitch;
+
+class PluginFinder {
+
+    private final PluginSwitch pluginSwitch;
+
+    public PluginFinder(PluginSwitch pluginSwitch) {
+        this.pluginSwitch = pluginSwitch;
+    }
+
+    String findPluginClass(Iterable<URL> resources) {
+        for (URL resource : resources) {
+            InputStream s = null;
+            try {
+                s = resource.openStream();
+                String pluginClassName = new PluginFileReader().readPluginClass(s);
+                if (pluginClassName == null) {
+                    // For backwards compatibility
+                    // If the resource does not have plugin class name we're ignoring it
+                    continue;
+                }
+                if (!pluginSwitch.isEnabled(pluginClassName)) {
+                    continue;
+                }
+                return pluginClassName;
+            } catch (Exception e) {
+                throw new MockitoException(
+                        "Problems reading plugin implementation from: " + resource, e);
+            } finally {
+                IOUtil.closeQuietly(s);
+            }
+        }
+        return null;
+    }
+
+    List<String> findPluginClasses(Iterable<URL> resources) {
+        List<String> pluginClassNames = new ArrayList<>();
+        for (URL resource : resources) {
+            InputStream s = null;
+            try {
+                s = resource.openStream();
+                String pluginClassName = new PluginFileReader().readPluginClass(s);
+                if (pluginClassName == null) {
+                    // For backwards compatibility
+                    // If the resource does not have plugin class name we're ignoring it
+                    continue;
+                }
+                if (!pluginSwitch.isEnabled(pluginClassName)) {
+                    continue;
+                }
+                pluginClassNames.add(pluginClassName);
+            } catch (Exception e) {
+                throw new MockitoException(
+                        "Problems reading plugin implementation from: " + resource, e);
+            } finally {
+                IOUtil.closeQuietly(s);
+            }
+        }
+        return pluginClassNames;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
new file mode 100644
index 0000000000..262f7e78b8
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.internal.util.collections.Iterables;
+import org.mockito.plugins.PluginSwitch;
+
+class PluginInitializer {
+
+    private final PluginSwitch pluginSwitch;
+    private final Set<String> alias;
+
+    PluginInitializer(PluginSwitch pluginSwitch, Set<String> alias) {
+        this.pluginSwitch = pluginSwitch;
+        this.alias = alias;
+    }
+
+    /**
+     * Equivalent to {@link java.util.ServiceLoader#load} but without requiring
+     * Java 6 / Android 2.3 (Gingerbread).
+     */
+    public <T> T loadImpl(Class<T> service) {
+        ClassLoader loader = Thread.currentThread().getContextClassLoader();
+        if (loader == null) {
+            loader = ClassLoader.getSystemClassLoader();
+        }
+        Enumeration<URL> resources;
+        try {
+            resources = loader.getResources("mockito-extensions/" + service.getName());
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to load " + service, e);
+        }
+
+        try {
+            String classOrAlias =
+                    new PluginFinder(pluginSwitch).findPluginClass(Iterables.toIterable(resources));
+            if (classOrAlias != null) {
+                if (alias.contains(classOrAlias)) {
+                    classOrAlias = DefaultMockitoPlugins.getDefaultPluginClass(classOrAlias);
+                }
+                Class<?> pluginClass = loader.loadClass(classOrAlias);
+                addReads(pluginClass);
+                Object plugin = pluginClass.getDeclaredConstructor().newInstance();
+                return service.cast(plugin);
+            }
+            return null;
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                    "Failed to load " + service + " implementation declared in " + resources, e);
+        }
+    }
+
+    public <T> List<T> loadImpls(Class<T> service) {
+        ClassLoader loader = Thread.currentThread().getContextClassLoader();
+        if (loader == null) {
+            loader = ClassLoader.getSystemClassLoader();
+        }
+        Enumeration<URL> resources;
+        try {
+            resources = loader.getResources("mockito-extensions/" + service.getName());
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to load " + service, e);
+        }
+
+        try {
+            List<String> classesOrAliases =
+                    new PluginFinder(pluginSwitch)
+                            .findPluginClasses(Iterables.toIterable(resources));
+            List<T> impls = new ArrayList<>();
+            for (String classOrAlias : classesOrAliases) {
+                if (alias.contains(classOrAlias)) {
+                    classOrAlias = DefaultMockitoPlugins.getDefaultPluginClass(classOrAlias);
+                }
+                Class<?> pluginClass = loader.loadClass(classOrAlias);
+                addReads(pluginClass);
+                Object plugin = pluginClass.getDeclaredConstructor().newInstance();
+                impls.add(service.cast(plugin));
+            }
+            return impls;
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                    "Failed to load " + service + " implementation declared in " + resources, e);
+        }
+    }
+
+    private static void addReads(Class<?> pluginClass) {
+        try {
+            Method getModule = Class.class.getMethod("getModule");
+            Method addReads =
+                    getModule.getReturnType().getMethod("addReads", getModule.getReturnType());
+            addReads.invoke(
+                    getModule.invoke(PluginInitializer.class), getModule.invoke(pluginClass));
+        } catch (NoSuchMethodException ignored) {
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
new file mode 100644
index 0000000000..9ff6ff6f84
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+import org.mockito.plugins.PluginSwitch;
+
+class PluginLoader {
+
+    private final DefaultMockitoPlugins plugins;
+    private final PluginInitializer initializer;
+
+    PluginLoader(DefaultMockitoPlugins plugins, PluginInitializer initializer) {
+        this.plugins = plugins;
+        this.initializer = initializer;
+    }
+
+    PluginLoader(PluginSwitch pluginSwitch) {
+        this(
+                new DefaultMockitoPlugins(),
+                new PluginInitializer(pluginSwitch, Collections.emptySet()));
+    }
+
+    /**
+     * Adds an alias for a class name to this plugin loader. Instead of the fully qualified type name,
+     * the alias can be used as a convenience name for a known plugin. This avoids exposing API that is
+     * explicitly marked as <i>internal</i> through the package name. Without such aliases, we would need
+     * to make internal packages part of the API, not by code but by configuration file.
+     */
+    PluginLoader(PluginSwitch pluginSwitch, String... alias) {
+        this(
+                new DefaultMockitoPlugins(),
+                new PluginInitializer(pluginSwitch, new HashSet<>(Arrays.asList(alias))));
+    }
+
+    /**
+     * Scans the classpath for given pluginType. If not found, default class is used.
+     */
+    <T> T loadPlugin(final Class<T> pluginType) {
+        return loadPlugin(pluginType, null);
+    }
+
+    /**
+     * Scans the classpath for given {@code preferredPluginType}. If not found scan for {@code
+     * alternatePluginType}. If neither a preferred or alternate plugin is found, default to default
+     * class of {@code preferredPluginType}.
+     *
+     * @return An object of either {@code preferredPluginType} or {@code alternatePluginType},
+     * cast to the lowest common denominator in the chain of inheritance
+     */
+    @SuppressWarnings("unchecked")
+    <ReturnT, PreferredT extends ReturnT, AlternateType extends ReturnT> ReturnT loadPlugin(
+            final Class<PreferredT> preferredPluginType,
+            final Class<AlternateType> alternatePluginType) {
+        try {
+            PreferredT preferredPlugin = initializer.loadImpl(preferredPluginType);
+            if (preferredPlugin != null) {
+                return preferredPlugin;
+            } else if (alternatePluginType != null) {
+                AlternateType alternatePlugin = initializer.loadImpl(alternatePluginType);
+                if (alternatePlugin != null) {
+                    return alternatePlugin;
+                }
+            }
+
+            return plugins.getDefaultPlugin(preferredPluginType);
+        } catch (final Throwable t) {
+            return (ReturnT)
+                    Proxy.newProxyInstance(
+                            preferredPluginType.getClassLoader(),
+                            new Class<?>[] {preferredPluginType},
+                            new InvocationHandler() {
+                                @Override
+                                public Object invoke(Object proxy, Method method, Object[] args)
+                                        throws Throwable {
+                                    throw new IllegalStateException(
+                                            "Could not initialize plugin: "
+                                                    + preferredPluginType
+                                                    + " (alternate: "
+                                                    + alternatePluginType
+                                                    + ")",
+                                            t);
+                                }
+                            });
+        }
+    }
+
+    /**
+     * Scans the classpath for given {@code pluginType} and returns a list of its instances.
+     *
+     * @return An list of {@code pluginType} or an empty list if none was found.
+     */
+    @SuppressWarnings("unchecked")
+    <T> List<T> loadPlugins(final Class<T> pluginType) {
+        try {
+            return initializer.loadImpls(pluginType);
+        } catch (final Throwable t) {
+            return Collections.singletonList(
+                    (T)
+                            Proxy.newProxyInstance(
+                                    pluginType.getClassLoader(),
+                                    new Class<?>[] {pluginType},
+                                    new InvocationHandler() {
+                                        @Override
+                                        public Object invoke(
+                                                Object proxy, Method method, Object[] args)
+                                                throws Throwable {
+                                            throw new IllegalStateException(
+                                                    "Could not initialize plugin: " + pluginType,
+                                                    t);
+                                        }
+                                    }));
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
new file mode 100644
index 0000000000..2c19d74518
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import java.util.List;
+
+import org.mockito.plugins.AnnotationEngine;
+import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
+import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MemberAccessor;
+import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockResolver;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.plugins.PluginSwitch;
+import org.mockito.plugins.StackTraceCleanerProvider;
+
+class PluginRegistry {
+
+    private final PluginSwitch pluginSwitch =
+            new PluginLoader(new DefaultPluginSwitch()).loadPlugin(PluginSwitch.class);
+
+    private final MockMaker mockMaker =
+            new PluginLoader(
+                            pluginSwitch,
+                            DefaultMockitoPlugins.MOCK_MAKER_ALIASES.toArray(new String[0]))
+                    .loadPlugin(MockMaker.class);
+
+    private final MemberAccessor memberAccessor =
+            new PluginLoader(
+                            pluginSwitch,
+                            DefaultMockitoPlugins.MEMBER_ACCESSOR_ALIASES.toArray(new String[0]))
+                    .loadPlugin(MemberAccessor.class);
+
+    private final StackTraceCleanerProvider stackTraceCleanerProvider =
+            new PluginLoader(pluginSwitch).loadPlugin(StackTraceCleanerProvider.class);
+
+    private final InstantiatorProvider2 instantiatorProvider;
+
+    private final AnnotationEngine annotationEngine =
+            new PluginLoader(pluginSwitch).loadPlugin(AnnotationEngine.class);
+
+    private final MockitoLogger mockitoLogger =
+            new PluginLoader(pluginSwitch).loadPlugin(MockitoLogger.class);
+
+    private final List<MockResolver> mockResolvers =
+            new PluginLoader(pluginSwitch).loadPlugins(MockResolver.class);
+
+    private final DoNotMockEnforcerWithType doNotMockEnforcer =
+            new PluginLoader(pluginSwitch)
+                    .loadPlugin(DoNotMockEnforcerWithType.class, DoNotMockEnforcer.class);
+
+    PluginRegistry() {
+        instantiatorProvider =
+                new PluginLoader(pluginSwitch).loadPlugin(InstantiatorProvider2.class);
+    }
+
+    /**
+     * The implementation of the stack trace cleaner
+     */
+    StackTraceCleanerProvider getStackTraceCleanerProvider() {
+        // TODO we should throw some sensible exception if this is null.
+        return stackTraceCleanerProvider;
+    }
+
+    /**
+     * Returns the implementation of the mock maker available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker} if no
+     * {@link org.mockito.plugins.MockMaker} extension exists or is visible in the current classpath.</p>
+     */
+    MockMaker getMockMaker() {
+        return mockMaker;
+    }
+
+    /**
+     * Returns the implementation of the member accessor available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.util.reflection.ReflectionMemberAccessor} if no
+     * {@link org.mockito.plugins.MockMaker} extension exists or is visible in the current classpath.</p>
+     */
+    MemberAccessor getMemberAccessor() {
+        return memberAccessor;
+    }
+
+    /**
+     * Returns the instantiator provider available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
+     * {@link org.mockito.plugins.InstantiatorProvider2} extension exists or is visible in the
+     * current classpath.</p>
+     */
+    InstantiatorProvider2 getInstantiatorProvider() {
+        return instantiatorProvider;
+    }
+
+    /**
+     * Returns the annotation engine available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.configuration.InjectingAnnotationEngine} if no
+     * {@link org.mockito.plugins.AnnotationEngine} extension exists or is visible in the current classpath.</p>
+     */
+    AnnotationEngine getAnnotationEngine() {
+        return annotationEngine;
+    }
+
+    /**
+     * Returns the logger available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.util.ConsoleMockitoLogger} if no
+     * {@link org.mockito.plugins.MockitoLogger} extension exists or is visible in the current classpath.</p>
+     */
+    MockitoLogger getMockitoLogger() {
+        return mockitoLogger;
+    }
+
+    /**
+     * Returns the DoNotMock enforce for the current runtime.
+     *
+     * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
+     * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
+     */
+    DoNotMockEnforcerWithType getDoNotMockEnforcer() {
+        return doNotMockEnforcer;
+    }
+
+    /**
+     * Returns a list of available mock resolvers if any.
+     *
+     * @return A list of available mock resolvers or an empty list if none are registered.
+     */
+    List<MockResolver> getMockResolvers() {
+        return mockResolvers;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
new file mode 100644
index 0000000000..66ca630304
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import java.util.List;
+
+import org.mockito.DoNotMock;
+import org.mockito.plugins.AnnotationEngine;
+import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
+import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MemberAccessor;
+import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockResolver;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.plugins.MockitoPlugins;
+import org.mockito.plugins.StackTraceCleanerProvider;
+
+/**
+ * Access to Mockito behavior that can be reconfigured by plugins
+ */
+public final class Plugins {
+
+    private static final PluginRegistry registry = new PluginRegistry();
+
+    /**
+     * The implementation of the stack trace cleaner
+     */
+    public static StackTraceCleanerProvider getStackTraceCleanerProvider() {
+        return registry.getStackTraceCleanerProvider();
+    }
+
+    /**
+     * Returns the implementation of the mock maker available for the current runtime.
+     *
+     * <p>Returns default mock maker if no
+     * {@link org.mockito.plugins.MockMaker} extension exists or is visible in the current classpath.</p>
+     */
+    public static MockMaker getMockMaker() {
+        return registry.getMockMaker();
+    }
+
+    /**
+     * Returns the implementation of the member accessor available for the current runtime.
+     *
+     * <p>Returns default member accessor if no
+     * {@link org.mockito.plugins.MemberAccessor} extension exists or is visible in the current classpath.</p>
+     */
+    public static MemberAccessor getMemberAccessor() {
+        return registry.getMemberAccessor();
+    }
+
+    /**
+     * Returns the instantiator provider available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
+     * {@link org.mockito.plugins.InstantiatorProvider2} extension exists or is visible in the
+     * current classpath.</p>
+     */
+    public static InstantiatorProvider2 getInstantiatorProvider() {
+        return registry.getInstantiatorProvider();
+    }
+
+    /**
+     * Returns the annotation engine available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.configuration.InjectingAnnotationEngine} if no
+     * {@link org.mockito.plugins.AnnotationEngine} extension exists or is visible in the current classpath.</p>
+     */
+    public static AnnotationEngine getAnnotationEngine() {
+        return registry.getAnnotationEngine();
+    }
+
+    /**
+     * Returns the logger available for the current runtime.
+     *
+     * <p>Returns {@link org.mockito.internal.util.ConsoleMockitoLogger} if no
+     * {@link org.mockito.plugins.MockitoLogger} extension exists or is visible in the current classpath.</p>
+     */
+    public static MockitoLogger getMockitoLogger() {
+        return registry.getMockitoLogger();
+    }
+
+    /**
+     * Returns a list of available mock resolvers if any.
+     *
+     * @return A list of available mock resolvers or an empty list if none are registered.
+     */
+    public static List<MockResolver> getMockResolvers() {
+        return registry.getMockResolvers();
+    }
+
+    /**
+     * @return instance of mockito plugins type
+     */
+    public static MockitoPlugins getPlugins() {
+        return new DefaultMockitoPlugins();
+    }
+
+    /**
+     * Returns the {@link DoNotMock} enforcer available for the current runtime.
+     *
+     * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
+     * {@link DoNotMockEnforcerWithType} or {@link DoNotMockEnforcer} extension exists or is visible
+     * in the current classpath.</p>
+     */
+    public static DoNotMockEnforcerWithType getDoNotMockEnforcer() {
+        return registry.getDoNotMockEnforcer();
+    }
+
+    private Plugins() {}
+}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/package-info.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/configuration/plugins/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/configuration/plugins/package-info.java
diff --git a/src/main/java/org/mockito/internal/creation/DelegatingMethod.java b/mockito-core/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
similarity index 95%
rename from src/main/java/org/mockito/internal/creation/DelegatingMethod.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
index 375bcb8db8..bb947ba76a 100644
--- a/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
@@ -20,30 +20,37 @@ public DelegatingMethod(Method method) {
         this.parameterTypes = SuspendMethod.trimSuspendParameterTypes(method.getParameterTypes());
     }
 
+    @Override
     public Class<?>[] getExceptionTypes() {
         return method.getExceptionTypes();
     }
 
+    @Override
     public Method getJavaMethod() {
         return method;
     }
 
+    @Override
     public String getName() {
         return method.getName();
     }
 
+    @Override
     public Class<?>[] getParameterTypes() {
         return parameterTypes;
     }
 
+    @Override
     public Class<?> getReturnType() {
         return method.getReturnType();
     }
 
+    @Override
     public boolean isVarArgs() {
         return method.isVarArgs();
     }
 
+    @Override
     public boolean isAbstract() {
         return (method.getModifiers() & Modifier.ABSTRACT) != 0;
     }
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java b/mockito-core/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
new file mode 100644
index 0000000000..4088efb307
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
@@ -0,0 +1,327 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation;
+
+import static java.util.Arrays.asList;
+
+import static org.mockito.internal.exceptions.Reporter.defaultAnswerDoesNotAcceptNullParameter;
+import static org.mockito.internal.exceptions.Reporter.extraInterfacesAcceptsOnlyInterfaces;
+import static org.mockito.internal.exceptions.Reporter.extraInterfacesDoesNotAcceptNullParameters;
+import static org.mockito.internal.exceptions.Reporter.extraInterfacesRequiresAtLeastOneInterface;
+import static org.mockito.internal.exceptions.Reporter.methodDoesNotAcceptParameter;
+import static org.mockito.internal.exceptions.Reporter.requiresAtLeastOneListener;
+import static org.mockito.internal.exceptions.Reporter.strictnessDoesNotAcceptNullParameter;
+import static org.mockito.internal.util.collections.Sets.newSet;
+
+import java.io.Serializable;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.MockSettings;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.debugging.VerboseMockInvocationLogger;
+import org.mockito.internal.util.Checks;
+import org.mockito.internal.util.MockCreationValidator;
+import org.mockito.internal.util.MockNameImpl;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.listeners.VerificationStartedListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
+import org.mockito.mock.SerializableMode;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
+
+@SuppressWarnings("unchecked")
+public class MockSettingsImpl<T> extends CreationSettings<T>
+        implements MockSettings, MockCreationSettings<T> {
+
+    private static final long serialVersionUID = 4475297236197939569L;
+    private boolean useConstructor;
+    private Object outerClassInstance;
+    private Object[] constructorArgs;
+
+    @Override
+    public MockSettings serializable() {
+        return serializable(SerializableMode.BASIC);
+    }
+
+    @Override
+    public MockSettings serializable(SerializableMode mode) {
+        this.serializableMode = mode;
+        return this;
+    }
+
+    @Override
+    public MockSettings extraInterfaces(Class<?>... extraInterfaces) {
+        if (extraInterfaces == null || extraInterfaces.length == 0) {
+            throw extraInterfacesRequiresAtLeastOneInterface();
+        }
+
+        for (Class<?> i : extraInterfaces) {
+            if (i == null) {
+                throw extraInterfacesDoesNotAcceptNullParameters();
+            } else if (!i.isInterface()) {
+                throw extraInterfacesAcceptsOnlyInterfaces(i);
+            }
+        }
+        this.extraInterfaces = newSet(extraInterfaces);
+        return this;
+    }
+
+    @Override
+    public MockName getMockName() {
+        return mockName;
+    }
+
+    @Override
+    public Set<Class<?>> getExtraInterfaces() {
+        return extraInterfaces;
+    }
+
+    @Override
+    public Object getSpiedInstance() {
+        return spiedInstance;
+    }
+
+    @Override
+    public MockSettings name(String name) {
+        this.name = name;
+        return this;
+    }
+
+    @Override
+    public MockSettings spiedInstance(Object spiedInstance) {
+        this.spiedInstance = spiedInstance;
+        return this;
+    }
+
+    @Override
+    public MockSettings defaultAnswer(Answer defaultAnswer) {
+        this.defaultAnswer = defaultAnswer;
+        if (defaultAnswer == null) {
+            throw defaultAnswerDoesNotAcceptNullParameter();
+        }
+        return this;
+    }
+
+    @Override
+    public Answer<Object> getDefaultAnswer() {
+        return defaultAnswer;
+    }
+
+    @Override
+    public MockSettingsImpl<T> stubOnly() {
+        this.stubOnly = true;
+        return this;
+    }
+
+    @Override
+    public MockSettings useConstructor(Object... constructorArgs) {
+        Checks.checkNotNull(
+                constructorArgs,
+                "constructorArgs",
+                "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
+        this.useConstructor = true;
+        this.constructorArgs = constructorArgs;
+        return this;
+    }
+
+    @Override
+    public MockSettings outerInstance(Object outerClassInstance) {
+        this.outerClassInstance = outerClassInstance;
+        return this;
+    }
+
+    @Override
+    public MockSettings withoutAnnotations() {
+        stripAnnotations = true;
+        return this;
+    }
+
+    @Override
+    public boolean isUsingConstructor() {
+        return useConstructor;
+    }
+
+    @Override
+    public Object getOuterClassInstance() {
+        return outerClassInstance;
+    }
+
+    @Override
+    public Object[] getConstructorArgs() {
+        if (outerClassInstance == null) {
+            return constructorArgs;
+        }
+        List<Object> resultArgs = new ArrayList<>(constructorArgs.length + 1);
+        resultArgs.add(outerClassInstance);
+        resultArgs.addAll(asList(constructorArgs));
+        return resultArgs.toArray(new Object[constructorArgs.length + 1]);
+    }
+
+    @Override
+    public boolean isStubOnly() {
+        return this.stubOnly;
+    }
+
+    @Override
+    public MockSettings verboseLogging() {
+        if (!invocationListenersContainsType(VerboseMockInvocationLogger.class)) {
+            invocationListeners(new VerboseMockInvocationLogger());
+        }
+        return this;
+    }
+
+    @Override
+    public MockSettings invocationListeners(InvocationListener... listeners) {
+        addListeners(listeners, invocationListeners, "invocationListeners");
+        return this;
+    }
+
+    @Override
+    public MockSettings stubbingLookupListeners(StubbingLookupListener... listeners) {
+        addListeners(listeners, stubbingLookupListeners, "stubbingLookupListeners");
+        return this;
+    }
+
+    static <T> void addListeners(T[] listeners, List<T> container, String method) {
+        if (listeners == null) {
+            throw methodDoesNotAcceptParameter(method, "null vararg array.");
+        }
+        if (listeners.length == 0) {
+            throw requiresAtLeastOneListener(method);
+        }
+        for (T listener : listeners) {
+            if (listener == null) {
+                throw methodDoesNotAcceptParameter(method, "null listeners.");
+            }
+            container.add(listener);
+        }
+    }
+
+    @Override
+    public MockSettings verificationStartedListeners(VerificationStartedListener... listeners) {
+        addListeners(listeners, this.verificationStartedListeners, "verificationStartedListeners");
+        return this;
+    }
+
+    private boolean invocationListenersContainsType(Class<?> clazz) {
+        for (InvocationListener listener : invocationListeners) {
+            if (listener.getClass().equals(clazz)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean hasInvocationListeners() {
+        return !getInvocationListeners().isEmpty();
+    }
+
+    @Override
+    public Class<T> getTypeToMock() {
+        return typeToMock;
+    }
+
+    @Override
+    public <T2> MockCreationSettings<T2> build(Class<T2> typeToMock) {
+        return validatedSettings(typeToMock, (CreationSettings<T2>) this);
+    }
+
+    @Override
+    public <T2> MockCreationSettings<T2> buildStatic(Class<T2> classToMock) {
+        return validatedStaticSettings(classToMock, (CreationSettings<T2>) this);
+    }
+
+    @Override
+    public MockSettings lenient() {
+        this.strictness = Strictness.LENIENT;
+        return this;
+    }
+
+    @Override
+    public MockSettings strictness(Strictness strictness) {
+        if (strictness == null) {
+            throw strictnessDoesNotAcceptNullParameter();
+        }
+        this.strictness = strictness;
+        return this;
+    }
+
+    @Override
+    public MockSettings mockMaker(String mockMaker) {
+        this.mockMaker = mockMaker;
+        return this;
+    }
+
+    @Override
+    public MockSettings genericTypeToMock(Type genericType) {
+        this.genericTypeToMock = genericType;
+        return this;
+    }
+
+    private static <T> CreationSettings<T> validatedSettings(
+            Class<T> typeToMock, CreationSettings<T> source) {
+        MockCreationValidator validator = new MockCreationValidator();
+
+        validator.validateType(typeToMock, source.getMockMaker());
+        validator.validateExtraInterfaces(typeToMock, source.getExtraInterfaces());
+        validator.validateMockedType(typeToMock, source.getSpiedInstance());
+
+        // TODO SF - add this validation and also add missing coverage
+        //        validator.validateDelegatedInstance(classToMock, settings.getDelegatedInstance());
+
+        validator.validateConstructorUse(source.isUsingConstructor(), source.getSerializableMode());
+
+        // TODO SF - I don't think we really need CreationSettings type
+        // TODO do we really need to copy the entire settings every time we create mock object? it
+        // does not seem necessary.
+        CreationSettings<T> settings = buildCreationSettings(typeToMock, source, MockType.INSTANCE);
+        settings.setExtraInterfaces(prepareExtraInterfaces(source));
+        return settings;
+    }
+
+    private static <T> CreationSettings<T> validatedStaticSettings(
+            Class<T> classToMock, CreationSettings<T> source) {
+
+        if (classToMock.isPrimitive()) {
+            throw new MockitoException(
+                    "Cannot create static mock of primitive type " + classToMock);
+        }
+        if (!source.getExtraInterfaces().isEmpty()) {
+            throw new MockitoException(
+                    "Cannot specify additional interfaces for static mock of " + classToMock);
+        }
+        if (source.getSpiedInstance() != null) {
+            throw new MockitoException(
+                    "Cannot specify spied instance for static mock of " + classToMock);
+        }
+
+        return buildCreationSettings(classToMock, source, MockType.STATIC);
+    }
+
+    private static <T> CreationSettings<T> buildCreationSettings(
+            Class<T> classToMock, CreationSettings<T> source, MockType mockType) {
+        CreationSettings<T> settings = new CreationSettings<>(source);
+        settings.setMockName(new MockNameImpl(source.getName(), classToMock, mockType));
+        settings.setTypeToMock(classToMock);
+        settings.setMockType(mockType);
+        return settings;
+    }
+
+    private static Set<Class<?>> prepareExtraInterfaces(CreationSettings settings) {
+        Set<Class<?>> interfaces = new HashSet<>(settings.getExtraInterfaces());
+        if (settings.isSerializable()) {
+            interfaces.add(Serializable.class);
+        }
+        return interfaces;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/creation/SuspendMethod.java b/mockito-core/src/main/java/org/mockito/internal/creation/SuspendMethod.java
similarity index 83%
rename from src/main/java/org/mockito/internal/creation/SuspendMethod.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/SuspendMethod.java
index 42ceac66ee..1bb6e0a9d9 100644
--- a/src/main/java/org/mockito/internal/creation/SuspendMethod.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/SuspendMethod.java
@@ -10,14 +10,16 @@
  * Utilities for Kotlin Continuation-Passing-Style suspending function, detecting and trimming last hidden parameter.
  * See <a href="https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#continuation-passing-style">Design docs for details</a>.
  */
-public class SuspendMethod {
-    private static final String KOTLIN_EXPERIMENTAL_CONTINUATION = "kotlin.coroutines.experimental.Continuation";
+public final class SuspendMethod {
+    private static final String KOTLIN_EXPERIMENTAL_CONTINUATION =
+            "kotlin.coroutines.experimental.Continuation";
     private static final String KOTLIN_CONTINUATION = "kotlin.coroutines.Continuation";
 
     public static Class<?>[] trimSuspendParameterTypes(Class<?>[] parameterTypes) {
         int n = parameterTypes.length;
-        if (n > 0 && isContinuationType(parameterTypes[n - 1]))
+        if (n > 0 && isContinuationType(parameterTypes[n - 1])) {
             return Arrays.copyOf(parameterTypes, n - 1);
+        }
         return parameterTypes;
     }
 
@@ -25,4 +27,6 @@ private static boolean isContinuationType(Class<?> parameterType) {
         String name = parameterType.getName();
         return name.equals(KOTLIN_CONTINUATION) || name.equals(KOTLIN_EXPERIMENTAL_CONTINUATION);
     }
+
+    private SuspendMethod() {}
 }
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
similarity index 75%
rename from src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
index 789072832f..047d357bc2 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
@@ -4,24 +4,33 @@
  */
 package org.mockito.internal.creation.bytebuddy;
 
-import static org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.ForWriteReplace;
+import static org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor.ForWriteReplace;
 import static org.mockito.internal.util.StringUtil.join;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamClass;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.util.Set;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
-import org.mockito.Incubating;
 import org.mockito.exceptions.base.MockitoSerializationIssue;
 import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor;
 import org.mockito.internal.creation.settings.CreationSettings;
 import org.mockito.internal.util.MockUtil;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
 import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MemberAccessor;
 
 /**
  * This is responsible for serializing a mock, it is enabled if the mock is implementing {@link Serializable}.
@@ -46,12 +55,11 @@
  * TODO check the class is mockable in the deserialization side
  *
  * @see SubclassByteBuddyMockMaker
- * @see org.mockito.internal.creation.bytebuddy.MockMethodInterceptor
+ * @see MockMethodInterceptor
  * @author Brice Dutheil
  * @since 1.10.0
  */
-@Incubating
-class ByteBuddyCrossClassLoaderSerializationSupport implements Serializable {
+public class ByteBuddyCrossClassLoaderSerializationSupport implements Serializable {
     private static final long serialVersionUID = 7411152578314420778L;
     private static final String MOCKITO_PROXY_MARKER = "ByteBuddyMockitoProxyMarker";
     private boolean instanceLocalCurrentlySerializingFlag = false;
@@ -114,12 +122,16 @@ public Object writeReplace(Object mockitoMock) throws ObjectStreamException {
             return new CrossClassLoaderSerializationProxy(mockitoMock);
         } catch (IOException ioe) {
             MockName mockName = MockUtil.getMockName(mockitoMock);
-            String mockedType = MockUtil.getMockSettings(mockitoMock).getTypeToMock().getCanonicalName();
-            throw new MockitoSerializationIssue(join(
-                    "The mock '" + mockName + "' of type '" + mockedType + "'",
-                    "The Java Standard Serialization reported an '" + ioe.getClass().getSimpleName() + "' saying :",
-                    "  " + ioe.getMessage()
-            ), ioe);
+            String mockedType =
+                    MockUtil.getMockSettings(mockitoMock).getTypeToMock().getCanonicalName();
+            throw new MockitoSerializationIssue(
+                    join(
+                            "The mock '" + mockName + "' of type '" + mockedType + "'",
+                            "The Java Standard Serialization reported an '"
+                                    + ioe.getClass().getSimpleName()
+                                    + "' saying :",
+                            "  " + ioe.getMessage()),
+                    ioe);
         } finally {
             // unmark
             mockReplacementCompleted();
@@ -127,17 +139,14 @@ public Object writeReplace(Object mockitoMock) throws ObjectStreamException {
         }
     }
 
-
     private void mockReplacementCompleted() {
         instanceLocalCurrentlySerializingFlag = false;
     }
 
-
     private void mockReplacementStarted() {
         instanceLocalCurrentlySerializingFlag = true;
     }
 
-
     private boolean mockIsCurrentlyBeingReplaced() {
         return instanceLocalCurrentlySerializingFlag;
     }
@@ -192,10 +201,12 @@ public CrossClassLoaderSerializationProxy(Object mockitoMock) throws IOException
          * @return A deserialized instance of the Mockito mock.
          * @throws java.io.ObjectStreamException
          */
+        @SuppressWarnings("BanSerializableRead")
         private Object readResolve() throws ObjectStreamException {
             try {
                 ByteArrayInputStream bis = new ByteArrayInputStream(serializedMock);
-                ObjectInputStream objectInputStream = new MockitoMockObjectInputStream(bis, typeToMock, extraInterfaces);
+                ObjectInputStream objectInputStream =
+                        new MockitoMockObjectInputStream(bis, typeToMock, extraInterfaces);
 
                 Object deserializedMock = objectInputStream.readObject();
 
@@ -204,22 +215,25 @@ private Object readResolve() throws ObjectStreamException {
 
                 return deserializedMock;
             } catch (IOException ioe) {
-                throw new MockitoSerializationIssue(join(
-                        "Mockito mock cannot be deserialized to a mock of '" + typeToMock.getCanonicalName() + "'. The error was :",
-                        "  " + ioe.getMessage(),
-                        "If you are unsure what is the reason of this exception, feel free to contact us on the mailing list."
-                ), ioe);
+                throw new MockitoSerializationIssue(
+                        join(
+                                "Mockito mock cannot be deserialized to a mock of '"
+                                        + typeToMock.getCanonicalName()
+                                        + "'. The error was :",
+                                "  " + ioe.getMessage(),
+                                "If you are unsure what is the reason of this exception, feel free to open an issue on GitHub."),
+                        ioe);
             } catch (ClassNotFoundException cce) {
-                throw new MockitoSerializationIssue(join(
-                        "A class couldn't be found while deserializing a Mockito mock, you should check your classpath. The error was :",
-                        "  " + cce.getMessage(),
-                        "If you are still unsure what is the reason of this exception, feel free to contact us on the mailing list."
-                ), cce);
+                throw new MockitoSerializationIssue(
+                        join(
+                                "A class couldn't be found while deserializing a Mockito mock, you should check your classpath. The error was :",
+                                "  " + cce.getMessage(),
+                                "If you are still unsure what is the reason of this exception, feel free to open an issue on GitHub."),
+                        cce);
             }
         }
     }
 
-
     /**
      * Special Mockito aware <code>ObjectInputStream</code> that will resolve the Mockito proxy class.
      * <p/>
@@ -240,7 +254,9 @@ public static class MockitoMockObjectInputStream extends ObjectInputStream {
         private final Class<?> typeToMock;
         private final Set<Class<?>> extraInterfaces;
 
-        public MockitoMockObjectInputStream(InputStream in, Class<?> typeToMock, Set<Class<?>> extraInterfaces) throws IOException {
+        public MockitoMockObjectInputStream(
+                InputStream in, Class<?> typeToMock, Set<Class<?>> extraInterfaces)
+                throws IOException {
             super(in);
             this.typeToMock = typeToMock;
             this.extraInterfaces = extraInterfaces;
@@ -260,7 +276,9 @@ public MockitoMockObjectInputStream(InputStream in, Class<?> typeToMock, Set<Cla
          * @throws ClassNotFoundException
          */
         @Override
-        protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
+        @SuppressWarnings("BanSerializableRead")
+        protected Class<?> resolveClass(ObjectStreamClass desc)
+                throws IOException, ClassNotFoundException {
             if (notMarkedAsAMockitoMock(readObject())) {
                 return super.resolveClass(desc);
             }
@@ -268,20 +286,24 @@ protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, Clas
             // create the Mockito mock class before it can even be deserialized
             try {
                 @SuppressWarnings("unchecked")
-                Class<?> proxyClass = ((ClassCreatingMockMaker) Plugins.getMockMaker()).createMockType(
-                        new CreationSettings()
-                                .setTypeToMock(typeToMock)
-                                .setExtraInterfaces(extraInterfaces)
-                                .setSerializableMode(SerializableMode.ACROSS_CLASSLOADERS));
+                Class<?> proxyClass =
+                        ((ClassCreatingMockMaker) Plugins.getMockMaker())
+                                .createMockType(
+                                        new CreationSettings()
+                                                .setTypeToMock(typeToMock)
+                                                .setExtraInterfaces(extraInterfaces)
+                                                .setSerializableMode(
+                                                        SerializableMode.ACROSS_CLASSLOADERS));
 
                 hackClassNameToMatchNewlyCreatedClass(desc, proxyClass);
                 return proxyClass;
             } catch (ClassCastException cce) {
-                throw new MockitoSerializationIssue(join(
-                        "A Byte Buddy-generated mock cannot be deserialized into a non-Byte Buddy generated mock class",
-                        "",
-                        "The mock maker in use was: " + Plugins.getMockMaker().getClass()
-                ), cce);
+                throw new MockitoSerializationIssue(
+                        join(
+                                "A Byte Buddy-generated mock cannot be deserialized into a non-Byte Buddy generated mock class",
+                                "",
+                                "The mock maker in use was: " + Plugins.getMockMaker().getClass()),
+                        cce);
             }
         }
 
@@ -303,17 +325,25 @@ protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, Clas
          * @param proxyClass   The proxy class whose name will be applied.
          * @throws java.io.InvalidObjectException
          */
-        private void hackClassNameToMatchNewlyCreatedClass(ObjectStreamClass descInstance, Class<?> proxyClass) throws ObjectStreamException {
+        private void hackClassNameToMatchNewlyCreatedClass(
+                ObjectStreamClass descInstance, Class<?> proxyClass) throws ObjectStreamException {
             try {
+                MemberAccessor accessor = Plugins.getMemberAccessor();
                 Field classNameField = descInstance.getClass().getDeclaredField("name");
-                setField(descInstance, classNameField,proxyClass.getCanonicalName());
+                try {
+                    accessor.set(classNameField, descInstance, proxyClass.getCanonicalName());
+                } catch (IllegalAccessException e) {
+                    throw new MockitoSerializationIssue(
+                            "Access to " + classNameField + " was denied", e);
+                }
             } catch (NoSuchFieldException nsfe) {
-                throw new MockitoSerializationIssue(join(
-                        "Wow, the class 'ObjectStreamClass' in the JDK don't have the field 'name',",
-                        "this is definitely a bug in our code as it means the JDK team changed a few internal things.",
-                        "",
-                        "Please report an issue with the JDK used, a code sample and a link to download the JDK would be welcome."
-                ), nsfe);
+                throw new MockitoSerializationIssue(
+                        join(
+                                "Wow, the class 'ObjectStreamClass' in the JDK don't have the field 'name',",
+                                "this is definitely a bug in our code as it means the JDK team changed a few internal things.",
+                                "",
+                                "Please report an issue with the JDK used, a code sample and a link to download the JDK would be welcome."),
+                        nsfe);
             }
         }
 
@@ -328,7 +358,6 @@ private boolean notMarkedAsAMockitoMock(Object marker) {
         }
     }
 
-
     /**
      * Special Mockito aware <code>ObjectOutputStream</code>.
      * <p/>
@@ -374,7 +403,6 @@ private String mockitoProxyClassMarker(Class<?> cl) {
         }
     }
 
-
     /**
      * Simple interface that hold a correct <code>writeReplace</code> signature that can be seen by an
      * <code>ObjectOutputStream</code>.
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
new file mode 100644
index 0000000000..9a836bbbb1
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import org.mockito.MockedConstruction;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+/**
+ * ByteBuddy MockMaker.
+ *
+ * This class will serve as the programmatic entry point to all mockito internal MockMakers.
+ * Currently the default mock maker is the inlining engine.
+ *
+ * The programmatic API could look like {@code mock(Final.class, withSettings().finalClasses())}.
+ */
+public class ByteBuddyMockMaker implements ClassCreatingMockMaker {
+    private final SubclassByteBuddyMockMaker subclassByteBuddyMockMaker;
+
+    public ByteBuddyMockMaker() {
+        try {
+            subclassByteBuddyMockMaker = new SubclassByteBuddyMockMaker();
+        } catch (NoClassDefFoundError e) {
+            Reporter.missingByteBuddyDependency(e);
+            throw e;
+        }
+    }
+
+    ByteBuddyMockMaker(SubclassByteBuddyMockMaker subclassByteBuddyMockMaker) {
+        this.subclassByteBuddyMockMaker = subclassByteBuddyMockMaker;
+    }
+
+    @Override
+    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+        return subclassByteBuddyMockMaker.createMock(settings, handler);
+    }
+
+    @Override
+    public <T> Optional<T> createSpy(
+            MockCreationSettings<T> settings, MockHandler handler, T object) {
+        return subclassByteBuddyMockMaker.createSpy(settings, handler, object);
+    }
+
+    @Override
+    public <T> Class<? extends T> createMockType(MockCreationSettings<T> creationSettings) {
+        return subclassByteBuddyMockMaker.createMockType(creationSettings);
+    }
+
+    @Override
+    public MockHandler getHandler(Object mock) {
+        return subclassByteBuddyMockMaker.getHandler(mock);
+    }
+
+    @Override
+    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+        subclassByteBuddyMockMaker.resetMock(mock, newHandler, settings);
+    }
+
+    @Override
+    public TypeMockability isTypeMockable(Class<?> type) {
+        return subclassByteBuddyMockMaker.isTypeMockable(type);
+    }
+
+    @Override
+    public <T> StaticMockControl<T> createStaticMock(
+            Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+        return subclassByteBuddyMockMaker.createStaticMock(type, settings, handler);
+    }
+
+    @Override
+    public <T> ConstructionMockControl<T> createConstructionMock(
+            Class<T> type,
+            Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+            Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        return subclassByteBuddyMockMaker.createConstructionMock(
+                type, settingsFactory, handlerFactory, mockInitializer);
+    }
+
+    @Override
+    public void clearAllCaches() {
+        subclassByteBuddyMockMaker.clearAllCaches();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
new file mode 100644
index 0000000000..5040c17573
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+import static net.bytebuddy.matcher.ElementMatchers.*;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+public interface BytecodeGenerator {
+
+    <T> Class<? extends T> mockClass(MockFeatures<T> features);
+
+    void mockClassConstruction(Class<?> type);
+
+    void mockClassStatic(Class<?> type);
+
+    default void clearAllCaches() {}
+
+    static ElementMatcher<MethodDescription> isGroovyMethod(boolean inline) {
+        ElementMatcher.Junction<MethodDescription> matcher =
+                isDeclaredBy(named("groovy.lang.GroovyObjectSupport"))
+                        .or(isAnnotatedWith(named("groovy.transform.Internal")));
+        if (inline) {
+            return matcher.or(
+                    named("$getStaticMetaClass").and(returns(named("groovy.lang.MetaClass"))));
+        } else {
+            return matcher;
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ClassCreatingMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ClassCreatingMockMaker.java
similarity index 100%
rename from src/main/java/org/mockito/internal/creation/bytebuddy/ClassCreatingMockMaker.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ClassCreatingMockMaker.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ConstructionCallback.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ConstructionCallback.java
new file mode 100644
index 0000000000..ac8ecc4040
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ConstructionCallback.java
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+public interface ConstructionCallback {
+
+    Object apply(Class<?> type, Object object, Object[] arguments, String[] parameterTypeNames);
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
new file mode 100644
index 0000000000..acfddfef34
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import org.mockito.MockedConstruction;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InlineMockMaker;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+public class InlineByteBuddyMockMaker
+        implements ClassCreatingMockMaker, InlineMockMaker, Instantiator {
+    private final InlineDelegateByteBuddyMockMaker inlineDelegateByteBuddyMockMaker;
+
+    public InlineByteBuddyMockMaker() {
+        try {
+            inlineDelegateByteBuddyMockMaker = new InlineDelegateByteBuddyMockMaker();
+        } catch (NoClassDefFoundError e) {
+            Reporter.missingByteBuddyDependency(e);
+            throw e;
+        }
+    }
+
+    InlineByteBuddyMockMaker(InlineDelegateByteBuddyMockMaker inlineDelegateByteBuddyMockMaker) {
+        this.inlineDelegateByteBuddyMockMaker = inlineDelegateByteBuddyMockMaker;
+    }
+
+    @Override
+    public <T> T newInstance(Class<T> cls) {
+        return inlineDelegateByteBuddyMockMaker.newInstance(cls);
+    }
+
+    @Override
+    public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
+        return inlineDelegateByteBuddyMockMaker.createMockType(settings);
+    }
+
+    @Override
+    public void clearMock(Object mock) {
+        inlineDelegateByteBuddyMockMaker.clearMock(mock);
+    }
+
+    @Override
+    public void clearAllMocks() {
+        inlineDelegateByteBuddyMockMaker.clearAllMocks();
+    }
+
+    @Override
+    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+        return inlineDelegateByteBuddyMockMaker.createMock(settings, handler);
+    }
+
+    @Override
+    public <T> Optional<T> createSpy(
+            MockCreationSettings<T> settings, MockHandler handler, T instance) {
+        return inlineDelegateByteBuddyMockMaker.createSpy(settings, handler, instance);
+    }
+
+    @Override
+    public MockHandler getHandler(Object mock) {
+        return inlineDelegateByteBuddyMockMaker.getHandler(mock);
+    }
+
+    @Override
+    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+        inlineDelegateByteBuddyMockMaker.resetMock(mock, newHandler, settings);
+    }
+
+    @Override
+    public TypeMockability isTypeMockable(Class<?> type) {
+        return inlineDelegateByteBuddyMockMaker.isTypeMockable(type);
+    }
+
+    @Override
+    public <T> StaticMockControl<T> createStaticMock(
+            Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+        return inlineDelegateByteBuddyMockMaker.createStaticMock(type, settings, handler);
+    }
+
+    @Override
+    public <T> ConstructionMockControl<T> createConstructionMock(
+            Class<T> type,
+            Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+            Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        return inlineDelegateByteBuddyMockMaker.createConstructionMock(
+                type, settingsFactory, handlerFactory, mockInitializer);
+    }
+
+    @Override
+    public void clearAllCaches() {
+        inlineDelegateByteBuddyMockMaker.clearAllCaches();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
new file mode 100644
index 0000000000..3f32b93abc
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
@@ -0,0 +1,514 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.field.FieldDescription;
+import net.bytebuddy.description.field.FieldList;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.method.MethodList;
+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;
+import net.bytebuddy.jar.asm.MethodVisitor;
+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.SuppressSignatureCheck;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor;
+import org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher;
+import org.mockito.internal.util.concurrent.DetachedThreadLocal;
+import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import org.mockito.internal.util.concurrent.WeakConcurrentSet;
+import org.mockito.mock.SerializableMode;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.Instrumentation;
+import java.lang.instrument.UnmodifiableClassException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.security.ProtectionDomain;
+import java.util.*;
+import java.util.function.Predicate;
+
+import static net.bytebuddy.implementation.MethodDelegation.withDefaultConfiguration;
+import static net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant.of;
+import static net.bytebuddy.matcher.ElementMatchers.*;
+import static org.mockito.internal.util.StringUtil.join;
+
+@SuppressSignatureCheck
+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,
+                            Byte.class,
+                            Short.class,
+                            Character.class,
+                            Integer.class,
+                            Long.class,
+                            Float.class,
+                            Double.class,
+                            String.class));
+
+    private final Instrumentation instrumentation;
+
+    private final ByteBuddy byteBuddy;
+
+    private final WeakConcurrentSet<Class<?>> mocked, flatMocked;
+
+    private final BytecodeGenerator subclassEngine;
+
+    private final AsmVisitorWrapper mockTransformer;
+
+    private final Method getModule, canRead, redefineModule;
+
+    private volatile Throwable lastException;
+
+    public InlineBytecodeGenerator(
+            Instrumentation instrumentation,
+            WeakConcurrentMap<Object, MockMethodInterceptor> mocks,
+            DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics,
+            Predicate<Class<?>> isMockConstruction,
+            ConstructionCallback onConstruction) {
+        preload();
+        this.instrumentation = instrumentation;
+        byteBuddy =
+                new ByteBuddy()
+                        .with(TypeValidation.DISABLED)
+                        .with(Implementation.Context.Disabled.Factory.INSTANCE)
+                        .with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE)
+                        .ignore(isSynthetic().and(not(isConstructor())).or(isDefaultFinalizer()));
+        mocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.MANUAL);
+        flatMocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.MANUAL);
+        String identifier = RandomString.make();
+        subclassEngine =
+                new TypeCachingBytecodeGenerator(
+                        new SubclassBytecodeGenerator(
+                                ModuleHandler.make(instrumentation),
+                                withDefaultConfiguration()
+                                        .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()))
+                                                        .and(
+                                                                not(
+                                                                        BytecodeGenerator
+                                                                                .isGroovyMethod(
+                                                                                        true)))),
+                                Advice.withCustomMapping()
+                                        .bind(MockMethodAdvice.Identifier.class, identifier)
+                                        .to(MockMethodAdvice.class))
+                        .method(
+                                isStatic().and(not(BytecodeGenerator.isGroovyMethod(true))),
+                                Advice.withCustomMapping()
+                                        .bind(MockMethodAdvice.Identifier.class, identifier)
+                                        .to(MockMethodAdvice.ForStatic.class))
+                        .constructor(any(), new MockMethodAdvice.ConstructorShortcut(identifier))
+                        .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));
+        Method getModule, canRead, redefineModule;
+        try {
+            getModule = Class.class.getMethod("getModule");
+            canRead = getModule.getReturnType().getMethod("canRead", getModule.getReturnType());
+            redefineModule =
+                    Instrumentation.class.getMethod(
+                            "redefineModule",
+                            getModule.getReturnType(),
+                            Set.class,
+                            Map.class,
+                            Map.class,
+                            Set.class,
+                            Map.class);
+        } catch (Exception ignored) {
+            getModule = null;
+            canRead = null;
+            redefineModule = null;
+        }
+        this.getModule = getModule;
+        this.canRead = canRead;
+        this.redefineModule = redefineModule;
+        MockMethodDispatcher.set(
+                identifier,
+                new MockMethodAdvice(
+                        mocks, mockedStatics, identifier, isMockConstruction, onConstruction));
+        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
+                        || features.stripAnnotations
+                        || Modifier.isAbstract(features.mockedType.getModifiers());
+
+        checkSupportedCombination(subclassingRequired, features);
+
+        Set<Class<?>> types = new HashSet<>();
+        types.add(features.mockedType);
+        types.addAll(features.interfaces);
+
+        synchronized (this) {
+            triggerRetransformation(types, false);
+        }
+
+        return subclassingRequired ? subclassEngine.mockClass(features) : features.mockedType;
+    }
+
+    @Override
+    public synchronized void mockClassStatic(Class<?> type) {
+        triggerRetransformation(Collections.singleton(type), true);
+    }
+
+    @Override
+    public synchronized void mockClassConstruction(Class<?> type) {
+        triggerRetransformation(Collections.singleton(type), false);
+    }
+
+    private static void assureInitialization(Class<?> type) {
+        try {
+            Class.forName(type.getName(), true, type.getClassLoader());
+        } catch (Error error) {
+            Throwable ex = error;
+            if (ex instanceof ExceptionInInitializerError) {
+                ex = ((ExceptionInInitializerError) ex).getException();
+            }
+            throw new MockitoException(
+                    "Cannot instrument "
+                            + type
+                            + " because it or one of its supertypes could not be initialized",
+                    ex);
+        } catch (Throwable ignored) {
+        }
+    }
+
+    private <T> void triggerRetransformation(Set<Class<?>> types, boolean flat) {
+        Set<Class<?>> targets = new HashSet<Class<?>>();
+
+        try {
+            for (Class<?> type : types) {
+                if (flat) {
+                    if (!mocked.contains(type) && flatMocked.add(type)) {
+                        assureInitialization(type);
+                        targets.add(type);
+                    }
+                } else {
+                    do {
+                        if (mocked.add(type)) {
+                            if (!flatMocked.remove(type)) {
+                                assureInitialization(type);
+                                targets.add(type);
+                            }
+                            addInterfaces(targets, type.getInterfaces());
+                        }
+                        type = type.getSuperclass();
+                    } while (type != null);
+                }
+            }
+        } catch (Throwable t) {
+            for (Class<?> target : targets) {
+                mocked.remove(target);
+                flatMocked.remove(target);
+            }
+            throw t;
+        }
+
+        if (!targets.isEmpty()) {
+            try {
+                assureCanReadMockito(targets);
+                instrumentation.retransformClasses(targets.toArray(new Class<?>[targets.size()]));
+                Throwable throwable = lastException;
+                if (throwable != null) {
+                    throw new IllegalStateException(
+                            join(
+                                    "Byte Buddy could not instrument all classes within the mock's type hierarchy",
+                                    "",
+                                    "This problem should never occur for javac-compiled classes. This problem has been observed for classes that are:",
+                                    " - Compiled by older versions of scalac",
+                                    " - Classes that are part of the Android distribution"),
+                            throwable);
+                }
+            } catch (Exception exception) {
+                for (Class<?> failed : targets) {
+                    mocked.remove(failed);
+                    flatMocked.remove(failed);
+                }
+                throw new MockitoException("Could not modify all classes " + targets, exception);
+            } finally {
+                lastException = null;
+            }
+        }
+
+        mocked.expungeStaleEntries();
+        flatMocked.expungeStaleEntries();
+    }
+
+    private void assureCanReadMockito(Set<Class<?>> types) {
+        if (redefineModule == null) {
+            return;
+        }
+        Set<Object> modules = new HashSet<Object>();
+        try {
+            Object target =
+                    getModule.invoke(
+                            Class.forName(
+                                    "org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher",
+                                    false,
+                                    null));
+            for (Class<?> type : types) {
+                Object module = getModule.invoke(type);
+                if (!modules.contains(module) && !(Boolean) canRead.invoke(module, target)) {
+                    modules.add(module);
+                }
+            }
+            for (Object module : modules) {
+                redefineModule.invoke(
+                        instrumentation,
+                        module,
+                        Collections.singleton(target),
+                        Collections.emptyMap(),
+                        Collections.emptyMap(),
+                        Collections.emptySet(),
+                        Collections.emptyMap());
+            }
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                    join(
+                            "Could not adjust module graph to make the mock instance dispatcher visible to some classes",
+                            "",
+                            "At least one of those modules: "
+                                    + modules
+                                    + " is not reading the unnamed module of the bootstrap loader",
+                            "Without such a read edge, the classes that are redefined to become mocks cannot access the mock dispatcher.",
+                            "To circumvent this, Mockito attempted to add a read edge to this module what failed for an unexpected reason"),
+                    e);
+        }
+    }
+
+    private <T> void checkSupportedCombination(
+            boolean subclassingRequired, MockFeatures<T> features) {
+        if (subclassingRequired
+                && !features.mockedType.isArray()
+                && !features.mockedType.isPrimitive()
+                && (Modifier.isFinal(features.mockedType.getModifiers())
+                        || TypeSupport.INSTANCE.isSealed(features.mockedType)
+                        || features.interfaces.stream().anyMatch(TypeSupport.INSTANCE::isSealed))) {
+            throw new MockitoException(
+                    "Unsupported settings with this type '" + features.mockedType.getName() + "'");
+        }
+    }
+
+    private void addInterfaces(Set<Class<?>> types, Class<?>[] interfaces) {
+        for (Class<?> type : interfaces) {
+            if (mocked.add(type)) {
+                if (!flatMocked.remove(type)) {
+                    assureInitialization(type);
+                    types.add(type);
+                }
+                addInterfaces(types, type.getInterfaces());
+            }
+        }
+    }
+
+    @Override
+    public byte[] transform(
+            ClassLoader loader,
+            String className,
+            Class<?> classBeingRedefined,
+            ProtectionDomain protectionDomain,
+            byte[] classfileBuffer) {
+        if (classBeingRedefined == null
+                || !mocked.contains(classBeingRedefined)
+                        && !flatMocked.contains(classBeingRedefined)
+                || EXCLUDES.contains(classBeingRedefined)) {
+            return null;
+        } else {
+            try {
+                return byteBuddy
+                        .redefine(
+                                classBeingRedefined,
+                                //        new ClassFileLocator.Compound(
+                                ClassFileLocator.Simple.of(
+                                        classBeingRedefined.getName(), classfileBuffer)
+                                //            ,ClassFileLocator.ForClassLoader.ofSystemLoader()
+                                //        )
+                                )
+                        // 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;
+            }
+        }
+    }
+
+    @Override
+    public synchronized void clearAllCaches() {
+        Set<Class<?>> types = new HashSet<>();
+        mocked.forEach(types::add);
+        if (types.isEmpty()) {
+            return;
+        }
+        mocked.clear();
+        flatMocked.clear();
+        subclassEngine.clearAllCaches();
+        try {
+            instrumentation.retransformClasses(types.toArray(new Class<?>[0]));
+        } catch (UnmodifiableClassException e) {
+            throw new MockitoException(
+                    join(
+                            "Failed to reset mocks.",
+                            "",
+                            "This should not influence the working of Mockito.",
+                            "But if the reset intends to remove mocking code to improve performance, it is still impacted."),
+                    e);
+        }
+    }
+
+    private static class ParameterWritingVisitorWrapper extends AsmVisitorWrapper.AbstractBase {
+
+        private final Class<?> type;
+
+        private ParameterWritingVisitorWrapper(Class<?> type) {
+            this.type = type;
+        }
+
+        @Override
+        public ClassVisitor wrap(
+                TypeDescription instrumentedType,
+                ClassVisitor classVisitor,
+                Implementation.Context implementationContext,
+                TypePool typePool,
+                FieldList<FieldDescription.InDefinedShape> fields,
+                MethodList<?> methods,
+                int writerFlags,
+                int readerFlags) {
+            return implementationContext.getClassFileVersion().isAtLeast(ClassFileVersion.JAVA_V8)
+                    ? new ParameterAddingClassVisitor(
+                            classVisitor, new TypeDescription.ForLoadedType(type))
+                    : classVisitor;
+        }
+
+        private static class ParameterAddingClassVisitor extends ClassVisitor {
+
+            private final TypeDescription typeDescription;
+
+            private ParameterAddingClassVisitor(ClassVisitor cv, TypeDescription typeDescription) {
+                super(OpenedClassReader.ASM_API, cv);
+                this.typeDescription = typeDescription;
+            }
+
+            @Override
+            public MethodVisitor visitMethod(
+                    int access, String name, String desc, String signature, String[] exceptions) {
+                MethodVisitor methodVisitor =
+                        super.visitMethod(access, name, desc, signature, exceptions);
+                MethodList<?> methodList =
+                        typeDescription
+                                .getDeclaredMethods()
+                                .filter(
+                                        (name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME)
+                                                        ? isConstructor()
+                                                        : ElementMatchers.<MethodDescription>named(
+                                                                name))
+                                                .and(hasDescriptor(desc)));
+                if (methodList.size() == 1
+                        && methodList.getOnly().getParameters().hasExplicitMetaData()) {
+                    for (ParameterDescription parameterDescription :
+                            methodList.getOnly().getParameters()) {
+                        methodVisitor.visitParameter(
+                                parameterDescription.getName(),
+                                parameterDescription.getModifiers());
+                    }
+                    return new MethodParameterStrippingMethodVisitor(methodVisitor);
+                } else {
+                    return methodVisitor;
+                }
+            }
+        }
+
+        private static class MethodParameterStrippingMethodVisitor extends MethodVisitor {
+
+            public MethodParameterStrippingMethodVisitor(MethodVisitor mv) {
+                super(OpenedClassReader.ASM_API, mv);
+            }
+
+            @Override
+            public void visitParameter(String name, int access) {
+                // suppress to avoid additional writing of the parameter if retained.
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
new file mode 100644
index 0000000000..e05847f08f
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
@@ -0,0 +1,944 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import org.mockito.MockedConstruction;
+import org.mockito.creation.instance.InstantiationException;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.base.MockitoInitializationException;
+import org.mockito.exceptions.misusing.MockitoConfigurationException;
+import org.mockito.internal.PremainAttachAccess;
+import org.mockito.internal.SuppressSignatureCheck;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor;
+import org.mockito.internal.creation.instance.ConstructorInstantiator;
+import org.mockito.internal.framework.DisabledMockHandler;
+import org.mockito.internal.util.Platform;
+import org.mockito.internal.util.concurrent.DetachedThreadLocal;
+import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InlineMockMaker;
+import org.mockito.plugins.MemberAccessor;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.instrument.Instrumentation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+
+import static org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.EXCLUDES;
+import static org.mockito.internal.util.StringUtil.join;
+
+/**
+ * Agent and subclass based mock maker.
+ * <p>
+ * This mock maker uses a combination of the Java instrumentation API and sub-classing rather than creating
+ * a new sub-class to create a mock. This way, it becomes possible to mock final types and methods. This mock
+ * maker <strong>must be activated explicitly</strong> for supporting mocking final types and methods:
+ * <p>
+ * <p>
+ * This mock maker can be activated by creating the file <code>/mockito-extensions/org.mockito.plugins.MockMaker</code>
+ * containing the text <code>mock-maker-inline</code> or <code>org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker</code>.
+ * <p>
+ * <p>
+ * This mock maker will make a best effort to avoid subclass creation when creating a mock. Otherwise it will use the
+ * <code>org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker</code> to create the mock class. That means
+ * that the following condition is true
+ * <p>
+ * <pre class="code"><code class="java">
+ * class Foo { }
+ * assert mock(Foo.class).getClass() == Foo.class;
+ * </pre></code>
+ * <p>
+ * unless any of the following conditions is met, in such case the mock maker <em>falls back</em> to
+ * the creation of a subclass.
+ * <p>
+ * <ul>
+ * <li>the type to mock is an abstract class.</li>
+ * <li>the mock is set to require additional interfaces.</li>
+ * <li>the mock is <a href="#20">explicitly set to support serialization</a>.</li>
+ * </ul>
+ * <p>
+ * <p>
+ * Some type of the JDK cannot be mocked, this includes <code>Class</code>, <code>String</code>, and wrapper types.
+ * <p>
+ * <p>
+ * Nevertheless, final methods of such types are mocked when using the inlining mock maker. Mocking final types and enums
+ * does however remain impossible when explicitly requiring serialization support or when adding ancillary interfaces.
+ * <p>
+ * <p>
+ * Important behavioral changes when using inline-mocks:
+ * <ul>
+ * <li>Mockito is capable of mocking package-private methods even if they are defined in different packages than
+ * the mocked type. Mockito voluntarily never mocks package-visible methods within <code>java.*</code> packages.</li>
+ * <li>Additionally to final types, Mockito can now mock types that are not visible for extension; such types
+ * include private types in a protected package.</li>
+ * <li>Mockito can no longer mock <code>native</code> methods. Inline mocks require byte code manipulation of a
+ * method where native methods do not offer any byte code to manipulate.</li>
+ * <li>Mockito can no longer strip <code>synchronized</code> modifiers from mocked instances.</li>
+ * </ul>
+ * <p>
+ * <p>
+ * Note that inline mocks require a Java agent to be attached. Mockito will attempt an attachment of a Java agent upon
+ * loading the mock maker for creating inline mocks. Such runtime attachment is only possible when using a JVM that
+ * is part of a JDK or when using a Java 9 VM. When running on a non-JDK VM prior to Java 9, it is however possible to
+ * manually add the <a href="https://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
+ * parameter upon starting the JVM. Furthermore, the inlining mock maker requires the VM to support class retransformation
+ * (also known as HotSwap). All major VM distributions such as HotSpot (OpenJDK), J9 (IBM/Websphere) or Zing (Azul)
+ * support this feature.
+ */
+@SuppressSignatureCheck
+class InlineDelegateByteBuddyMockMaker
+        implements ClassCreatingMockMaker, InlineMockMaker, Instantiator {
+
+    private static final Instrumentation INSTRUMENTATION;
+
+    private static final Throwable INITIALIZATION_ERROR;
+
+    static {
+        Instrumentation instrumentation;
+        Throwable initializationError = null;
+
+        // ByteBuddy internally may attempt to fork a subprocess. In Java 11 and Java 19, the
+        // Java process class observes the os.name system property to determine the OS and
+        // thus determine how to fork a new process. If the user is stubbing System
+        // properties, they may clear the existing System properties, which will cause this
+        // to fail. This is very much an implementation detail, but it will result in Mockito
+        // failing to load with an error that is not overly clear, so let's attempt to detect
+        // this issue ahead of time instead.
+        if (System.getProperty("os.name") == null) {
+            throw new IllegalStateException(
+                    join(
+                            "The Byte Buddy agent cannot be loaded.",
+                            "",
+                            "To initialise the Byte Buddy agent, a subprocess may need to be created. To do this, the JVM requires "
+                                    + "knowledge of the 'os.name' System property in most JRE implementations. This property is not present, "
+                                    + "which means this operation will fail to complete. Please first make sure you are not clearing this "
+                                    + "property anywhere, and failing that, raise a bug with your JVM vendor."));
+        }
+
+        try {
+            try {
+                instrumentation = PremainAttachAccess.getInstrumentation();
+                File boot = File.createTempFile("mockitoboot", ".jar");
+                boot.deleteOnExit();
+                try (JarOutputStream outputStream =
+                        new JarOutputStream(new FileOutputStream(boot))) {
+                    InputStream inputStream =
+                            InlineDelegateByteBuddyMockMaker.class.getResourceAsStream(
+                                    "inject-MockMethodDispatcher.raw");
+                    if (inputStream == null) {
+                        throw new IllegalStateException(
+                                join(
+                                        "The MockMethodDispatcher class file is not locatable: "
+                                                + "inject-MockMethodDispatcher.raw"
+                                                + " in context of "
+                                                + InlineDelegateByteBuddyMockMaker.class.getName(),
+                                        "",
+                                        "The class loader responsible for looking up the resource: "
+                                                + InlineDelegateByteBuddyMockMaker.class
+                                                        .getClassLoader(),
+                                        "",
+                                        "The module responsible for looking up the resource: "
+                                                + InlineDelegateByteBuddyMockMaker.class
+                                                        .getModule()));
+                    }
+                    try (inputStream) {
+                        outputStream.putNextEntry(
+                                new JarEntry(
+                                        "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class"));
+                        int length;
+                        byte[] buffer = new byte[1024];
+                        while ((length = inputStream.read(buffer)) != -1) {
+                            outputStream.write(buffer, 0, length);
+                        }
+                    }
+                    outputStream.closeEntry();
+                }
+                try (JarFile jarfile = new JarFile(boot)) {
+                    instrumentation.appendToBootstrapClassLoaderSearch(jarfile);
+                }
+                Class<?> dispatcher;
+                try {
+                    dispatcher =
+                            Class.forName(
+                                    "org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher",
+                                    false,
+                                    null);
+                } catch (ClassNotFoundException cnfe) {
+                    throw new IllegalStateException(
+                            join(
+                                    "Mockito failed to inject the MockMethodDispatcher class into the bootstrap class loader",
+                                    "",
+                                    "It seems like your current VM does not support the instrumentation API correctly."),
+                            cnfe);
+                }
+                try {
+                    InlineDelegateByteBuddyMockMaker.class
+                            .getModule()
+                            .addReads(dispatcher.getModule());
+                } catch (Exception e) {
+                    throw new IllegalStateException(
+                            join(
+                                    "Mockito failed to adjust the module graph to read the dispatcher module",
+                                    "",
+                                    "Dispatcher: "
+                                            + dispatcher
+                                            + " is loaded by "
+                                            + dispatcher.getClassLoader()),
+                            e);
+                }
+            } catch (IOException ioe) {
+                throw new IllegalStateException(
+                        join(
+                                "Mockito could not self-attach a Java agent to the current VM. This feature is required for inline mocking.",
+                                "This error occured due to an I/O error during the creation of this agent: "
+                                        + ioe,
+                                "",
+                                "Potentially, the current VM does not support the instrumentation API correctly"),
+                        ioe);
+            }
+        } catch (Throwable throwable) {
+            instrumentation = null;
+            initializationError = throwable;
+        }
+        INSTRUMENTATION = instrumentation;
+        INITIALIZATION_ERROR = initializationError;
+    }
+
+    private final BytecodeGenerator bytecodeGenerator;
+
+    private final WeakConcurrentMap<Object, MockMethodInterceptor> mocks =
+            new WeakConcurrentMap<>(false);
+
+    private final DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics =
+            new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.MANUAL);
+
+    private final DetachedThreadLocal<Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>>>
+            mockedConstruction = new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.MANUAL);
+
+    private final ThreadLocal<Class<?>> currentMocking = ThreadLocal.withInitial(() -> null);
+
+    private final ThreadLocal<Object> currentSpied = new ThreadLocal<>();
+
+    InlineDelegateByteBuddyMockMaker() {
+        if (INITIALIZATION_ERROR != null) {
+            String detail;
+            if (PlatformUtils.isAndroidPlatform() || PlatformUtils.isProbablyTermuxEnvironment()) {
+                detail =
+                        "It appears as if you are trying to run this mock maker on Android which does not support the instrumentation API.";
+            } else {
+                try {
+                    if (INITIALIZATION_ERROR instanceof NoClassDefFoundError
+                            && INITIALIZATION_ERROR.getMessage() != null
+                            && INITIALIZATION_ERROR
+                                    .getMessage()
+                                    .startsWith("net/bytebuddy/agent/")) {
+                        detail =
+                                join(
+                                        "It seems like you are running Mockito with an incomplete or inconsistent class path. Byte Buddy Agent could not be loaded.",
+                                        "",
+                                        "Byte Buddy Agent is available on Maven Central as 'net.bytebuddy:byte-buddy-agent' with the module name 'net.bytebuddy.agent'.",
+                                        "Normally, your IDE or build tool (such as Maven or Gradle) should take care of your class path completion but ");
+                    } else if (Class.forName("javax.tools.ToolProvider")
+                                    .getMethod("getSystemJavaCompiler")
+                                    .invoke(null)
+                            == null) {
+                        detail =
+                                "It appears as if you are running on a JRE. Either install a JDK or add JNA to the class path.";
+                    } else {
+                        detail =
+                                "It appears as if your JDK does not supply a working agent attachment mechanism.";
+                    }
+                } catch (Throwable ignored) {
+                    detail =
+                            "It appears as if you are running an incomplete JVM installation that might not support all tooling APIs";
+                }
+            }
+            throw new MockitoInitializationException(
+                    join(
+                            "Could not initialize inline Byte Buddy mock maker.",
+                            "",
+                            detail,
+                            Platform.describe()),
+                    INITIALIZATION_ERROR);
+        }
+
+        ThreadLocal<Class<?>> currentConstruction = new ThreadLocal<>();
+        ThreadLocal<Boolean> isSuspended = ThreadLocal.withInitial(() -> false);
+        Predicate<Class<?>> isCallFromSubclassConstructor = StackWalkerChecker.orFallback();
+        Predicate<Class<?>> isMockConstruction =
+                type -> {
+                    if (isSuspended.get()) {
+                        return false;
+                    } else if ((currentMocking.get() != null
+                                    && type.isAssignableFrom(currentMocking.get()))
+                            || currentConstruction.get() != null) {
+                        return true;
+                    }
+                    Map<Class<?>, ?> interceptors = mockedConstruction.get();
+                    if (interceptors != null && interceptors.containsKey(type)) {
+                        // We only initiate a construction mock, if the call originates from an
+                        // un-mocked (as suppression is not enabled) subclass constructor.
+                        if (isCallFromSubclassConstructor.test(type)) {
+                            return false;
+                        }
+                        currentConstruction.set(type);
+                        return true;
+                    } else {
+                        return false;
+                    }
+                };
+        ConstructionCallback onConstruction =
+                (type, object, arguments, parameterTypeNames) -> {
+                    if (currentMocking.get() != null) {
+                        Object spy = currentSpied.get();
+                        if (spy == null) {
+                            return null;
+                        } else if (type.isInstance(spy)) {
+                            return spy;
+                        } else {
+                            isSuspended.set(true);
+                            try {
+                                // Unexpected construction of non-spied object
+                                throw new MockitoException(
+                                        "Unexpected spy for "
+                                                + type.getName()
+                                                + " on instance of "
+                                                + object.getClass().getName(),
+                                        object instanceof Throwable ? (Throwable) object : null);
+                            } finally {
+                                isSuspended.set(false);
+                            }
+                        }
+                    } else if (currentConstruction.get() != type) {
+                        return null;
+                    }
+                    currentConstruction.remove();
+                    isSuspended.set(true);
+                    try {
+                        Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors =
+                                mockedConstruction.get();
+                        if (interceptors != null) {
+                            BiConsumer<Object, MockedConstruction.Context> interceptor =
+                                    interceptors.get(type);
+                            if (interceptor != null) {
+                                interceptor.accept(
+                                        object,
+                                        new InlineConstructionMockContext(
+                                                arguments, object.getClass(), parameterTypeNames));
+                            }
+                        }
+                    } finally {
+                        isSuspended.set(false);
+                    }
+                    return null;
+                };
+
+        bytecodeGenerator =
+                new TypeCachingBytecodeGenerator(
+                        new InlineBytecodeGenerator(
+                                INSTRUMENTATION,
+                                mocks,
+                                mockedStatics,
+                                isMockConstruction,
+                                onConstruction),
+                        true);
+    }
+
+    @Override
+    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+        return doCreateMock(settings, handler, false);
+    }
+
+    @Override
+    public <T> Optional<T> createSpy(
+            MockCreationSettings<T> settings, MockHandler handler, T object) {
+        if (object == null) {
+            throw new MockitoConfigurationException("Spy instance must not be null");
+        }
+        currentSpied.set(object);
+        try {
+            return Optional.ofNullable(doCreateMock(settings, handler, true));
+        } finally {
+            currentSpied.remove();
+        }
+    }
+
+    private <T> T doCreateMock(
+            MockCreationSettings<T> settings,
+            MockHandler handler,
+            boolean nullOnNonInlineConstruction) {
+        Class<? extends T> type = createMockType(settings);
+
+        try {
+            T instance;
+            if (settings.isUsingConstructor()) {
+                instance =
+                        new ConstructorInstantiator(
+                                        settings.getOuterClassInstance() != null,
+                                        settings.getConstructorArgs())
+                                .newInstance(type);
+            } else {
+                try {
+                    // We attempt to use the "native" mock maker first that avoids
+                    // Objenesis and Unsafe
+                    instance = newInstance(type);
+                } catch (InstantiationException ignored) {
+                    if (nullOnNonInlineConstruction) {
+                        return null;
+                    }
+                    Instantiator instantiator =
+                            Plugins.getInstantiatorProvider().getInstantiator(settings);
+                    instance = instantiator.newInstance(type);
+                }
+            }
+            MockMethodInterceptor mockMethodInterceptor =
+                    new MockMethodInterceptor(handler, settings);
+            mocks.put(instance, mockMethodInterceptor);
+            if (instance instanceof MockAccess) {
+                ((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);
+            }
+            mocks.expungeStaleEntries();
+            return instance;
+        } catch (InstantiationException e) {
+            throw new MockitoException(
+                    "Unable to create mock instance of type '" + type.getSimpleName() + "'", e);
+        }
+    }
+
+    @Override
+    public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
+        try {
+            return bytecodeGenerator.mockClass(
+                    MockFeatures.withMockFeatures(
+                            settings.getTypeToMock(),
+                            settings.getExtraInterfaces(),
+                            settings.getSerializableMode(),
+                            settings.isStripAnnotations(),
+                            settings.getDefaultAnswer()));
+        } catch (Exception bytecodeGenerationFailed) {
+            throw prettifyFailure(settings, bytecodeGenerationFailed);
+        }
+    }
+
+    private <T> RuntimeException prettifyFailure(
+            MockCreationSettings<T> mockFeatures, Exception generationFailed) {
+        Class<T> typeToMock = mockFeatures.getTypeToMock();
+        if (typeToMock.isArray()) {
+            throw new MockitoException(
+                    join("Arrays cannot be mocked: " + typeToMock + ".", ""), generationFailed);
+        }
+        if (Modifier.isFinal(typeToMock.getModifiers())) {
+            throw new MockitoException(
+                    join(
+                            "Mockito cannot mock this class: " + typeToMock + ".",
+                            "Can not mock final classes with the following settings :",
+                            " - explicit serialization (e.g. withSettings().serializable())",
+                            " - extra interfaces (e.g. withSettings().extraInterfaces(...))",
+                            "",
+                            "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
+                            "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
+                            "",
+                            "Underlying exception : " + generationFailed),
+                    generationFailed);
+        }
+        if (TypeSupport.INSTANCE.isSealed(typeToMock) && typeToMock.isEnum()) {
+            throw new MockitoException(
+                    join(
+                            "Mockito cannot mock this class: " + typeToMock + ".",
+                            "Sealed abstract enums can't be mocked. Since Java 15 abstract enums are declared sealed, which prevents mocking.",
+                            "You can still return an existing enum literal from a stubbed method call."),
+                    generationFailed);
+        }
+        if (TypeSupport.INSTANCE.isSealed(typeToMock)
+                && Modifier.isAbstract(typeToMock.getModifiers())) {
+            throw new MockitoException(
+                    join(
+                            "Mockito cannot mock this class: " + typeToMock + ".",
+                            "Sealed interfaces or abstract classes can't be mocked. Interfaces cannot be instantiated and cannot be subclassed for mocking purposes.",
+                            "Instead of mocking a sealed interface or an abstract class, a non-abstract class can be mocked and used to represent the interface."),
+                    generationFailed);
+        }
+        if (Modifier.isPrivate(typeToMock.getModifiers())) {
+            throw new MockitoException(
+                    join(
+                            "Mockito cannot mock this class: " + typeToMock + ".",
+                            "Most likely it is a private class that is not visible by Mockito",
+                            "",
+                            "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
+                            "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
+                            ""),
+                    generationFailed);
+        }
+        throw new MockitoException(
+                join(
+                        "Mockito cannot mock this class: " + typeToMock + ".",
+                        "",
+                        "If you're not sure why you're getting this error, please open an issue on GitHub.",
+                        "",
+                        Platform.warnForVM(
+                                "IBM J9 VM",
+                                "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
+                                "Hotspot",
+                                ""),
+                        Platform.describe(),
+                        "",
+                        "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
+                        "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
+                        "",
+                        "Underlying exception : " + generationFailed),
+                generationFailed);
+    }
+
+    @Override
+    public MockHandler<?> getHandler(Object mock) {
+        MockMethodInterceptor interceptor;
+        if (mock instanceof Class<?>) {
+            Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+            interceptor = interceptors != null ? interceptors.get(mock) : null;
+        } else {
+            interceptor = mocks.get(mock);
+        }
+        if (interceptor == null) {
+            return null;
+        } else {
+            return interceptor.getMockHandler();
+        }
+    }
+
+    @Override
+    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+        MockMethodInterceptor mockMethodInterceptor =
+                new MockMethodInterceptor(newHandler, settings);
+        if (mock instanceof Class<?>) {
+            Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+            if (interceptors == null || !interceptors.containsKey(mock)) {
+                throw new MockitoException(
+                        "Cannot reset "
+                                + mock
+                                + " which is not currently registered as a static mock");
+            }
+            interceptors.put((Class<?>) mock, mockMethodInterceptor);
+        } else {
+            if (!mocks.containsKey(mock)) {
+                throw new MockitoException(
+                        "Cannot reset " + mock + " which is not currently registered as a mock");
+            }
+            mocks.put(mock, mockMethodInterceptor);
+            if (mock instanceof MockAccess) {
+                ((MockAccess) mock).setMockitoInterceptor(mockMethodInterceptor);
+            }
+            mocks.expungeStaleEntries();
+        }
+    }
+
+    @Override
+    public void clearAllCaches() {
+        clearAllMocks();
+        bytecodeGenerator.clearAllCaches();
+    }
+
+    @Override
+    public void clearMock(Object mock) {
+        if (mock instanceof Class<?>) {
+            for (Map<Class<?>, ?> entry : mockedStatics.getBackingMap().target.values()) {
+                entry.remove(mock);
+            }
+        } else {
+            mocks.put(
+                    mock,
+                    new MockMethodInterceptor(
+                            DisabledMockHandler.HANDLER,
+                            DisabledMockHandler.HANDLER.getMockSettings()));
+        }
+    }
+
+    @Override
+    public void clearAllMocks() {
+        mockedStatics.getBackingMap().clear();
+
+        for (Entry<Object, MockMethodInterceptor> entry : mocks) {
+            clearMock(entry.getKey());
+        }
+    }
+
+    @Override
+    public TypeMockability isTypeMockable(final Class<?> type) {
+        return new TypeMockability() {
+            @Override
+            public boolean mockable() {
+                return INSTRUMENTATION.isModifiableClass(type) && !EXCLUDES.contains(type);
+            }
+
+            @Override
+            public String nonMockableReason() {
+                if (mockable()) {
+                    return "";
+                }
+                if (type.isPrimitive()) {
+                    return "primitive type";
+                }
+                if (EXCLUDES.contains(type)) {
+                    return "Cannot mock wrapper types, String.class or Class.class";
+                }
+                return "VM does not support modification of given type";
+            }
+        };
+    }
+
+    @Override
+    public <T> StaticMockControl<T> createStaticMock(
+            Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+        if (type == ConcurrentHashMap.class) {
+            throw new MockitoException(
+                    "It is not possible to mock static methods of ConcurrentHashMap "
+                            + "to avoid infinitive loops within Mockito's implementation of static mock handling");
+        } else if (type == Thread.class
+                || type == System.class
+                || type == Arrays.class
+                || ClassLoader.class.isAssignableFrom(type)) {
+            throw new MockitoException(
+                    "It is not possible to mock static methods of "
+                            + type.getName()
+                            + " to avoid interfering with class loading what leads to infinite loops");
+        }
+
+        bytecodeGenerator.mockClassStatic(type);
+
+        Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+        if (interceptors == null) {
+            interceptors = new WeakHashMap<>();
+            mockedStatics.set(interceptors);
+        }
+        mockedStatics.getBackingMap().expungeStaleEntries();
+
+        return new InlineStaticMockControl<>(type, interceptors, settings, handler);
+    }
+
+    @Override
+    public <T> ConstructionMockControl<T> createConstructionMock(
+            Class<T> type,
+            Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+            Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        if (type == Object.class) {
+            throw new MockitoException(
+                    "It is not possible to mock construction of the Object class "
+                            + "to avoid inference with default object constructor chains");
+        } else if (type.isPrimitive() || Modifier.isAbstract(type.getModifiers())) {
+            throw new MockitoException(
+                    "It is not possible to construct primitive types or abstract types: "
+                            + type.getName());
+        }
+
+        bytecodeGenerator.mockClassConstruction(type);
+
+        Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors =
+                mockedConstruction.get();
+        if (interceptors == null) {
+            interceptors = new WeakHashMap<>();
+            mockedConstruction.set(interceptors);
+        }
+        mockedConstruction.getBackingMap().expungeStaleEntries();
+
+        return new InlineConstructionMockControl<>(
+                type, settingsFactory, handlerFactory, mockInitializer, interceptors);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T newInstance(Class<T> cls) throws InstantiationException {
+        Constructor<?>[] constructors = cls.getDeclaredConstructors();
+        if (constructors.length == 0) {
+            throw new InstantiationException(cls.getName() + " does not define a constructor");
+        }
+        Constructor<?> selected = constructors[0];
+        for (Constructor<?> constructor : constructors) {
+            if (Modifier.isPublic(constructor.getModifiers())) {
+                selected = constructor;
+                break;
+            }
+        }
+        Class<?>[] types = selected.getParameterTypes();
+        Object[] arguments = new Object[types.length];
+        int index = 0;
+        for (Class<?> type : types) {
+            arguments[index++] = makeStandardArgument(type);
+        }
+        MemberAccessor accessor = Plugins.getMemberAccessor();
+        try {
+            return (T)
+                    accessor.newInstance(
+                            selected,
+                            callback -> {
+                                currentMocking.set(cls);
+                                try {
+                                    return callback.newInstance();
+                                } finally {
+                                    currentMocking.remove();
+                                }
+                            },
+                            arguments);
+        } catch (Exception e) {
+            throw new InstantiationException("Could not instantiate " + cls.getName(), e);
+        }
+    }
+
+    private Object makeStandardArgument(Class<?> type) {
+        if (type == boolean.class) {
+            return false;
+        } else if (type == byte.class) {
+            return (byte) 0;
+        } else if (type == short.class) {
+            return (short) 0;
+        } else if (type == char.class) {
+            return (char) 0;
+        } else if (type == int.class) {
+            return 0;
+        } else if (type == long.class) {
+            return 0L;
+        } else if (type == float.class) {
+            return 0f;
+        } else if (type == double.class) {
+            return 0d;
+        } else {
+            return null;
+        }
+    }
+
+    private static class InlineStaticMockControl<T> implements StaticMockControl<T> {
+
+        private final Class<T> type;
+
+        private final Map<Class<?>, MockMethodInterceptor> interceptors;
+
+        private final MockCreationSettings<T> settings;
+
+        private final MockHandler<?> handler;
+
+        private InlineStaticMockControl(
+                Class<T> type,
+                Map<Class<?>, MockMethodInterceptor> interceptors,
+                MockCreationSettings<T> settings,
+                MockHandler<?> handler) {
+            this.type = type;
+            this.interceptors = interceptors;
+            this.settings = settings;
+            this.handler = handler;
+        }
+
+        @Override
+        public Class<T> getType() {
+            return type;
+        }
+
+        @Override
+        public void enable() {
+            if (interceptors.putIfAbsent(type, new MockMethodInterceptor(handler, settings))
+                    != null) {
+                throw new MockitoException(
+                        join(
+                                "For "
+                                        + type.getName()
+                                        + ", static mocking is already registered in the current thread",
+                                "",
+                                "To create a new mock, the existing static mock registration must be deregistered"));
+            }
+        }
+
+        @Override
+        public void disable() {
+            if (interceptors.remove(type) == null) {
+                throw new MockitoException(
+                        join(
+                                "Could not deregister "
+                                        + type.getName()
+                                        + " as a static mock since it is not currently registered",
+                                "",
+                                "To register a static mock, use Mockito.mockStatic("
+                                        + type.getSimpleName()
+                                        + ".class)"));
+            }
+        }
+    }
+
+    private class InlineConstructionMockControl<T> implements ConstructionMockControl<T> {
+
+        private final Class<T> type;
+
+        private final Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory;
+        private final Function<MockedConstruction.Context, MockHandler<T>> handlerFactory;
+
+        private final MockedConstruction.MockInitializer<T> mockInitializer;
+
+        private final Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors;
+
+        private final List<Object> all = new ArrayList<>();
+        private int count;
+
+        private InlineConstructionMockControl(
+                Class<T> type,
+                Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+                Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+                MockedConstruction.MockInitializer<T> mockInitializer,
+                Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors) {
+            this.type = type;
+            this.settingsFactory = settingsFactory;
+            this.handlerFactory = handlerFactory;
+            this.mockInitializer = mockInitializer;
+            this.interceptors = interceptors;
+        }
+
+        @Override
+        public Class<T> getType() {
+            return type;
+        }
+
+        @Override
+        public void enable() {
+            if (interceptors.putIfAbsent(
+                            type,
+                            (object, context) -> {
+                                ((InlineConstructionMockContext) context).count = ++count;
+                                MockMethodInterceptor interceptor =
+                                        new MockMethodInterceptor(
+                                                handlerFactory.apply(context),
+                                                settingsFactory.apply(context));
+                                mocks.put(object, interceptor);
+                                try {
+                                    @SuppressWarnings("unchecked")
+                                    T cast = (T) object;
+                                    mockInitializer.prepare(cast, context);
+                                } catch (Throwable t) {
+                                    mocks.remove(object); // TODO: filter stack trace?
+                                    throw new MockitoException(
+                                            "Could not initialize mocked construction", t);
+                                }
+                                all.add(object);
+                            })
+                    != null) {
+                throw new MockitoException(
+                        join(
+                                "For "
+                                        + type.getName()
+                                        + ", static mocking is already registered in the current thread",
+                                "",
+                                "To create a new mock, the existing static mock registration must be deregistered"));
+            }
+        }
+
+        @Override
+        public void disable() {
+            if (interceptors.remove(type) == null) {
+                throw new MockitoException(
+                        join(
+                                "Could not deregister "
+                                        + type.getName()
+                                        + " as a static mock since it is not currently registered",
+                                "",
+                                "To register a static mock, use Mockito.mockStatic("
+                                        + type.getSimpleName()
+                                        + ".class)"));
+            }
+            all.clear();
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public List<T> getMocks() {
+            return (List<T>) all;
+        }
+    }
+
+    private static class InlineConstructionMockContext implements MockedConstruction.Context {
+
+        private static final Map<String, Class<?>> PRIMITIVES = new HashMap<>();
+
+        static {
+            PRIMITIVES.put(boolean.class.getName(), boolean.class);
+            PRIMITIVES.put(byte.class.getName(), byte.class);
+            PRIMITIVES.put(short.class.getName(), short.class);
+            PRIMITIVES.put(char.class.getName(), char.class);
+            PRIMITIVES.put(int.class.getName(), int.class);
+            PRIMITIVES.put(long.class.getName(), long.class);
+            PRIMITIVES.put(float.class.getName(), float.class);
+            PRIMITIVES.put(double.class.getName(), double.class);
+        }
+
+        private int count;
+
+        private final Object[] arguments;
+        private final Class<?> type;
+        private final String[] parameterTypeNames;
+
+        private InlineConstructionMockContext(
+                Object[] arguments, Class<?> type, String[] parameterTypeNames) {
+            this.arguments = arguments;
+            this.type = type;
+            this.parameterTypeNames = parameterTypeNames;
+        }
+
+        @Override
+        public int getCount() {
+            if (count == 0) {
+                throw new MockitoConfigurationException(
+                        "mocked construction context is not initialized");
+            }
+            return count;
+        }
+
+        @Override
+        public Constructor<?> constructor() {
+            Class<?>[] parameterTypes = new Class<?>[parameterTypeNames.length];
+            int index = 0;
+            for (String parameterTypeName : parameterTypeNames) {
+                if (PRIMITIVES.containsKey(parameterTypeName)) {
+                    parameterTypes[index++] = PRIMITIVES.get(parameterTypeName);
+                } else {
+                    try {
+                        parameterTypes[index++] =
+                                Class.forName(parameterTypeName, false, type.getClassLoader());
+                    } catch (ClassNotFoundException e) {
+                        throw new MockitoException(
+                                "Could not find parameter of type " + parameterTypeName, e);
+                    }
+                }
+            }
+            try {
+                return type.getDeclaredConstructor(parameterTypes);
+            } catch (NoSuchMethodException e) {
+                throw new MockitoException(
+                        join(
+                                "Could not resolve constructor of type",
+                                "",
+                                type.getName(),
+                                "",
+                                "with arguments of types",
+                                Arrays.toString(parameterTypes)),
+                        e);
+            }
+        }
+
+        @Override
+        public List<?> arguments() {
+            return Collections.unmodifiableList(Arrays.asList(arguments));
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
new file mode 100644
index 0000000000..ca27be01e1
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import java.util.Collections;
+import java.util.Set;
+
+import org.mockito.mock.SerializableMode;
+import org.mockito.stubbing.Answer;
+
+class MockFeatures<T> {
+
+    final Class<T> mockedType;
+    final Set<Class<?>> interfaces;
+    final SerializableMode serializableMode;
+    final boolean stripAnnotations;
+    final Answer defaultAnswer;
+
+    private MockFeatures(
+            Class<T> mockedType,
+            Set<Class<?>> interfaces,
+            SerializableMode serializableMode,
+            boolean stripAnnotations,
+            Answer defaultAnswer) {
+        this.mockedType = mockedType;
+        this.interfaces = Collections.unmodifiableSet(interfaces);
+        this.serializableMode = serializableMode;
+        this.stripAnnotations = stripAnnotations;
+        this.defaultAnswer = defaultAnswer;
+    }
+
+    public static <T> MockFeatures<T> withMockFeatures(
+            Class<T> mockedType,
+            Set<Class<?>> interfaces,
+            SerializableMode serializableMode,
+            boolean stripAnnotations,
+            Answer defaultAnswer) {
+        return new MockFeatures<T>(
+                mockedType, interfaces, serializableMode, stripAnnotations, defaultAnswer);
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
new file mode 100644
index 0000000000..2ce0027bc4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
@@ -0,0 +1,766 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static net.bytebuddy.matcher.ElementMatchers.isVisibleTo;
+import static net.bytebuddy.matcher.ElementMatchers.isConstructor;
+import static net.bytebuddy.matcher.ElementMatchers.isStatic;
+import static net.bytebuddy.matcher.ElementMatchers.not;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.ref.SoftReference;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.concurrent.Callable;
+import java.util.function.Predicate;
+
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.field.FieldDescription;
+import net.bytebuddy.description.field.FieldList;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.method.MethodList;
+import net.bytebuddy.description.method.ParameterDescription;
+import net.bytebuddy.description.type.TypeDefinition;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.scaffold.MethodGraph;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.implementation.bind.annotation.Argument;
+import net.bytebuddy.implementation.bind.annotation.This;
+import net.bytebuddy.implementation.bytecode.StackSize;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+import net.bytebuddy.jar.asm.Label;
+import net.bytebuddy.jar.asm.MethodVisitor;
+import net.bytebuddy.jar.asm.Opcodes;
+import net.bytebuddy.jar.asm.Type;
+import net.bytebuddy.pool.TypePool;
+import net.bytebuddy.utility.OpenedClassReader;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor;
+import org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.invocation.mockref.MockReference;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
+import org.mockito.internal.util.concurrent.DetachedThreadLocal;
+import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import org.mockito.plugins.MemberAccessor;
+
+public class MockMethodAdvice extends MockMethodDispatcher {
+
+    private final WeakConcurrentMap<Object, MockMethodInterceptor> interceptors;
+    private final DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics;
+
+    private final String identifier;
+
+    private final SelfCallInfo selfCallInfo = new SelfCallInfo();
+    private final MethodGraph.Compiler compiler = MethodGraph.Compiler.Default.forJavaHierarchy();
+    private final WeakConcurrentMap<Class<?>, SoftReference<MethodGraph>> graphs =
+            new WeakConcurrentMap.WithInlinedExpunction<>();
+
+    private final Predicate<Class<?>> isMockConstruction;
+    private final ConstructionCallback onConstruction;
+
+    public MockMethodAdvice(
+            WeakConcurrentMap<Object, MockMethodInterceptor> interceptors,
+            DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics,
+            String identifier,
+            Predicate<Class<?>> isMockConstruction,
+            ConstructionCallback onConstruction) {
+        this.interceptors = interceptors;
+        this.mockedStatics = mockedStatics;
+        this.onConstruction = onConstruction;
+        this.identifier = identifier;
+        this.isMockConstruction = isMockConstruction;
+    }
+
+    @SuppressWarnings("unused")
+    @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
+    private static Callable<?> enter(
+            @Identifier String identifier,
+            @Advice.This Object mock,
+            @Advice.Origin Method origin,
+            @Advice.AllArguments Object[] arguments)
+            throws Throwable {
+        MockMethodDispatcher dispatcher = MockMethodDispatcher.get(identifier, mock);
+        if (dispatcher == null
+                || !dispatcher.isMocked(mock)
+                || dispatcher.isOverridden(mock, origin)) {
+            return null;
+        } else {
+            return dispatcher.handle(mock, origin, arguments);
+        }
+    }
+
+    @SuppressWarnings({"unused", "UnusedAssignment"})
+    @Advice.OnMethodExit
+    private static void exit(
+            @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object returned,
+            @Advice.Enter Callable<?> mocked)
+            throws Throwable {
+        if (mocked != null) {
+            returned = mocked.call();
+        }
+    }
+
+    @Override
+    public Callable<?> handle(Object instance, Method origin, Object[] arguments) throws Throwable {
+        MockMethodInterceptor interceptor = interceptors.get(instance);
+        if (interceptor == null) {
+            return null;
+        }
+        RealMethod realMethod;
+        if (instance instanceof Serializable) {
+            realMethod = new SerializableRealMethodCall(identifier, origin, instance, arguments);
+        } else {
+            realMethod = new RealMethodCall(selfCallInfo, origin, instance, arguments);
+        }
+        return new ReturnValueWrapper(
+                interceptor.doIntercept(
+                        instance, origin, arguments, realMethod, LocationFactory.create(true)));
+    }
+
+    @Override
+    public Callable<?> handleStatic(Class<?> type, Method origin, Object[] arguments)
+            throws Throwable {
+        Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+        if (interceptors == null || !interceptors.containsKey(type)) {
+            return null;
+        }
+        return new ReturnValueWrapper(
+                interceptors
+                        .get(type)
+                        .doIntercept(
+                                type,
+                                origin,
+                                arguments,
+                                new StaticMethodCall(selfCallInfo, type, origin, arguments),
+                                LocationFactory.create(true)));
+    }
+
+    @Override
+    public Object handleConstruction(
+            Class<?> type, Object object, Object[] arguments, String[] parameterTypeNames) {
+        return onConstruction.apply(type, object, arguments, parameterTypeNames);
+    }
+
+    @Override
+    public boolean isMock(Object instance) {
+        // We need to exclude 'interceptors.target' explicitly to avoid a recursive check on whether
+        // the map is a mock object what requires reading from the map.
+        return instance != interceptors.target && interceptors.containsKey(instance);
+    }
+
+    @Override
+    public boolean isMocked(Object instance) {
+        return isMock(instance) && selfCallInfo.checkSelfCall(instance);
+    }
+
+    @Override
+    public boolean isMockedStatic(Class<?> type) {
+        if (!selfCallInfo.checkSelfCall(type)) {
+            return false;
+        }
+        Map<Class<?>, ?> interceptors = mockedStatics.get();
+        return interceptors != null && interceptors.containsKey(type);
+    }
+
+    @Override
+    public boolean isOverridden(Object instance, Method origin) {
+        SoftReference<MethodGraph> reference = graphs.get(instance.getClass());
+        MethodGraph methodGraph = reference == null ? null : reference.get();
+        if (methodGraph == null) {
+            methodGraph =
+                    compiler.compile(
+                            (TypeDefinition) TypeDescription.ForLoadedType.of(instance.getClass()));
+            graphs.put(instance.getClass(), new SoftReference<>(methodGraph));
+        }
+        MethodGraph.Node node =
+                methodGraph.locate(
+                        new MethodDescription.ForLoadedMethod(origin).asSignatureToken());
+        return !node.getSort().isResolved()
+                || !node.getRepresentative()
+                        .asDefined()
+                        .getDeclaringType()
+                        .represents(origin.getDeclaringClass());
+    }
+
+    @Override
+    public boolean isConstructorMock(Class<?> type) {
+        return isMockConstruction.test(type);
+    }
+
+    private static class RealMethodCall implements RealMethod {
+
+        private final SelfCallInfo selfCallInfo;
+
+        private final Method origin;
+
+        private final MockWeakReference<Object> instanceRef;
+
+        private final Object[] arguments;
+
+        private RealMethodCall(
+                SelfCallInfo selfCallInfo, Method origin, Object instance, Object[] arguments) {
+            this.selfCallInfo = selfCallInfo;
+            this.origin = origin;
+            this.instanceRef = new MockWeakReference<>(instance);
+            this.arguments = arguments;
+        }
+
+        @Override
+        public boolean isInvokable() {
+            return true;
+        }
+
+        @Override
+        public Object invoke() throws Throwable {
+            selfCallInfo.set(instanceRef.get());
+            return tryInvoke(origin, instanceRef.get(), arguments);
+        }
+    }
+
+    private static class SerializableRealMethodCall implements RealMethod {
+
+        private final String identifier;
+
+        private final SerializableMethod origin;
+
+        private final MockReference<Object> instanceRef;
+
+        private final Object[] arguments;
+
+        private SerializableRealMethodCall(
+                String identifier, Method origin, Object instance, Object[] arguments) {
+            this.origin = new SerializableMethod(origin);
+            this.identifier = identifier;
+            this.instanceRef = new MockWeakReference<>(instance);
+            this.arguments = arguments;
+        }
+
+        @Override
+        public boolean isInvokable() {
+            return true;
+        }
+
+        @Override
+        public Object invoke() throws Throwable {
+            Method method = origin.getJavaMethod();
+            MockMethodDispatcher mockMethodDispatcher =
+                    MockMethodDispatcher.get(identifier, instanceRef.get());
+            if (!(mockMethodDispatcher instanceof MockMethodAdvice)) {
+                throw new MockitoException("Unexpected dispatcher for advice-based super call");
+            }
+            Object previous =
+                    ((MockMethodAdvice) mockMethodDispatcher)
+                            .selfCallInfo.replace(instanceRef.get());
+            try {
+                return tryInvoke(method, instanceRef.get(), arguments);
+            } finally {
+                ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.set(previous);
+            }
+        }
+    }
+
+    private static class StaticMethodCall implements RealMethod {
+
+        private final SelfCallInfo selfCallInfo;
+
+        private final Class<?> type;
+
+        private final Method origin;
+
+        private final Object[] arguments;
+
+        private StaticMethodCall(
+                SelfCallInfo selfCallInfo, Class<?> type, Method origin, Object[] arguments) {
+            this.selfCallInfo = selfCallInfo;
+            this.type = type;
+            this.origin = origin;
+            this.arguments = arguments;
+        }
+
+        @Override
+        public boolean isInvokable() {
+            return true;
+        }
+
+        @Override
+        public Object invoke() throws Throwable {
+            selfCallInfo.set(type);
+            return tryInvoke(origin, null, arguments);
+        }
+    }
+
+    private static Object tryInvoke(Method origin, Object instance, Object[] arguments)
+            throws Throwable {
+        MemberAccessor accessor = Plugins.getMemberAccessor();
+        try {
+            return accessor.invoke(origin, instance, arguments);
+        } catch (InvocationTargetException exception) {
+            Throwable cause = exception.getCause();
+            new ConditionalStackTraceFilter()
+                    .filter(removeRecursiveCalls(cause, origin.getDeclaringClass()));
+            throw cause;
+        }
+    }
+
+    static Throwable removeRecursiveCalls(final Throwable cause, final Class<?> declaringClass) {
+        final List<String> uniqueStackTraceItems = new ArrayList<>();
+        final List<Integer> indexesToBeRemoved = new ArrayList<>();
+        for (StackTraceElement element : cause.getStackTrace()) {
+            final String key = element.getClassName() + element.getLineNumber();
+            final int elementIndex = uniqueStackTraceItems.lastIndexOf(key);
+            uniqueStackTraceItems.add(key);
+
+            if (elementIndex > -1 && declaringClass.getName().equals(element.getClassName())) {
+                indexesToBeRemoved.add(elementIndex);
+            }
+        }
+        final List<StackTraceElement> adjustedList =
+                new ArrayList<>(Arrays.asList(cause.getStackTrace()));
+        indexesToBeRemoved.stream()
+                .sorted(Comparator.reverseOrder())
+                .mapToInt(Integer::intValue)
+                .forEach(adjustedList::remove);
+        cause.setStackTrace(adjustedList.toArray(new StackTraceElement[] {}));
+        return cause;
+    }
+
+    private static class ReturnValueWrapper implements Callable<Object> {
+
+        private final Object returned;
+
+        private ReturnValueWrapper(Object returned) {
+            this.returned = returned;
+        }
+
+        @Override
+        public Object call() {
+            return returned;
+        }
+    }
+
+    private static class SelfCallInfo extends ThreadLocal<Object> {
+
+        Object replace(Object value) {
+            Object current = get();
+            set(value);
+            return current;
+        }
+
+        boolean checkSelfCall(Object value) {
+            if (value == get()) {
+                set(null);
+                return false;
+            } else {
+                return true;
+            }
+        }
+    }
+
+    static class ConstructorShortcut
+            implements AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper {
+
+        private final String identifier;
+
+        ConstructorShortcut(String identifier) {
+            this.identifier = identifier;
+        }
+
+        @Override
+        public MethodVisitor wrap(
+                TypeDescription instrumentedType,
+                MethodDescription instrumentedMethod,
+                MethodVisitor methodVisitor,
+                Implementation.Context implementationContext,
+                TypePool typePool,
+                int writerFlags,
+                int readerFlags) {
+            if (instrumentedMethod.isConstructor() && !instrumentedType.represents(Object.class)) {
+                MethodList<MethodDescription.InDefinedShape> constructors =
+                        instrumentedType
+                                .getSuperClass()
+                                .asErasure()
+                                .getDeclaredMethods()
+                                .filter(isConstructor().and(isVisibleTo(instrumentedType)));
+                int arguments = Integer.MAX_VALUE;
+                boolean packagePrivate = true;
+                MethodDescription.InDefinedShape current = null;
+                for (MethodDescription.InDefinedShape constructor : constructors) {
+                    // We are choosing the shortest constructor with regards to arguments.
+                    // Yet, we prefer a non-package-private constructor since they require
+                    // the super class to be on the same class loader.
+                    if (constructor.getParameters().size() < arguments
+                            && (packagePrivate || !constructor.isPackagePrivate())) {
+                        arguments = constructor.getParameters().size();
+                        packagePrivate = constructor.isPackagePrivate();
+                        current = constructor;
+                    }
+                }
+                if (current != null) {
+                    final MethodDescription.InDefinedShape selected = current;
+                    return new MethodVisitor(OpenedClassReader.ASM_API, methodVisitor) {
+                        @Override
+                        public void visitCode() {
+                            super.visitCode();
+                            /*
+                             * The byte code that is added to the start of the method is roughly equivalent to
+                             * the following byte code for a hypothetical constructor of class Current:
+                             *
+                             * if (MockMethodDispatcher.isConstructorMock(<identifier>, Current.class) {
+                             *   super(<default arguments>);
+                             *   Current o = (Current) MockMethodDispatcher.handleConstruction(Current.class,
+                             *       this,
+                             *       new Object[] {argument1, argument2, ...},
+                             *       new String[] {argumentType1, argumentType2, ...});
+                             *   if (o != null) {
+                             *     this.field = o.field; // for each declared field
+                             *   }
+                             *   return;
+                             * }
+                             *
+                             * This avoids the invocation of the original constructor chain but fullfils the
+                             * verifier requirement to invoke a super constructor.
+                             */
+                            Label label = new Label();
+                            super.visitLdcInsn(identifier);
+                            if (implementationContext
+                                    .getClassFileVersion()
+                                    .isAtLeast(ClassFileVersion.JAVA_V5)) {
+                                super.visitLdcInsn(Type.getType(instrumentedType.getDescriptor()));
+                            } else {
+                                super.visitLdcInsn(instrumentedType.getName());
+                                super.visitMethodInsn(
+                                        Opcodes.INVOKESTATIC,
+                                        Type.getInternalName(Class.class),
+                                        "forName",
+                                        Type.getMethodDescriptor(
+                                                Type.getType(Class.class),
+                                                Type.getType(String.class)),
+                                        false);
+                            }
+                            super.visitMethodInsn(
+                                    Opcodes.INVOKESTATIC,
+                                    Type.getInternalName(MockMethodDispatcher.class),
+                                    "isConstructorMock",
+                                    Type.getMethodDescriptor(
+                                            Type.BOOLEAN_TYPE,
+                                            Type.getType(String.class),
+                                            Type.getType(Class.class)),
+                                    false);
+                            super.visitInsn(Opcodes.ICONST_0);
+                            super.visitJumpInsn(Opcodes.IF_ICMPEQ, label);
+                            super.visitVarInsn(Opcodes.ALOAD, 0);
+                            for (TypeDescription type :
+                                    selected.getParameters().asTypeList().asErasures()) {
+                                if (type.represents(boolean.class)
+                                        || type.represents(byte.class)
+                                        || type.represents(short.class)
+                                        || type.represents(char.class)
+                                        || type.represents(int.class)) {
+                                    super.visitInsn(Opcodes.ICONST_0);
+                                } else if (type.represents(long.class)) {
+                                    super.visitInsn(Opcodes.LCONST_0);
+                                } else if (type.represents(float.class)) {
+                                    super.visitInsn(Opcodes.FCONST_0);
+                                } else if (type.represents(double.class)) {
+                                    super.visitInsn(Opcodes.DCONST_0);
+                                } else {
+                                    super.visitInsn(Opcodes.ACONST_NULL);
+                                }
+                            }
+                            super.visitMethodInsn(
+                                    Opcodes.INVOKESPECIAL,
+                                    selected.getDeclaringType().getInternalName(),
+                                    selected.getInternalName(),
+                                    selected.getDescriptor(),
+                                    false);
+                            super.visitLdcInsn(identifier);
+                            if (implementationContext
+                                    .getClassFileVersion()
+                                    .isAtLeast(ClassFileVersion.JAVA_V5)) {
+                                super.visitLdcInsn(Type.getType(instrumentedType.getDescriptor()));
+                            } else {
+                                super.visitLdcInsn(instrumentedType.getName());
+                                super.visitMethodInsn(
+                                        Opcodes.INVOKESTATIC,
+                                        Type.getInternalName(Class.class),
+                                        "forName",
+                                        Type.getMethodDescriptor(
+                                                Type.getType(Class.class),
+                                                Type.getType(String.class)),
+                                        false);
+                            }
+                            super.visitVarInsn(Opcodes.ALOAD, 0);
+                            super.visitLdcInsn(instrumentedMethod.getParameters().size());
+                            super.visitTypeInsn(
+                                    Opcodes.ANEWARRAY, Type.getInternalName(Object.class));
+                            int index = 0;
+                            for (ParameterDescription parameter :
+                                    instrumentedMethod.getParameters()) {
+                                super.visitInsn(Opcodes.DUP);
+                                super.visitLdcInsn(index++);
+                                Type type =
+                                        Type.getType(
+                                                parameter.getType().asErasure().getDescriptor());
+                                super.visitVarInsn(
+                                        type.getOpcode(Opcodes.ILOAD), parameter.getOffset());
+                                if (parameter.getType().isPrimitive()) {
+                                    Type wrapper =
+                                            Type.getType(
+                                                    parameter
+                                                            .getType()
+                                                            .asErasure()
+                                                            .asBoxed()
+                                                            .getDescriptor());
+                                    super.visitMethodInsn(
+                                            Opcodes.INVOKESTATIC,
+                                            wrapper.getInternalName(),
+                                            "valueOf",
+                                            Type.getMethodDescriptor(wrapper, type),
+                                            false);
+                                }
+                                super.visitInsn(Opcodes.AASTORE);
+                            }
+                            index = 0;
+                            super.visitLdcInsn(instrumentedMethod.getParameters().size());
+                            super.visitTypeInsn(
+                                    Opcodes.ANEWARRAY, Type.getInternalName(String.class));
+                            for (TypeDescription typeDescription :
+                                    instrumentedMethod.getParameters().asTypeList().asErasures()) {
+                                super.visitInsn(Opcodes.DUP);
+                                super.visitLdcInsn(index++);
+                                super.visitLdcInsn(typeDescription.getName());
+                                super.visitInsn(Opcodes.AASTORE);
+                            }
+                            super.visitMethodInsn(
+                                    Opcodes.INVOKESTATIC,
+                                    Type.getInternalName(MockMethodDispatcher.class),
+                                    "handleConstruction",
+                                    Type.getMethodDescriptor(
+                                            Type.getType(Object.class),
+                                            Type.getType(String.class),
+                                            Type.getType(Class.class),
+                                            Type.getType(Object.class),
+                                            Type.getType(Object[].class),
+                                            Type.getType(String[].class)),
+                                    false);
+                            FieldList<FieldDescription.InDefinedShape> fields =
+                                    instrumentedType.getDeclaredFields().filter(not(isStatic()));
+                            super.visitTypeInsn(
+                                    Opcodes.CHECKCAST, instrumentedType.getInternalName());
+                            super.visitInsn(Opcodes.DUP);
+                            Label noSpy = new Label();
+                            super.visitJumpInsn(Opcodes.IFNULL, noSpy);
+                            for (FieldDescription field : fields) {
+                                super.visitInsn(Opcodes.DUP);
+                                super.visitFieldInsn(
+                                        Opcodes.GETFIELD,
+                                        instrumentedType.getInternalName(),
+                                        field.getInternalName(),
+                                        field.getDescriptor());
+                                super.visitVarInsn(Opcodes.ALOAD, 0);
+                                super.visitInsn(
+                                        field.getType().getStackSize() == StackSize.DOUBLE
+                                                ? Opcodes.DUP_X2
+                                                : Opcodes.DUP_X1);
+                                super.visitInsn(Opcodes.POP);
+                                super.visitFieldInsn(
+                                        Opcodes.PUTFIELD,
+                                        instrumentedType.getInternalName(),
+                                        field.getInternalName(),
+                                        field.getDescriptor());
+                            }
+                            super.visitLabel(noSpy);
+                            if (implementationContext
+                                    .getClassFileVersion()
+                                    .isAtLeast(ClassFileVersion.JAVA_V6)) {
+                                Object[] locals =
+                                        toFrames(
+                                                instrumentedType.getInternalName(),
+                                                instrumentedMethod
+                                                        .getParameters()
+                                                        .asTypeList()
+                                                        .asErasures());
+                                super.visitFrame(
+                                        Opcodes.F_FULL,
+                                        locals.length,
+                                        locals,
+                                        1,
+                                        new Object[] {instrumentedType.getInternalName()});
+                            }
+                            super.visitInsn(Opcodes.POP);
+                            super.visitInsn(Opcodes.RETURN);
+                            super.visitLabel(label);
+                            if (implementationContext
+                                    .getClassFileVersion()
+                                    .isAtLeast(ClassFileVersion.JAVA_V6)) {
+                                Object[] locals =
+                                        toFrames(
+                                                Opcodes.UNINITIALIZED_THIS,
+                                                instrumentedMethod
+                                                        .getParameters()
+                                                        .asTypeList()
+                                                        .asErasures());
+                                super.visitFrame(
+                                        Opcodes.F_FULL, locals.length, locals, 0, new Object[0]);
+                            }
+                        }
+
+                        @Override
+                        public void visitMaxs(int maxStack, int maxLocals) {
+                            int prequel = Math.max(5, selected.getStackSize());
+                            for (ParameterDescription parameter :
+                                    instrumentedMethod.getParameters()) {
+                                prequel =
+                                        Math.max(
+                                                prequel,
+                                                6 + parameter.getType().getStackSize().getSize());
+                                prequel = Math.max(prequel, 8);
+                            }
+                            super.visitMaxs(Math.max(maxStack, prequel), maxLocals);
+                        }
+                    };
+                }
+            }
+            return methodVisitor;
+        }
+
+        private static Object[] toFrames(Object self, List<TypeDescription> types) {
+            Object[] frames = new Object[1 + types.size()];
+            frames[0] = self;
+            int index = 0;
+            for (TypeDescription type : types) {
+                Object frame;
+                if (type.represents(boolean.class)
+                        || type.represents(byte.class)
+                        || type.represents(short.class)
+                        || type.represents(char.class)
+                        || type.represents(int.class)) {
+                    frame = Opcodes.INTEGER;
+                } else if (type.represents(long.class)) {
+                    frame = Opcodes.LONG;
+                } else if (type.represents(float.class)) {
+                    frame = Opcodes.FLOAT;
+                } else if (type.represents(double.class)) {
+                    frame = Opcodes.DOUBLE;
+                } else {
+                    frame = type.getInternalName();
+                }
+                frames[++index] = frame;
+            }
+            return frames;
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Identifier {}
+
+    static class ForHashCode {
+
+        @SuppressWarnings("unused")
+        @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
+        private static boolean enter(@Identifier String id, @Advice.This Object self) {
+            MockMethodDispatcher dispatcher = MockMethodDispatcher.get(id, self);
+            return dispatcher != null && dispatcher.isMock(self);
+        }
+
+        @SuppressWarnings({"unused", "UnusedAssignment"})
+        @Advice.OnMethodExit
+        private static void enter(
+                @Advice.This Object self,
+                @Advice.Return(readOnly = false) int hashCode,
+                @Advice.Enter boolean skipped) {
+            if (skipped) {
+                hashCode = System.identityHashCode(self);
+            }
+        }
+    }
+
+    static class ForEquals {
+
+        @SuppressWarnings("unused")
+        @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
+        private static boolean enter(@Identifier String identifier, @Advice.This Object self) {
+            MockMethodDispatcher dispatcher = MockMethodDispatcher.get(identifier, self);
+            return dispatcher != null && dispatcher.isMock(self);
+        }
+
+        @SuppressWarnings({"unused", "UnusedAssignment"})
+        @Advice.OnMethodExit
+        private static void enter(
+                @Advice.This Object self,
+                @Advice.Argument(0) Object other,
+                @Advice.Return(readOnly = false) boolean equals,
+                @Advice.Enter boolean skipped) {
+            if (skipped) {
+                equals = self == other;
+            }
+        }
+    }
+
+    static class ForStatic {
+
+        @SuppressWarnings("unused")
+        @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
+        private static Callable<?> enter(
+                @Identifier String identifier,
+                @Advice.Origin Class<?> type,
+                @Advice.Origin Method origin,
+                @Advice.AllArguments Object[] arguments)
+                throws Throwable {
+            MockMethodDispatcher dispatcher = MockMethodDispatcher.getStatic(identifier, type);
+            if (dispatcher == null || !dispatcher.isMockedStatic(type)) {
+                return null;
+            } else {
+                return dispatcher.handleStatic(type, origin, arguments);
+            }
+        }
+
+        @SuppressWarnings({"unused", "UnusedAssignment"})
+        @Advice.OnMethodExit
+        private static void exit(
+                @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object returned,
+                @Advice.Enter Callable<?> mocked)
+                throws Throwable {
+            if (mocked != null) {
+                returned = mocked.call();
+            }
+        }
+    }
+
+    public static class ForReadObject {
+
+        @SuppressWarnings({"unused", "BanSerializableRead"})
+        public static void doReadObject(
+                @Identifier String identifier,
+                @This MockAccess thiz,
+                @Argument(0) ObjectInputStream objectInputStream)
+                throws IOException, ClassNotFoundException {
+            objectInputStream.defaultReadObject();
+            MockMethodAdvice mockMethodAdvice =
+                    (MockMethodAdvice) MockMethodDispatcher.get(identifier, thiz);
+            if (mockMethodAdvice != null) {
+                mockMethodAdvice.interceptors.put(thiz, thiz.getMockitoInterceptor());
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java
new file mode 100644
index 0000000000..5c735cdb25
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java
@@ -0,0 +1,423 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy.Default;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy.UsingLookup;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public abstract class ModuleHandler {
+
+    abstract void exportFromTo(Class<?> source, Class<?> target);
+
+    abstract void exportFromTo(Class<?> source, ClassLoader classLoader);
+
+    abstract void openFromTo(Class<?> source, Class<?> target);
+
+    abstract void readFromTo(Class<?> source, Class<?> target);
+
+    abstract ClassLoader toCodegenLoader(ClassLoader classLoader);
+
+    public abstract ClassLoadingStrategy<ClassLoader> classLoadingStrategy();
+
+    abstract ClassLoadingStrategy<ClassLoader> classLoadingStrategy(Class<?> type);
+
+    abstract boolean canOpen(Class<?> type);
+
+    abstract boolean canAddRead(Class<?> type);
+
+    static ModuleHandler make() {
+        try {
+            return new ModuleSystemFound() {
+                @Override
+                void exportFromTo(Object source, Object target, String packageName) {
+                    throw new UnsupportedOperationException(
+                            "Cannot export " + packageName + " of " + source + " to " + target);
+                }
+
+                @Override
+                void openFromToRaw(Object source, Object target, String packageName) {
+                    throw new UnsupportedOperationException(
+                            "Cannot open " + packageName + " of " + source + " to " + target);
+                }
+
+                @Override
+                void addReadsFromToRaw(Object source, Object target) {
+                    throw new UnsupportedOperationException(
+                            "Cannot add reading of " + source + " to " + target);
+                }
+            };
+        } catch (Exception ignored) {
+            return new NoModuleSystemFound() {
+                @Override
+                public ClassLoadingStrategy<ClassLoader> classLoadingStrategy() {
+                    return Default.INJECTION;
+                }
+            };
+        }
+    }
+
+    static ModuleHandler make(Object inst) {
+        try {
+            Method redefineModule =
+                    Class.forName("java.lang.instrument.Instrumentation")
+                            .getMethod(
+                                    "redefineModule",
+                                    Module.class,
+                                    Set.class,
+                                    Map.class,
+                                    Map.class,
+                                    Set.class,
+                                    Map.class);
+            return new ModuleSystemFound() {
+                @Override
+                void exportFromTo(Object source, Object target, String packageName) {
+                    try {
+                        redefineModule.invoke(
+                                inst,
+                                source,
+                                Collections.emptySet(),
+                                Collections.singletonMap(
+                                        packageName, Collections.singleton(target)),
+                                Collections.emptyMap(),
+                                Collections.emptySet(),
+                                Collections.emptyMap());
+                    } catch (Exception e) {
+                        throw new IllegalStateException(e);
+                    }
+                }
+
+                @Override
+                void openFromToRaw(Object source, Object target, String packageName) {
+                    try {
+                        redefineModule.invoke(
+                                inst,
+                                source,
+                                Collections.emptySet(),
+                                Collections.emptyMap(),
+                                Collections.singletonMap(
+                                        packageName, Collections.singleton(target)),
+                                Collections.emptySet(),
+                                Collections.emptyMap());
+                    } catch (Exception e) {
+                        throw new IllegalStateException(e);
+                    }
+                }
+
+                @Override
+                void addReadsFromToRaw(Object source, Object target) {
+                    try {
+                        redefineModule.invoke(
+                                inst,
+                                source,
+                                Collections.singleton(target),
+                                Collections.emptyMap(),
+                                Collections.emptyMap(),
+                                Collections.emptySet(),
+                                Collections.emptyMap());
+                    } catch (Exception e) {
+                        throw new IllegalStateException(e);
+                    }
+                }
+
+                @Override
+                boolean canOpen(Class<?> type) {
+                    return true;
+                }
+
+                @Override
+                boolean canAddRead(Class<?> type) {
+                    return true;
+                }
+            };
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    public abstract static class NoModuleSystemFound extends ModuleHandler {
+
+        @Override
+        void exportFromTo(Class<?> source, Class<?> target) {
+            // empty
+        }
+
+        @Override
+        void exportFromTo(Class<?> source, ClassLoader classLoader) {
+            // empty
+
+        }
+
+        @Override
+        void openFromTo(Class<?> source, Class<?> target) {
+            // empty
+
+        }
+
+        @Override
+        void readFromTo(Class<?> source, Class<?> target) {
+            // empty
+        }
+
+        @Override
+        ClassLoader toCodegenLoader(ClassLoader classLoader) {
+            return classLoader;
+        }
+
+        @Override
+        ClassLoadingStrategy<ClassLoader> classLoadingStrategy(Class<?> type) {
+            return classLoadingStrategy();
+        }
+
+        @Override
+        boolean canOpen(Class<?> type) {
+            return true;
+        }
+
+        @Override
+        boolean canAddRead(Class<?> type) {
+            return true;
+        }
+    }
+
+    abstract static class ModuleSystemFound extends ModuleHandler {
+
+        private final Object lookup;
+        private final Method privateLookupIn,
+                getModule,
+                isExported,
+                isOpen,
+                canRead,
+                addExports,
+                addOpens,
+                addReads,
+                getPackageName,
+                getUnnamedModule;
+
+        public ModuleSystemFound() throws Exception {
+            Class<?> methodHandles = Class.forName("java.lang.invoke.MethodHandles");
+            lookup = methodHandles.getMethod("lookup").invoke(null);
+            privateLookupIn =
+                    methodHandles.getMethod(
+                            "privateLookupIn",
+                            Class.class,
+                            Class.forName("java.lang.invoke.MethodHandles$Lookup"));
+            getModule = Class.class.getMethod("getModule");
+            Class<?> module = Class.forName("java.lang.Module");
+            isExported = module.getMethod("isExported", String.class, module);
+            isOpen = module.getMethod("isOpen", String.class, module);
+            canRead = module.getMethod("canRead", module);
+            addExports = module.getMethod("addExports", String.class, module);
+            addOpens = module.getMethod("addOpens", String.class, module);
+            addReads = module.getMethod("addReads", module);
+            getPackageName = Class.class.getMethod("getPackageName");
+            getUnnamedModule = ClassLoader.class.getMethod("getUnnamedModule");
+        }
+
+        private Object getModule(Class<?> type) {
+            try {
+                return getModule.invoke(type);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private boolean isExported(Object module, String packageName, Object target) {
+            try {
+                return (Boolean) isExported.invoke(module, packageName, target);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private boolean isOpen(Object module, String packageName, Object target) {
+            try {
+                return (Boolean) isOpen.invoke(module, packageName, target);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private boolean canRead(Object module, Object target) {
+            try {
+                return (Boolean) canRead.invoke(module, target);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private void addExports(Object module, String packageName, Object target) {
+            try {
+                addExports.invoke(module, packageName, target);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private void addOpens(Object module, String packageName, Object target) {
+            try {
+                addOpens.invoke(module, packageName, target);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private void addReads(Object module, Object target) {
+            try {
+                addReads.invoke(module, target);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private String getPackageName(Class<?> type) {
+            try {
+                return (String) getPackageName.invoke(type);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        private Object getUnnamedModule(ClassLoader classLoader) {
+            try {
+                return getUnnamedModule.invoke(classLoader);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+
+        @Override
+        void exportFromTo(Class<?> source, Class<?> target) {
+            exportFromTo(source, getModule(target));
+        }
+
+        @Override
+        void exportFromTo(Class<?> source, ClassLoader classLoader) {
+            exportFromTo(source, getUnnamedModule(classLoader));
+        }
+
+        private void exportFromTo(Class<?> source, Object target) {
+            if (!isExported(getModule(source), getPackageName(source), target)) {
+                if (getModule(source) == getModule(ModuleHandler.class)) {
+                    addExports(getModule(source), getPackageName(source), target);
+                } else {
+                    exportFromTo(getModule(source), target, getPackageName(source));
+                }
+            }
+        }
+
+        abstract void exportFromTo(Object source, Object target, String packageName);
+
+        @Override
+        void openFromTo(Class<?> source, Class<?> target) {
+            openFromTo(source, getModule(target));
+        }
+
+        private void openFromTo(Class<?> source, Object target) {
+            if (!isOpen(getModule(source), getPackageName(source), target)) {
+                if (getModule(source) == getModule(ModuleHandler.class)) {
+                    addOpens(getModule(source), getPackageName(source), target);
+                } else {
+                    openFromToRaw(getModule(source), target, getPackageName(source));
+                }
+            }
+        }
+
+        abstract void openFromToRaw(Object source, Object target, String packageName);
+
+        @Override
+        void readFromTo(Class<?> source, Class<?> target) {
+            readFromTo(source, getModule(target));
+        }
+
+        private void readFromTo(Class<?> source, Object target) {
+            if (!canRead(getModule(source), target)) {
+                if (getModule(source) == getModule(ModuleHandler.class)) {
+                    addReads(getModule(source), target);
+                } else {
+                    addReadsFromToRaw(getModule(source), target);
+                }
+            }
+        }
+
+        abstract void addReadsFromToRaw(Object source, Object target);
+
+        @Override
+        ClassLoader toCodegenLoader(ClassLoader classLoader) {
+            if (classLoader == MockAccess.class.getClassLoader()) {
+                return classLoader;
+            }
+            return new MockitoMockClassLoader(classLoader);
+        }
+
+        @Override
+        public ClassLoadingStrategy<ClassLoader> classLoadingStrategy() {
+            return (classLoader, types) -> {
+                if (classLoader instanceof MockitoMockClassLoader) {
+                    MockitoMockClassLoader mockLoader = (MockitoMockClassLoader) classLoader;
+                    return mockLoader.defineClasses(types);
+                } else {
+                    throw new IllegalStateException(
+                            "Expected class loader to be a Mockito mock loader: " + classLoader);
+                }
+            };
+        }
+
+        @Override
+        ClassLoadingStrategy<ClassLoader> classLoadingStrategy(Class<?> type) {
+            if (!canRead(getModule(Mockito.class), getModule(type))) {
+                addReads(getModule(Mockito.class), getModule(type));
+            }
+            try {
+                return UsingLookup.of(privateLookupIn.invoke(null, type, lookup));
+            } catch (Exception e) {
+                throw new MockitoException(
+                        "Could not resolve private lookup for " + type.getTypeName(), e);
+            }
+        }
+
+        @Override
+        boolean canOpen(Class<?> type) {
+            return isOpen(getModule(type), getPackageName(type), getModule(Mockito.class));
+        }
+
+        @Override
+        boolean canAddRead(Class<?> type) {
+            return canRead(getModule(type), getModule(Mockito.class));
+        }
+    }
+
+    private static class MockitoMockClassLoader extends ClassLoader {
+
+        private MockitoMockClassLoader(ClassLoader parent) {
+            super(parent);
+        }
+
+        private Map<TypeDescription, Class<?>> defineClasses(Map<TypeDescription, byte[]> types) {
+            Map<TypeDescription, Class<?>> loaded = new LinkedHashMap<>();
+            for (Entry<TypeDescription, byte[]> entry : types.entrySet()) {
+                Class<?> type =
+                        defineClass(
+                                entry.getKey().getName(),
+                                entry.getValue(),
+                                0,
+                                entry.getValue().length);
+                loaded.put(entry.getKey(), type);
+            }
+            return loaded;
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/PlatformUtils.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/PlatformUtils.java
new file mode 100644
index 0000000000..0fa235d3d7
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/PlatformUtils.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+/**
+ * Helpers for various platform detection mechanisms related to the ByteBuddy mock maker.
+ *
+ * @author Ashley Scopes
+ */
+final class PlatformUtils {
+    private PlatformUtils() {
+        // Static-only class.
+    }
+
+    static boolean isAndroidPlatform() {
+        return System.getProperty("java.specification.vendor", "")
+                .toLowerCase()
+                .contains("android");
+    }
+
+    static boolean isProbablyTermuxEnvironment() {
+        boolean isLinux = System.getProperty("os.name", "").equalsIgnoreCase("linux");
+        boolean isInTermuxData =
+                System.getProperty("java.home", "").toLowerCase().contains("/com.termux/");
+        return isLinux && isInTermuxData;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/StackTraceChecker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/StackTraceChecker.java
new file mode 100644
index 0000000000..18f92ba690
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/StackTraceChecker.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import java.util.function.Predicate;
+
+class StackTraceChecker implements Predicate<Class<?>> {
+
+    @Override
+    public boolean test(Class<?> type) {
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        for (int index = 1; index < stackTrace.length - 1; index++) {
+            if (!stackTrace[index].getClassName().startsWith("org.mockito.internal.")) {
+                if (stackTrace[index + 1].getMethodName().startsWith("<init>")) {
+                    try {
+                        if (!stackTrace[index + 1].getClassName().equals(type.getName())
+                                && type.isAssignableFrom(
+                                        Class.forName(
+                                                stackTrace[index + 1].getClassName(),
+                                                false,
+                                                type.getClassLoader()))) {
+                            return true;
+                        } else {
+                            break;
+                        }
+                    } catch (ClassNotFoundException ignored) {
+                        break;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/StackWalkerChecker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/StackWalkerChecker.java
new file mode 100644
index 0000000000..c16439dbcb
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/StackWalkerChecker.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+class StackWalkerChecker implements Predicate<Class<?>> {
+
+    private final Method stackWalkerGetInstance;
+    private final Method stackWalkerWalk;
+    private final Method stackWalkerStackFrameGetDeclaringClass;
+    private final Enum<?> stackWalkerOptionRetainClassReference;
+
+    StackWalkerChecker() throws Exception {
+        Class<?> stackWalker = Class.forName("java.lang.StackWalker");
+        @SuppressWarnings({"unchecked", "rawtypes"})
+        Class<? extends Enum> stackWalkerOption =
+                (Class<? extends Enum<?>>) Class.forName("java.lang.StackWalker$Option");
+        stackWalkerGetInstance = stackWalker.getMethod("getInstance", stackWalkerOption);
+        stackWalkerWalk = stackWalker.getMethod("walk", Function.class);
+        Class<?> stackWalkerStackFrame = Class.forName("java.lang.StackWalker$StackFrame");
+        stackWalkerStackFrameGetDeclaringClass =
+                stackWalkerStackFrame.getMethod("getDeclaringClass");
+        @SuppressWarnings("unchecked")
+        Enum<?> stackWalkerOptionRetainClassReference =
+                Enum.valueOf(stackWalkerOption, "RETAIN_CLASS_REFERENCE");
+        this.stackWalkerOptionRetainClassReference = stackWalkerOptionRetainClassReference;
+    }
+
+    static Predicate<Class<?>> orFallback() {
+        try {
+            return new StackWalkerChecker();
+        } catch (Exception e) {
+            return new StackTraceChecker();
+        }
+    }
+
+    @Override
+    public boolean test(Class<?> type) {
+        try {
+            Object walker =
+                    stackWalkerGetInstance.invoke(null, stackWalkerOptionRetainClassReference);
+            return (Boolean)
+                    stackWalkerWalk.invoke(
+                            walker,
+                            (Function<?, ?>)
+                                    stream -> {
+                                        Iterator<?> iterator = ((Stream<?>) stream).iterator();
+                                        while (iterator.hasNext()) {
+                                            try {
+                                                Object frame = iterator.next();
+                                                if (((Class<?>)
+                                                                stackWalkerStackFrameGetDeclaringClass
+                                                                        .invoke(frame))
+                                                        .getName()
+                                                        .startsWith("org.mockito.internal.")) {
+                                                    continue;
+                                                }
+                                                if (iterator.hasNext()) {
+                                                    Object next = iterator.next();
+                                                    Class<?> declaringClass =
+                                                            (Class<?>)
+                                                                    stackWalkerStackFrameGetDeclaringClass
+                                                                            .invoke(next);
+                                                    if (type != declaringClass
+                                                            && type.isAssignableFrom(
+                                                                    declaringClass)) {
+                                                        return true;
+                                                    } else {
+                                                        break;
+                                                    }
+                                                } else {
+                                                    break;
+                                                }
+                                            } catch (Exception ignored) {
+                                                return false;
+                                            }
+                                        }
+                                        return false;
+                                    });
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
new file mode 100644
index 0000000000..9e53822de6
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.Modifier;
+
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor;
+import org.mockito.internal.util.Platform;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Subclass based mock maker.
+ *
+ * This mock maker tries to create a subclass to represent a mock. It uses the given mock settings, that contains
+ * the type to mock, extra interfaces, and serialization support.
+ *
+ * <p>
+ * The type to mock has to be not final and not part of the JDK. The created mock will implement extra interfaces
+ * if any. And will implement <code>Serializable</code> if this settings is explicitly set.
+ */
+public class SubclassByteBuddyMockMaker implements ClassCreatingMockMaker {
+
+    private final BytecodeGenerator cachingMockBytecodeGenerator;
+
+    public SubclassByteBuddyMockMaker() {
+        this(ModuleHandler.make());
+    }
+
+    public SubclassByteBuddyMockMaker(ModuleHandler handler) {
+        cachingMockBytecodeGenerator =
+                new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(handler), false);
+    }
+
+    @Override
+    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+        Class<? extends T> mockedProxyType = createMockType(settings);
+
+        Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(settings);
+        T mockInstance = null;
+        try {
+            mockInstance = instantiator.newInstance(mockedProxyType);
+            MockAccess mockAccess = (MockAccess) mockInstance;
+            mockAccess.setMockitoInterceptor(new MockMethodInterceptor(handler, settings));
+
+            return ensureMockIsAssignableToMockedType(settings, mockInstance);
+        } catch (ClassCastException cce) {
+            throw new MockitoException(
+                    join(
+                            "ClassCastException occurred while creating the mockito mock :",
+                            "  class to mock : " + describeClass(settings.getTypeToMock()),
+                            "  created class : " + describeClass(mockedProxyType),
+                            "  proxy instance class : " + describeClass(mockInstance),
+                            "  instance creation by : " + instantiator.getClass().getSimpleName(),
+                            "",
+                            "You might experience classloading issues, please ask the mockito mailing-list.",
+                            ""),
+                    cce);
+        } catch (org.mockito.creation.instance.InstantiationException e) {
+            throw new MockitoException(
+                    "Unable to create mock instance of type '"
+                            + mockedProxyType.getSuperclass().getSimpleName()
+                            + "'",
+                    e);
+        }
+    }
+
+    @Override
+    public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
+        try {
+            return cachingMockBytecodeGenerator.mockClass(
+                    MockFeatures.withMockFeatures(
+                            settings.getTypeToMock(),
+                            settings.getExtraInterfaces(),
+                            settings.getSerializableMode(),
+                            settings.isStripAnnotations(),
+                            settings.getDefaultAnswer()));
+        } catch (Exception bytecodeGenerationFailed) {
+            throw prettifyFailure(settings, bytecodeGenerationFailed);
+        }
+    }
+
+    private static <T> T ensureMockIsAssignableToMockedType(
+            MockCreationSettings<T> settings, T mock) {
+        // Force explicit cast to mocked type here, instead of
+        // relying on the JVM to implicitly cast on the client call site.
+        // This allows us to catch earlier the ClassCastException earlier
+        Class<T> typeToMock = settings.getTypeToMock();
+        return typeToMock.cast(mock);
+    }
+
+    private <T> RuntimeException prettifyFailure(
+            MockCreationSettings<T> mockFeatures, Exception generationFailed) {
+        if (mockFeatures.getTypeToMock().isArray()) {
+            throw new MockitoException(
+                    join("Mockito cannot mock arrays: " + mockFeatures.getTypeToMock() + ".", ""),
+                    generationFailed);
+        }
+        if (Modifier.isPrivate(mockFeatures.getTypeToMock().getModifiers())) {
+            throw new MockitoException(
+                    join(
+                            "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+                            "Most likely it is due to mocking a private class that is not visible to Mockito",
+                            ""),
+                    generationFailed);
+        }
+        throw new MockitoException(
+                join(
+                        "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+                        "",
+                        "Mockito can only mock non-private & non-final classes, but the root cause of this error might be different.",
+                        "Please check the full stacktrace to understand what the issue is.",
+                        "If you're still not sure why you're getting this error, please open an issue on GitHub.",
+                        "",
+                        Platform.warnForVM(
+                                "IBM J9 VM",
+                                "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
+                                "Hotspot",
+                                ""),
+                        Platform.describe(),
+                        "",
+                        "Underlying exception : " + generationFailed),
+                generationFailed);
+    }
+
+    private static String describeClass(Class<?> type) {
+        return type == null
+                ? "null"
+                : "'"
+                        + type.getCanonicalName()
+                        + "', loaded by classloader : '"
+                        + type.getClassLoader()
+                        + "'";
+    }
+
+    private static String describeClass(Object instance) {
+        return instance == null ? "null" : describeClass(instance.getClass());
+    }
+
+    @Override
+    public MockHandler getHandler(Object mock) {
+        if (!(mock instanceof MockAccess)) {
+            return null;
+        }
+        return ((MockAccess) mock).getMockitoInterceptor().getMockHandler();
+    }
+
+    @Override
+    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+        ((MockAccess) mock).setMockitoInterceptor(new MockMethodInterceptor(newHandler, settings));
+    }
+
+    @Override
+    public TypeMockability isTypeMockable(final Class<?> type) {
+        return new TypeMockability() {
+            @Override
+            public boolean mockable() {
+                return !type.isPrimitive()
+                        && !Modifier.isFinal(type.getModifiers())
+                        && !TypeSupport.INSTANCE.isSealed(type);
+            }
+
+            @Override
+            public String nonMockableReason() {
+                if (mockable()) {
+                    return "";
+                }
+                if (type.isPrimitive()) {
+                    return "primitive type";
+                }
+                if (Modifier.isFinal(type.getModifiers())) {
+                    return "final class";
+                }
+                if (TypeSupport.INSTANCE.isSealed(type)) {
+                    return "sealed class";
+                }
+                return join("not handled type");
+            }
+        };
+    }
+
+    @Override
+    public void clearAllCaches() {
+        cachingMockBytecodeGenerator.clearAllCaches();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
new file mode 100644
index 0000000000..4701e4d140
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static java.lang.Thread.currentThread;
+import static net.bytebuddy.description.modifier.Visibility.PRIVATE;
+import static net.bytebuddy.dynamic.Transformer.ForMethod.withModifiers;
+import static net.bytebuddy.implementation.MethodDelegation.to;
+import static net.bytebuddy.implementation.attribute.MethodAttributeAppender.ForInstrumentedMethod.INCLUDING_RECEIVER;
+import static net.bytebuddy.matcher.ElementMatchers.any;
+import static net.bytebuddy.matcher.ElementMatchers.hasParameters;
+import static net.bytebuddy.matcher.ElementMatchers.hasType;
+import static net.bytebuddy.matcher.ElementMatchers.isEquals;
+import static net.bytebuddy.matcher.ElementMatchers.isHashCode;
+import static net.bytebuddy.matcher.ElementMatchers.isPackagePrivate;
+import static net.bytebuddy.matcher.ElementMatchers.returns;
+import static net.bytebuddy.matcher.ElementMatchers.whereAny;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.*;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.modifier.SynchronizationState;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.dynamic.loading.MultipleParentClassLoader;
+import net.bytebuddy.dynamic.scaffold.TypeValidation;
+import net.bytebuddy.implementation.FieldAccessor;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.implementation.attribute.MethodAttributeAppender;
+import net.bytebuddy.matcher.ElementMatcher;
+import net.bytebuddy.utility.GraalImageCode;
+import net.bytebuddy.utility.RandomString;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor;
+import org.mockito.internal.creation.bytebuddy.codegen.InjectionBase;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport.CrossClassLoaderSerializableMock;
+import org.mockito.internal.creation.bytebuddy.access.MockMethodInterceptor.DispatcherDefaultingToRealMethod;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+import org.mockito.mock.SerializableMode;
+
+class SubclassBytecodeGenerator implements BytecodeGenerator {
+
+    private static final String CODEGEN_PACKAGE =
+            "org.mockito.internal.creation.bytebuddy.codegen.";
+
+    private final ModuleHandler handler;
+    private final ByteBuddy byteBuddy;
+    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(ModuleHandler.make());
+    }
+
+    public SubclassBytecodeGenerator(ModuleHandler handler) {
+        this(handler, null, any());
+    }
+
+    SubclassBytecodeGenerator(
+            ModuleHandler handler,
+            Implementation readReplace,
+            ElementMatcher<? super MethodDescription> matcher) {
+        this.handler = handler;
+        this.readReplace = readReplace;
+        this.matcher = matcher;
+        byteBuddy = new ByteBuddy().with(TypeValidation.DISABLED);
+    }
+
+    private static boolean needsSamePackageClassLoader(MockFeatures<?> features) {
+        if (!Modifier.isPublic(features.mockedType.getModifiers())
+                || !features.mockedType.isInterface()) {
+            // The mocked type is package private or is not an interface and thus may contain
+            // package private methods.
+            return true;
+        }
+        if (hasNonPublicTypeReference(features.mockedType)) {
+            return true;
+        }
+
+        for (Class<?> iface : features.interfaces) {
+            if (!Modifier.isPublic(iface.getModifiers())) {
+                return true;
+            }
+            if (hasNonPublicTypeReference(iface)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean hasNonPublicTypeReference(Class<?> iface) {
+        for (Method method : iface.getMethods()) {
+            if (!Modifier.isPublic(method.getReturnType().getModifiers())) {
+                return true;
+            }
+            for (Class<?> param : method.getParameterTypes()) {
+                if (!Modifier.isPublic(param.getModifiers())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
+        MultipleParentClassLoader.Builder loaderBuilder =
+                new MultipleParentClassLoader.Builder()
+                        .appendMostSpecific(features.mockedType)
+                        .appendMostSpecific(features.interfaces)
+                        .appendMostSpecific(
+                                MockAccess.class, DispatcherDefaultingToRealMethod.class)
+                        .appendMostSpecific(
+                                MockMethodInterceptor.class,
+                                MockMethodInterceptor.ForHashCode.class,
+                                MockMethodInterceptor.ForEquals.class);
+        ClassLoader contextLoader = currentThread().getContextClassLoader();
+        boolean shouldIncludeContextLoader = true;
+        if (needsSamePackageClassLoader(features)) {
+            // For the generated class to access package-private methods, it must be defined by the
+            // same classloader as its type. All the other added classloaders are required to load
+            // the type; if the context classloader is a child of the mocked type's defining
+            // classloader, it will break a mock that would have worked. Check if the context class
+            // loader is a child of the classloader we'd otherwise use, and possibly skip it.
+            ClassLoader candidateLoader = loaderBuilder.build();
+            for (ClassLoader parent = contextLoader; parent != null; parent = parent.getParent()) {
+                if (parent == candidateLoader) {
+                    shouldIncludeContextLoader = false;
+                    break;
+                }
+            }
+        }
+        if (shouldIncludeContextLoader) {
+            loaderBuilder = loaderBuilder.appendMostSpecific(contextLoader);
+        }
+        ClassLoader classLoader = loaderBuilder.build();
+
+        // If Mockito does not need to create a new class loader and if a mock is not based on a JDK
+        // type, we attempt to define the mock class in the user runtime package to allow for
+        // mocking package private types and methods.
+        // This also requires that we are able to access the package of the mocked class either by
+        // override or explicit privilege given by the target package being opened to Mockito.
+        boolean localMock =
+                classLoader == features.mockedType.getClassLoader()
+                        && features.serializableMode != SerializableMode.ACROSS_CLASSLOADERS
+                        && !isComingFromJDK(features.mockedType)
+                        && !GraalImageCode.getCurrent().isDefined()
+                        && handler.canOpen(features.mockedType)
+                        && handler.canAddRead(features.mockedType);
+        String typeName;
+        if (localMock) {
+            typeName = features.mockedType.getName();
+        } else {
+            typeName = CODEGEN_PACKAGE + features.mockedType.getSimpleName();
+        }
+        String name =
+                String.format(
+                        "%s$%s$%s",
+                        typeName,
+                        "MockitoMock",
+                        GraalImageCode.getCurrent().isDefined()
+                                ? suffix(features)
+                                : RandomString.make());
+
+        if (localMock) {
+            handler.openFromTo(features.mockedType, MockAccess.class);
+            handler.readFromTo(features.mockedType, MockAccess.class);
+            handler.exportFromTo(features.mockedType, MockAccess.class);
+            handler.exportFromTo(MockAccess.class, features.mockedType);
+            for (Class<?> iFace : features.interfaces) {
+                handler.exportFromTo(iFace, features.mockedType);
+            }
+        } else {
+            assertVisibility(features.mockedType);
+            for (Class<?> iFace : features.interfaces) {
+                assertVisibility(iFace);
+            }
+            classLoader = handler.toCodegenLoader(classLoader);
+            handler.exportFromTo(MockAccess.class, classLoader);
+            handler.exportFromTo(features.mockedType, classLoader);
+            for (Class<?> iFace : features.interfaces) {
+                handler.exportFromTo(iFace, classLoader);
+            }
+        }
+        // Graal requires that the byte code of classes is identical what requires that interfaces
+        // are always defined in the exact same order. Therefore, we add an interface to the
+        // interface set if not mocking a class when Graal is active.
+        @SuppressWarnings("unchecked")
+        Class<T> target =
+                GraalImageCode.getCurrent().isDefined() && features.mockedType.isInterface()
+                        ? (Class<T>) Object.class
+                        : features.mockedType;
+        // If we create a mock for an interface with additional interfaces implemented, we do not
+        // want to preserve the annotations of either interface. The caching mechanism does not
+        // consider the order of these interfaces and the same mock class might be reused for
+        // either order. Also, it does not have clean semantics as annotations are not normally
+        // preserved for interfaces in Java.
+        Annotation[] annotationsOnType;
+        if (features.stripAnnotations) {
+            annotationsOnType = new Annotation[0];
+        } else if (!features.mockedType.isInterface() || features.interfaces.isEmpty()) {
+            annotationsOnType = features.mockedType.getAnnotations();
+        } else {
+            annotationsOnType = new Annotation[0];
+        }
+        DynamicType.Builder<T> builder =
+                byteBuddy
+                        .subclass(target)
+                        .name(name)
+                        .ignoreAlso(BytecodeGenerator.isGroovyMethod(false))
+                        .annotateType(annotationsOnType)
+                        .implement(
+                                new ArrayList<>(
+                                        GraalImageCode.getCurrent().isDefined()
+                                                ? sortedSerializable(
+                                                        features.interfaces,
+                                                        GraalImageCode.getCurrent().isDefined()
+                                                                        && features.mockedType
+                                                                                .isInterface()
+                                                                ? features.mockedType
+                                                                : void.class)
+                                                : features.interfaces))
+                        .method(matcher)
+                        .intercept(dispatcher)
+                        .transform(withModifiers(SynchronizationState.PLAIN))
+                        .attribute(
+                                features.stripAnnotations
+                                        ? MethodAttributeAppender.NoOp.INSTANCE
+                                        : INCLUDING_RECEIVER)
+                        .serialVersionUid(42L)
+                        .defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE)
+                        .implement(MockAccess.class)
+                        .intercept(FieldAccessor.ofBeanProperty())
+                        .method(isHashCode())
+                        .intercept(hashCode)
+                        .method(isEquals())
+                        .intercept(equals);
+        if (features.serializableMode == SerializableMode.ACROSS_CLASSLOADERS) {
+            builder =
+                    builder.implement(CrossClassLoaderSerializableMock.class)
+                            .intercept(writeReplace);
+        }
+        if (readReplace != null) {
+            builder =
+                    builder.defineMethod("readObject", void.class, Visibility.PRIVATE)
+                            .withParameters(ObjectInputStream.class)
+                            .throwing(ClassNotFoundException.class, IOException.class)
+                            .intercept(readReplace);
+        }
+        if (name.startsWith(CODEGEN_PACKAGE) || classLoader instanceof MultipleParentClassLoader) {
+            builder =
+                    builder.ignoreAlso(
+                            isPackagePrivate()
+                                    .or(returns(isPackagePrivate()))
+                                    .or(hasParameters(whereAny(hasType(isPackagePrivate())))));
+        }
+        ClassLoadingStrategy<ClassLoader> strategy;
+        if (localMock) {
+            strategy = handler.classLoadingStrategy(features.mockedType);
+        } else if (classLoader == MockAccess.class.getClassLoader()) {
+            strategy = handler.classLoadingStrategy(InjectionBase.class);
+        } else {
+            strategy = handler.classLoadingStrategy();
+        }
+        return builder.make().load(classLoader, strategy).getLoaded();
+    }
+
+    private static CharSequence suffix(MockFeatures<?> features) {
+        // Constructs a deterministic suffix for this mock to assure that mocks always carry the
+        // same name.
+        StringBuilder sb = new StringBuilder();
+        Set<String> names = new TreeSet<>();
+        names.add(features.mockedType.getName());
+        for (Class<?> type : features.interfaces) {
+            names.add(type.getName());
+        }
+        return sb.append(RandomString.hashOf(names.hashCode()))
+                .append(RandomString.hashOf(features.serializableMode.name().hashCode()))
+                .append(features.stripAnnotations ? "S" : "N");
+    }
+
+    private static Collection<? extends Type> sortedSerializable(
+            Collection<Class<?>> interfaces, Class<?> mockedType) {
+        SortedSet<Class<?>> types = new TreeSet<>(Comparator.comparing(Class::getName));
+        types.addAll(interfaces);
+        if (mockedType != void.class) {
+            types.add(mockedType);
+        }
+        types.add(Serializable.class);
+        return types;
+    }
+
+    @Override
+    public void mockClassStatic(Class<?> type) {
+        throw new MockitoException("The subclass byte code generator cannot create static mocks");
+    }
+
+    @Override
+    public void mockClassConstruction(Class<?> type) {
+        throw new MockitoException(
+                "The subclass byte code generator cannot create construction mocks");
+    }
+
+    private boolean isComingFromJDK(Class<?> type) {
+        // Comes from the manifest entry :
+        // Implementation-Title: Java Runtime Environment
+        // This entry is not necessarily present in every jar of the JDK
+        return (type.getPackage() != null
+                        && "Java Runtime Environment"
+                                .equalsIgnoreCase(type.getPackage().getImplementationTitle()))
+                || type.getName().startsWith("java.")
+                || type.getName().startsWith("javax.");
+    }
+
+    private static void assertVisibility(Class<?> type) {
+        if (!Modifier.isPublic(type.getModifiers())) {
+            throw new MockitoException(
+                    join(
+                            "Cannot create mock for " + type,
+                            "",
+                            "The type is not public and its mock class is loaded by a different class loader.",
+                            "This can have multiple reasons:",
+                            " - You are mocking a class with additional interfaces of another class loader",
+                            " - Mockito is loaded by a different class loader than the mocked type (e.g. with OSGi)",
+                            " - The thread's context class loader is different than the mock's class loader"));
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
new file mode 100644
index 0000000000..3a8af3afa7
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import java.lang.ref.ReferenceQueue;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import net.bytebuddy.TypeCache;
+import org.mockito.mock.SerializableMode;
+
+class TypeCachingBytecodeGenerator extends ReferenceQueue<ClassLoader>
+        implements BytecodeGenerator {
+    /**
+     * The size of the {@link #cacheLocks}.
+     * <p>Caution: This must match the {@link #CACHE_LOCK_MASK}.
+     */
+    private static final int CACHE_LOCK_SIZE = 16;
+
+    /**
+     * The mask to use to mask out the {@link MockitoMockKey#hashCode()} to find the {@link #cacheLocks}.
+     * <p>Caution: this must match the bits of the {@link #CACHE_LOCK_SIZE}.
+     */
+    private static final int CACHE_LOCK_MASK = 0x0F;
+
+    private final BytecodeGenerator bytecodeGenerator;
+
+    private final TypeCache<MockitoMockKey> typeCache;
+
+    private final ReadWriteLock lock = new ReentrantReadWriteLock();
+
+    /**
+     * This array contains {@link TypeCachingLock} instances, which are used as java monitor locks for
+     * {@link TypeCache#findOrInsert(ClassLoader, Object, Callable, Object)}.
+     * The locks spread the lock to acquire over multiple locks instead of using a single lock
+     * {@code BOOTSTRAP_LOCK} for all {@link MockitoMockKey}.
+     *
+     * <p>Note: We can't simply use the mockedType class lock as a lock,
+     * because the {@link MockitoMockKey}, will be the same for different mockTypes + interfaces.
+     *
+     * <p>#3035: Excessive locking in TypeCachingBytecodeGenerator#BOOTSTRAP_LOCK
+     */
+    private final TypeCachingLock[] cacheLocks;
+
+    public TypeCachingBytecodeGenerator(BytecodeGenerator bytecodeGenerator, boolean weak) {
+        this.bytecodeGenerator = bytecodeGenerator;
+        typeCache =
+                new TypeCache.WithInlineExpunction<>(
+                        weak ? TypeCache.Sort.WEAK : TypeCache.Sort.SOFT);
+
+        this.cacheLocks = new TypeCachingLock[CACHE_LOCK_SIZE];
+        for (int i = 0; i < CACHE_LOCK_SIZE; i++) {
+            cacheLocks[i] = new TypeCachingLock();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> Class<T> mockClass(final MockFeatures<T> params) {
+        lock.readLock().lock();
+        try {
+            Class<T> mockedType = params.mockedType;
+            ClassLoader classLoader = mockedType.getClassLoader();
+            MockitoMockKey key =
+                    new MockitoMockKey(
+                            mockedType,
+                            params.interfaces,
+                            params.serializableMode,
+                            params.stripAnnotations);
+            return (Class<T>)
+                    typeCache.findOrInsert(
+                            classLoader,
+                            key,
+                            () -> bytecodeGenerator.mockClass(params),
+                            getCacheLockForKey(key));
+        } catch (IllegalArgumentException exception) {
+            Throwable cause = exception.getCause();
+            if (cause instanceof RuntimeException) {
+                throw (RuntimeException) cause;
+            } else {
+                throw exception;
+            }
+        } finally {
+            lock.readLock().unlock();
+        }
+    }
+
+    /**
+     * Returns a {@link TypeCachingLock}, which locks the {@link TypeCache#findOrInsert(ClassLoader, Object, Callable, Object)}.
+     *
+     * @param key the key to lock
+     * @return the {@link TypeCachingLock} to use to lock the {@link TypeCache}
+     */
+    private TypeCachingLock getCacheLockForKey(MockitoMockKey key) {
+        int hashCode = key.hashCode();
+        // Try to spread some higher bits with XOR to lower bits, because we only use lower bits.
+        hashCode = hashCode ^ (hashCode >>> 16);
+        int index = hashCode & CACHE_LOCK_MASK;
+        return cacheLocks[index];
+    }
+
+    @Override
+    public void mockClassStatic(Class<?> type) {
+        bytecodeGenerator.mockClassStatic(type);
+    }
+
+    @Override
+    public void mockClassConstruction(Class<?> type) {
+        bytecodeGenerator.mockClassConstruction(type);
+    }
+
+    @Override
+    public void clearAllCaches() {
+        lock.writeLock().lock();
+        try {
+            typeCache.clear();
+            bytecodeGenerator.clearAllCaches();
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    private static final class TypeCachingLock {}
+
+    private static class MockitoMockKey extends TypeCache.SimpleKey {
+
+        private final SerializableMode serializableMode;
+        private final boolean stripAnnotations;
+
+        private MockitoMockKey(
+                Class<?> type,
+                Set<Class<?>> additionalType,
+                SerializableMode serializableMode,
+                boolean stripAnnotations) {
+            super(type, additionalType);
+            this.serializableMode = serializableMode;
+            this.stripAnnotations = stripAnnotations;
+        }
+
+        @Override
+        public boolean equals(Object object) {
+            if (this == object) {
+                return true;
+            }
+            if (object == null || getClass() != object.getClass()) {
+                return false;
+            }
+            if (!super.equals(object)) {
+                return false;
+            }
+            MockitoMockKey that = (MockitoMockKey) object;
+            return stripAnnotations == that.stripAnnotations
+                    && serializableMode.equals(that.serializableMode);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = super.hashCode();
+            result = 31 * result + (stripAnnotations ? 1 : 0);
+            result = 31 * result + serializableMode.hashCode();
+            return result;
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/TypeSupport.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/TypeSupport.java
new file mode 100644
index 0000000000..17df601f9b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/TypeSupport.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import org.mockito.exceptions.base.MockitoException;
+
+import java.lang.reflect.Method;
+
+class TypeSupport {
+
+    static final TypeSupport INSTANCE;
+
+    static {
+        Method isSealed;
+        try {
+            isSealed = Class.class.getMethod("isSealed");
+        } catch (NoSuchMethodException ignored) {
+            isSealed = null;
+        }
+        INSTANCE = new TypeSupport(isSealed);
+    }
+
+    private final Method isSealed;
+
+    private TypeSupport(Method isSealed) {
+        this.isSealed = isSealed;
+    }
+
+    boolean isSealed(Class<?> type) {
+        if (isSealed == null) {
+            return false;
+        }
+        try {
+            return (boolean) isSealed.invoke(type);
+        } catch (Throwable t) {
+            throw new MockitoException(
+                    "Failed to check if type is sealed using handle " + isSealed, t);
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockAccess.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/MockAccess.java
similarity index 83%
rename from src/main/java/org/mockito/internal/creation/bytebuddy/MockAccess.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/MockAccess.java
index 35698d8cf9..9a32f482eb 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockAccess.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/MockAccess.java
@@ -2,7 +2,7 @@
  * Copyright (c) 2016 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
-package org.mockito.internal.creation.bytebuddy;
+package org.mockito.internal.creation.bytebuddy.access;
 
 public interface MockAccess {
 
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/MockMethodInterceptor.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/MockMethodInterceptor.java
new file mode 100644
index 0000000000..ca0a77245a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/MockMethodInterceptor.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy.access;
+
+import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+
+import net.bytebuddy.implementation.bind.annotation.AllArguments;
+import net.bytebuddy.implementation.bind.annotation.Argument;
+import net.bytebuddy.implementation.bind.annotation.BindingPriority;
+import net.bytebuddy.implementation.bind.annotation.FieldValue;
+import net.bytebuddy.implementation.bind.annotation.Origin;
+import net.bytebuddy.implementation.bind.annotation.RuntimeType;
+import net.bytebuddy.implementation.bind.annotation.StubValue;
+import net.bytebuddy.implementation.bind.annotation.SuperCall;
+import net.bytebuddy.implementation.bind.annotation.This;
+import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+
+public class MockMethodInterceptor implements Serializable {
+
+    private static final long serialVersionUID = 7152947254057253027L;
+
+    private final MockHandler<?> handler;
+
+    private final MockCreationSettings<?> mockCreationSettings;
+
+    private final ByteBuddyCrossClassLoaderSerializationSupport serializationSupport;
+
+    private transient ThreadLocal<Object> weakReferenceHatch = new ThreadLocal<>();
+
+    public MockMethodInterceptor(
+            MockHandler<?> handler, MockCreationSettings<?> mockCreationSettings) {
+        this.handler = handler;
+        this.mockCreationSettings = mockCreationSettings;
+        serializationSupport = new ByteBuddyCrossClassLoaderSerializationSupport();
+    }
+
+    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
+        stream.defaultReadObject();
+        weakReferenceHatch = new ThreadLocal<>();
+    }
+
+    Object doIntercept(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod)
+            throws Throwable {
+        return doIntercept(mock, invokedMethod, arguments, realMethod, LocationFactory.create());
+    }
+
+    public Object doIntercept(
+            Object mock,
+            Method invokedMethod,
+            Object[] arguments,
+            RealMethod realMethod,
+            Location location)
+            throws Throwable {
+        // If the currently dispatched method is used in a hot path, typically a tight loop and if
+        // the mock is not used after the currently dispatched method, the JVM might attempt a
+        // garbage collection of the mock instance even before the execution of the current
+        // method is completed. Since we only reference the mock weakly from hereon after to avoid
+        // leaking the instance, it might therefore be garbage collected before the
+        // handler.handle(...) method completes. Since the handler method expects the mock to be
+        // present while a method call onto the mock is dispatched, this can lead to the problem
+        // described in GitHub #1802.
+        //
+        // To avoid this problem, we distract the JVM JIT by escaping the mock instance to a thread
+        // local field for the duration of the handler's dispatch.
+        //
+        // When dropping support for Java 8, instead of this hatch we should use an explicit fence
+        // https://docs.oracle.com/javase/9/docs/api/java/lang/ref/Reference.html#reachabilityFence-java.lang.Object-
+        weakReferenceHatch.set(mock);
+        try {
+            return handler.handle(
+                    createInvocation(
+                            mock,
+                            invokedMethod,
+                            arguments,
+                            realMethod,
+                            mockCreationSettings,
+                            location));
+        } finally {
+            weakReferenceHatch.remove();
+        }
+    }
+
+    public MockHandler<?> getMockHandler() {
+        return handler;
+    }
+
+    public ByteBuddyCrossClassLoaderSerializationSupport getSerializationSupport() {
+        return serializationSupport;
+    }
+
+    public static final class ForHashCode {
+
+        @SuppressWarnings("unused")
+        public static int doIdentityHashCode(@This Object thiz) {
+            return System.identityHashCode(thiz);
+        }
+
+        private ForHashCode() {}
+    }
+
+    public static class ForEquals {
+
+        @SuppressWarnings("unused")
+        public static boolean doIdentityEquals(@This Object thiz, @Argument(0) Object other) {
+            return thiz == other;
+        }
+    }
+
+    public static final class ForWriteReplace {
+
+        public static Object doWriteReplace(@This MockAccess thiz) throws ObjectStreamException {
+            return thiz.getMockitoInterceptor().getSerializationSupport().writeReplace(thiz);
+        }
+
+        private ForWriteReplace() {}
+    }
+
+    public static class DispatcherDefaultingToRealMethod {
+
+        @SuppressWarnings("unused")
+        @RuntimeType
+        @BindingPriority(BindingPriority.DEFAULT * 2)
+        public static Object interceptSuperCallable(
+                @This Object mock,
+                @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
+                @Origin Method invokedMethod,
+                @AllArguments Object[] arguments,
+                @SuperCall(serializableProxy = true) Callable<?> superCall)
+                throws Throwable {
+            if (interceptor == null) {
+                return superCall.call();
+            }
+            return interceptor.doIntercept(
+                    mock, invokedMethod, arguments, new RealMethod.FromCallable(superCall));
+        }
+
+        @SuppressWarnings("unused")
+        @RuntimeType
+        public static Object interceptAbstract(
+                @This Object mock,
+                @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
+                @StubValue Object stubValue,
+                @Origin Method invokedMethod,
+                @AllArguments Object[] arguments)
+                throws Throwable {
+            if (interceptor == null) {
+                return stubValue;
+            }
+            return interceptor.doIntercept(
+                    mock, invokedMethod, arguments, RealMethod.IsIllegal.INSTANCE);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/package-info.java
new file mode 100644
index 0000000000..45d9f66501
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/access/package-info.java
@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * ByteBuddy related stuff used for mock interaction.
+ */
+package org.mockito.internal.creation.bytebuddy.access;
diff --git a/src/main/java/org/mockito/codegen/InjectionBase.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/codegen/InjectionBase.java
similarity index 90%
rename from src/main/java/org/mockito/codegen/InjectionBase.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/codegen/InjectionBase.java
index b582c3b51d..3f11aad109 100644
--- a/src/main/java/org/mockito/codegen/InjectionBase.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/codegen/InjectionBase.java
@@ -2,7 +2,7 @@
  * Copyright (c) 2007 Mockito contributors
  * This program is made available under the terms of the MIT License.
  */
-package org.mockito.codegen;
+package org.mockito.internal.creation.bytebuddy.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.
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/codegen/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/codegen/package-info.java
new file mode 100644
index 0000000000..e35387de53
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/codegen/package-info.java
@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * ByteBuddy package for generated types.
+ */
+package org.mockito.internal.creation.bytebuddy.codegen;
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java
new file mode 100644
index 0000000000..82db0ba5db
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy.inject;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+public abstract class MockMethodDispatcher {
+
+    static {
+        ClassLoader classLoader = MockMethodDispatcher.class.getClassLoader();
+        if (classLoader != null) {
+            // Do not use Mockito classes in here as this is executed on the boot loader.
+            throw new IllegalStateException(
+                    MockMethodDispatcher.class.getName()
+                            + " is not loaded by the bootstrap class loader but by an instance of "
+                            + classLoader.getClass().getName()
+                            + ".\n\nThis causes the inline mock maker to not work as expected. "
+                            + "Please contact the maintainer of this class loader implementation "
+                            + "to assure that this class is never loaded by another class loader. "
+                            + "The bootstrap class loader must always be queried first for this "
+                            + "class for Mockito's inline mock maker to function correctly.");
+        }
+    }
+
+    private static final ConcurrentMap<String, MockMethodDispatcher> DISPATCHERS =
+            new ConcurrentHashMap<>();
+
+    public static MockMethodDispatcher get(String identifier, Object mock) {
+        if (mock == DISPATCHERS) {
+            // Avoid endless loop if ConcurrentHashMap was redefined to check for being a mock.
+            return null;
+        } else {
+            return DISPATCHERS.get(identifier);
+        }
+    }
+
+    public static MockMethodDispatcher getStatic(String identifier, Class<?> type) {
+        if (MockMethodDispatcher.class.isAssignableFrom(type) || type == ConcurrentHashMap.class) {
+            // Avoid endless loop for lookups of self.
+            return null;
+        } else {
+            return DISPATCHERS.get(identifier);
+        }
+    }
+
+    public static void set(String identifier, MockMethodDispatcher dispatcher) {
+        DISPATCHERS.putIfAbsent(identifier, dispatcher);
+    }
+
+    @SuppressWarnings("unused")
+    public static boolean isConstructorMock(String identifier, Class<?> type) {
+        return DISPATCHERS.get(identifier).isConstructorMock(type);
+    }
+
+    public abstract boolean isConstructorMock(Class<?> type);
+
+    @SuppressWarnings("unused")
+    public static Object handleConstruction(
+            String identifier,
+            Class<?> type,
+            Object object,
+            Object[] arguments,
+            String[] parameterTypeNames) {
+        return DISPATCHERS
+                .get(identifier)
+                .handleConstruction(type, object, arguments, parameterTypeNames);
+    }
+
+    public abstract Callable<?> handle(Object instance, Method origin, Object[] arguments)
+            throws Throwable;
+
+    public abstract Callable<?> handleStatic(Class<?> type, Method origin, Object[] arguments)
+            throws Throwable;
+
+    public abstract Object handleConstruction(
+            Class<?> type, Object object, Object[] arguments, String[] parameterTypeNames);
+
+    public abstract boolean isMock(Object instance);
+
+    public abstract boolean isMocked(Object instance);
+
+    public abstract boolean isMockedStatic(Class<?> type);
+
+    public abstract boolean isOverridden(Object instance, Method origin);
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/creation/bytebuddy/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java b/mockito-core/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
new file mode 100644
index 0000000000..30094c58b8
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.instance;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.creation.instance.InstantiationException;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.Primitives;
+import org.mockito.plugins.MemberAccessor;
+
+public class ConstructorInstantiator implements Instantiator {
+
+    /**
+     * Whether or not the constructors used for creating an object refer to an outer instance or not.
+     * This member is only used to for constructing error messages.
+     * If an outer inject exists, it would be the first ([0]) element of the {@link #constructorArgs} array.
+     */
+    private final boolean hasOuterClassInstance;
+
+    private final Object[] constructorArgs;
+
+    public ConstructorInstantiator(boolean hasOuterClassInstance, Object... constructorArgs) {
+        this.hasOuterClassInstance = hasOuterClassInstance;
+        this.constructorArgs = constructorArgs;
+    }
+
+    @Override
+    public <T> T newInstance(Class<T> cls) {
+        return withParams(cls, constructorArgs);
+    }
+
+    private <T> T withParams(Class<T> cls, Object... params) {
+        List<Constructor<?>> matchingConstructors = new LinkedList<>();
+        try {
+            for (Constructor<?> constructor : cls.getDeclaredConstructors()) {
+                Class<?>[] types = constructor.getParameterTypes();
+                if (paramsMatch(types, params)) {
+                    evaluateConstructor(matchingConstructors, constructor);
+                }
+            }
+
+            if (matchingConstructors.size() == 1) {
+                return invokeConstructor(matchingConstructors.get(0), params);
+            }
+        } catch (Exception e) {
+            throw paramsException(cls, e);
+        }
+        if (matchingConstructors.isEmpty()) {
+            throw noMatchingConstructor(cls);
+        } else {
+            throw multipleMatchingConstructors(cls, matchingConstructors);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T invokeConstructor(Constructor<?> constructor, Object... params)
+            throws java.lang.InstantiationException,
+                    IllegalAccessException,
+                    InvocationTargetException {
+        MemberAccessor accessor = Plugins.getMemberAccessor();
+        return (T) accessor.newInstance(constructor, params);
+    }
+
+    private InstantiationException paramsException(Class<?> cls, Exception e) {
+        return new InstantiationException(
+                join(
+                        "Unable to create instance of '" + cls.getSimpleName() + "'.",
+                        "Please ensure the target class has "
+                                + constructorArgsString()
+                                + " and executes cleanly."),
+                e);
+    }
+
+    private String constructorArgTypes() {
+        int argPos = 0;
+        if (hasOuterClassInstance) {
+            ++argPos;
+        }
+        String[] constructorArgTypes = new String[constructorArgs.length - argPos];
+        for (int i = argPos; i < constructorArgs.length; ++i) {
+            constructorArgTypes[i - argPos] =
+                    constructorArgs[i] == null ? null : constructorArgs[i].getClass().getName();
+        }
+        return Arrays.toString(constructorArgTypes);
+    }
+
+    private InstantiationException noMatchingConstructor(Class<?> cls) {
+        String constructorString = constructorArgsString();
+        String outerInstanceHint = "";
+        if (hasOuterClassInstance) {
+            outerInstanceHint = " and provided outer instance is correct";
+        }
+        return new InstantiationException(
+                join(
+                        "Unable to create instance of '" + cls.getSimpleName() + "'.",
+                        "Please ensure that the target class has "
+                                + constructorString
+                                + outerInstanceHint
+                                + "."),
+                null);
+    }
+
+    private String constructorArgsString() {
+        String constructorString;
+        if (constructorArgs.length == 0 || (hasOuterClassInstance && constructorArgs.length == 1)) {
+            constructorString = "a 0-arg constructor";
+        } else {
+            constructorString =
+                    "a constructor that matches these argument types: " + constructorArgTypes();
+        }
+        return constructorString;
+    }
+
+    private InstantiationException multipleMatchingConstructors(
+            Class<?> cls, List<Constructor<?>> constructors) {
+        return new InstantiationException(
+                join(
+                        "Unable to create instance of '" + cls.getSimpleName() + "'.",
+                        "Multiple constructors could be matched to arguments of types "
+                                + constructorArgTypes()
+                                + ":",
+                        join("", " - ", constructors),
+                        "If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.",
+                        "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.",
+                        "See https://github.com/mockito/mockito/issues/685"),
+                null);
+    }
+
+    private static boolean paramsMatch(Class<?>[] types, Object[] params) {
+        if (params.length != types.length) {
+            return false;
+        }
+        for (int i = 0; i < params.length; i++) {
+            if (params[i] == null) {
+                if (types[i].isPrimitive()) {
+                    return false;
+                }
+            } else if ((!types[i].isPrimitive() && !types[i].isInstance(params[i]))
+                    || (types[i].isPrimitive()
+                            && !types[i].equals(
+                                    Primitives.primitiveTypeOf(params[i].getClass())))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Evalutes {@code constructor} against the currently found {@code matchingConstructors} and determines if
+     * it's a better match to the given arguments, a worse match, or an equivalently good match.
+     * <p>
+     * This method tries to emulate the behavior specified in
+     * <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.12.2">JLS 15.12.2. Compile-Time
+     * Step 2: Determine Method Signature</a>. A constructor X is deemed to be a better match than constructor Y to the
+     * given argument list if they are both applicable, constructor X has at least one parameter than is more specific
+     * than the corresponding parameter of constructor Y, and constructor Y has no parameter than is more specific than
+     * the corresponding parameter in constructor X.
+     * </p>
+     * <p>
+     * If {@code constructor} is a better match than the constructors in the {@code matchingConstructors} list, the list
+     * is cleared, and it's added to the list as a singular best matching constructor (so far).<br/>
+     * If {@code constructor} is an equivalently good of a match as the constructors in the {@code matchingConstructors}
+     * list, it's added to the list.<br/>
+     * If {@code constructor} is a worse match than the constructors in the {@code matchingConstructors} list, the list
+     * will remain unchanged.
+     * </p>
+     *
+     * @param matchingConstructors A list of equivalently best matching constructors found so far
+     * @param constructor The constructor to be evaluated against this list
+     */
+    private void evaluateConstructor(
+            List<Constructor<?>> matchingConstructors, Constructor<?> constructor) {
+        boolean newHasBetterParam = false;
+        boolean existingHasBetterParam = false;
+
+        Class<?>[] paramTypes = constructor.getParameterTypes();
+        for (int i = 0; i < paramTypes.length; ++i) {
+            Class<?> paramType = paramTypes[i];
+            if (!paramType.isPrimitive()) {
+                for (Constructor<?> existingCtor : matchingConstructors) {
+                    Class<?> existingParamType = existingCtor.getParameterTypes()[i];
+                    if (paramType != existingParamType) {
+                        if (paramType.isAssignableFrom(existingParamType)) {
+                            existingHasBetterParam = true;
+                        } else {
+                            newHasBetterParam = true;
+                        }
+                    }
+                }
+            }
+        }
+        if (!existingHasBetterParam) {
+            matchingConstructors.clear();
+        }
+        if (newHasBetterParam || !existingHasBetterParam) {
+            matchingConstructors.add(constructor);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java b/mockito-core/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
new file mode 100644
index 0000000000..af071bfb36
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.instance;
+
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InstantiatorProvider2;
+
+public class DefaultInstantiatorProvider implements InstantiatorProvider2 {
+
+    private static final Instantiator INSTANCE = new ObjenesisInstantiator();
+
+    @Override
+    public Instantiator getInstantiator(MockCreationSettings<?> settings) {
+        if (settings != null && settings.getConstructorArgs() != null) {
+            return new ConstructorInstantiator(
+                    settings.getOuterClassInstance() != null, settings.getConstructorArgs());
+        } else {
+            return INSTANCE;
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java b/mockito-core/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
new file mode 100644
index 0000000000..deffbe9d51
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.instance;
+
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.configuration.GlobalConfiguration;
+import org.objenesis.ObjenesisStd;
+
+class ObjenesisInstantiator implements Instantiator {
+
+    // TODO: in order to provide decent exception message when objenesis is not found,
+    // have a constructor in this class that tries to instantiate ObjenesisStd and if it fails then
+    // show decent exception that dependency is missing
+    // TODO: for the same reason catch and give better feedback when hamcrest core is not found.
+    private final ObjenesisStd objenesis =
+            new ObjenesisStd(new GlobalConfiguration().enableClassCache());
+
+    @Override
+    public <T> T newInstance(Class<T> cls) {
+        return objenesis.newInstance(cls);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/creation/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/creation/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/proxy/InvokeDefaultProxy.java b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/InvokeDefaultProxy.java
new file mode 100644
index 0000000000..41f808ad79
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/InvokeDefaultProxy.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.util.Platform;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+class InvokeDefaultProxy implements ProxyRealMethod {
+
+    private final Method invokeDefault;
+
+    InvokeDefaultProxy() throws Throwable {
+        invokeDefault =
+                InvocationHandler.class.getMethod(
+                        "invokeDefault", Object.class, Method.class, Object[].class);
+    }
+
+    @Override
+    public RealMethod resolve(Object proxy, Method method, Object[] args) {
+        return new InvokeDefaultRealMethod(proxy, method, args);
+    }
+
+    private class InvokeDefaultRealMethod implements RealMethod, Serializable {
+
+        private static final long serialVersionUID = -1;
+
+        private final Object proxy;
+        private final SerializableMethod serializableMethod;
+        private final Object[] args;
+
+        private InvokeDefaultRealMethod(Object proxy, Method method, Object[] args) {
+            this.proxy = proxy;
+            this.serializableMethod = new SerializableMethod(method);
+            this.args = args;
+        }
+
+        @Override
+        public boolean isInvokable() {
+            return true;
+        }
+
+        @Override
+        public Object invoke() throws Throwable {
+            try {
+                return invokeDefault.invoke(null, proxy, serializableMethod.getJavaMethod(), args);
+            } catch (InvocationTargetException e) {
+                throw e.getTargetException();
+            } catch (IllegalAccessException | IllegalArgumentException e) {
+                throw new MockitoException(
+                        join(
+                                "Failed to access default method or invoked method with illegal arguments",
+                                "",
+                                "Method "
+                                        + serializableMethod.getJavaMethod()
+                                        + " could not be delegated, this is not supposed to happen",
+                                Platform.describe()),
+                        e);
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/proxy/MethodHandleProxy.java b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/MethodHandleProxy.java
new file mode 100644
index 0000000000..068f7233a5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/MethodHandleProxy.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.mockito.internal.SuppressSignatureCheck;
+import org.mockito.internal.invocation.RealMethod;
+
+import java.io.Serializable;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+@SuppressSignatureCheck
+class MethodHandleProxy implements ProxyRealMethod {
+
+    private final MethodHandles.Lookup lookup;
+
+    MethodHandleProxy() throws Throwable {
+        lookup = MethodHandles.lookup();
+    }
+
+    @Override
+    public RealMethod resolve(Object proxy, Method method, Object[] args) {
+        try {
+            return new MethodHandleRealMethod(
+                    lookup.findSpecial(
+                                    method.getDeclaringClass(),
+                                    method.getName(),
+                                    MethodType.methodType(
+                                            method.getReturnType(), method.getParameterTypes()),
+                                    method.getDeclaringClass())
+                            .bindTo(proxy),
+                    args);
+        } catch (Throwable ignored) {
+            return RealMethod.IsIllegal.INSTANCE;
+        }
+    }
+
+    @SuppressSignatureCheck
+    static class LegacyVersion implements ProxyRealMethod {
+
+        private final Constructor<MethodHandles.Lookup> constructor;
+
+        LegacyVersion() throws Throwable {
+            try {
+                Class.forName("java.lang.Module");
+                throw new RuntimeException("Must not be used when modules are available");
+            } catch (ClassNotFoundException ignored) {
+            }
+            constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class);
+            constructor.setAccessible(true);
+        }
+
+        @Override
+        public RealMethod resolve(Object proxy, Method method, Object[] args) {
+            try {
+                return new MethodHandleRealMethod(
+                        constructor
+                                .newInstance(method.getDeclaringClass())
+                                .in(method.getDeclaringClass())
+                                .unreflectSpecial(method, method.getDeclaringClass())
+                                .bindTo(proxy),
+                        args);
+            } catch (Throwable ignored) {
+                return RealMethod.IsIllegal.INSTANCE;
+            }
+        }
+    }
+
+    @SuppressSignatureCheck
+    private static class MethodHandleRealMethod implements RealMethod, Serializable {
+
+        private static final long serialVersionUID = -1;
+
+        private final MethodHandle handle;
+        private final Object[] args;
+
+        private MethodHandleRealMethod(MethodHandle handle, Object[] args) {
+            this.handle = handle;
+            this.args = args;
+        }
+
+        @Override
+        public boolean isInvokable() {
+            return true;
+        }
+
+        @Override
+        public Object invoke() throws Throwable {
+            return handle.invokeWithArguments(args);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/proxy/ProxyMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/ProxyMockMaker.java
new file mode 100644
index 0000000000..88e6886111
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/ProxyMockMaker.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.internal.util.Platform;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockMaker;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
+import static org.mockito.internal.util.StringUtil.join;
+
+/**
+ * A mock maker that is using the {@link Proxy} utility and is therefore only capable of mocking interfaces but
+ * does not rely on manual byte code generation but only uses official and public Java API.
+ */
+public class ProxyMockMaker implements MockMaker {
+
+    private static final Object[] EMPTY = new Object[0];
+
+    private final ProxyRealMethod proxyRealMethod = ProxyRealMethod.make();
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+        boolean object = settings.getTypeToMock() == Object.class;
+        Class<?>[] ifaces = new Class<?>[settings.getExtraInterfaces().size() + (object ? 0 : 1)];
+        int index = 0;
+        if (!object) {
+            ifaces[index++] = settings.getTypeToMock();
+        }
+        ClassLoader classLoader = settings.getTypeToMock().getClassLoader();
+        for (Class<?> iface : settings.getExtraInterfaces()) {
+            ifaces[index++] = iface;
+            classLoader = resolveCommonClassLoader(classLoader, iface);
+        }
+        return (T)
+                Proxy.newProxyInstance(
+                        resolveCommonClassLoader(classLoader, ProxyMockMaker.class),
+                        ifaces,
+                        new MockInvocationHandler(handler, settings));
+    }
+
+    private static ClassLoader resolveCommonClassLoader(ClassLoader mostSpecific, Class<?> type) {
+        if (mostSpecific == null) {
+            return type.getClassLoader();
+        }
+        ClassLoader candidate = type.getClassLoader();
+        if (candidate == null || mostSpecific == candidate) {
+            return mostSpecific;
+        }
+        while (candidate != null) {
+            if (candidate == mostSpecific) {
+                return type.getClassLoader();
+            }
+            candidate = candidate.getParent();
+        }
+        candidate = mostSpecific;
+        while (candidate != null) {
+            if (candidate == type.getClassLoader()) {
+                return mostSpecific;
+            }
+            candidate = candidate.getParent();
+        }
+        return new CommonClassLoader(mostSpecific, type.getClassLoader());
+    }
+
+    @Override
+    public MockHandler getHandler(Object mock) {
+        if (!Proxy.isProxyClass(mock.getClass())) {
+            return null;
+        }
+        InvocationHandler handler = Proxy.getInvocationHandler(mock);
+        if (!(handler instanceof MockInvocationHandler)) {
+            return null;
+        }
+        return ((MockInvocationHandler) handler).handler.get();
+    }
+
+    @Override
+    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+        ((MockInvocationHandler) Proxy.getInvocationHandler(mock)).handler.set(newHandler);
+    }
+
+    @Override
+    public TypeMockability isTypeMockable(Class<?> type) {
+        return new TypeMockability() {
+            @Override
+            public boolean mockable() {
+                return type.isInterface() || type == Object.class;
+            }
+
+            @Override
+            public String nonMockableReason() {
+                return mockable() ? "" : "non-interface";
+            }
+        };
+    }
+
+    private class MockInvocationHandler implements InvocationHandler {
+
+        private final AtomicReference<MockHandler<?>> handler;
+
+        private final MockCreationSettings<?> settings;
+
+        private MockInvocationHandler(MockHandler<?> handler, MockCreationSettings<?> settings) {
+            this.handler = new AtomicReference<>(handler);
+            this.settings = settings;
+        }
+
+        @Override
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            if (args == null) {
+                args = EMPTY;
+            }
+            if (method.getDeclaringClass() == Object.class) {
+                switch (method.getName()) {
+                    case "hashCode":
+                        return System.identityHashCode(proxy);
+                    case "equals":
+                        return proxy == args[0];
+                    case "toString":
+                        break;
+                    default:
+                        throw new MockitoException(
+                                join(
+                                        "Unexpected overridable method of Object class found",
+                                        "",
+                                        "The method "
+                                                + method
+                                                + " was not expected to be declared. Either your JVM build offers "
+                                                + "non-official API or the current functionality is not supported",
+                                        Platform.describe()));
+                }
+            }
+            RealMethod realMethod;
+            if (Modifier.isAbstract(method.getModifiers())) {
+                realMethod = RealMethod.IsIllegal.INSTANCE;
+            } else {
+                realMethod = proxyRealMethod.resolve(proxy, method, args);
+            }
+            return handler.get()
+                    .handle(
+                            createInvocation(
+                                    proxy,
+                                    method,
+                                    args,
+                                    realMethod,
+                                    settings,
+                                    LocationFactory.create()));
+        }
+    }
+
+    private static class CommonClassLoader extends ClassLoader {
+
+        private final ClassLoader left, right;
+
+        private CommonClassLoader(ClassLoader left, ClassLoader right) {
+            super(null);
+            this.left = left;
+            this.right = right;
+        }
+
+        @Override
+        public Class<?> loadClass(String name) throws ClassNotFoundException {
+            try {
+                return left.loadClass(name);
+            } catch (ClassNotFoundException ignored) {
+                return right.loadClass(name);
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/proxy/ProxyRealMethod.java b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/ProxyRealMethod.java
new file mode 100644
index 0000000000..a6f140de1d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/ProxyRealMethod.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.mockito.internal.invocation.RealMethod;
+
+import java.lang.reflect.Method;
+
+interface ProxyRealMethod {
+
+    RealMethod resolve(Object proxy, Method method, Object[] args);
+
+    static ProxyRealMethod make() {
+        // From Java 16 on, there is a standard API for invoking a default method from an invocation
+        // handler.
+        try {
+            return new InvokeDefaultProxy();
+        } catch (Throwable ignored) {
+        }
+        // Java 8 does not yet allow special method invocation via proxies. Therefore, we need to
+        // deep reflect what is no longer allowed after Java 8.
+        try {
+            return new MethodHandleProxy.LegacyVersion();
+        } catch (Throwable ignored) {
+        }
+        // Between Java 9 and 15, a default method can be invoked via regular method handle
+        // invocation.
+        try {
+            return new MethodHandleProxy();
+        } catch (Throwable ignored) {
+        }
+        // Nothing works, this might happen on Android where method handles are not supported on old
+        // versions. Default methods cannot be invoked.
+        return (proxy, method, args) -> RealMethod.IsIllegal.INSTANCE;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/proxy/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/package-info.java
new file mode 100644
index 0000000000..0649d3ba57
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/proxy/package-info.java
@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * Mock makers based on the {@link java.lang.reflect.Proxy} utility.
+ */
+package org.mockito.internal.creation.proxy;
diff --git a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java b/mockito-core/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
similarity index 76%
rename from src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
index 6501c95393..253ca99684 100644
--- a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
@@ -5,6 +5,7 @@
 package org.mockito.internal.creation.settings;
 
 import java.io.Serializable;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
@@ -17,39 +18,47 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
+import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 
 public class CreationSettings<T> implements MockCreationSettings<T>, Serializable {
     private static final long serialVersionUID = -6789800638070123629L;
 
     protected Class<T> typeToMock;
-    protected Set<Class<?>> extraInterfaces = new LinkedHashSet<Class<?>>();
+    protected transient Type genericTypeToMock;
+    protected Set<Class<?>> extraInterfaces = new LinkedHashSet<>();
     protected String name;
     protected Object spiedInstance;
     protected Answer<Object> defaultAnswer;
     protected MockName mockName;
     protected SerializableMode serializableMode = SerializableMode.NONE;
-    protected List<InvocationListener> invocationListeners = new ArrayList<InvocationListener>();
+    protected List<InvocationListener> invocationListeners = new ArrayList<>();
 
-    //Other listeners in this class may also need concurrency-safe implementation. However, no issue was reported about it.
-    // If we do it, we need to understand usage patterns and choose the right concurrent implementation.
-    protected List<StubbingLookupListener> stubbingLookupListeners = new CopyOnWriteArrayList<StubbingLookupListener>();
+    // Other listeners in this class may also need concurrency-safe implementation. However, no
+    // issue was reported about it.
+    // If we do it, we need to understand usage patterns and choose the right concurrent
+    // implementation.
+    protected List<StubbingLookupListener> stubbingLookupListeners = new CopyOnWriteArrayList<>();
 
-    protected List<VerificationStartedListener> verificationStartedListeners = new LinkedList<VerificationStartedListener>();
+    protected List<VerificationStartedListener> verificationStartedListeners = new LinkedList<>();
     protected boolean stubOnly;
     protected boolean stripAnnotations;
     private boolean useConstructor;
     private Object outerClassInstance;
     private Object[] constructorArgs;
-    protected boolean lenient;
+    protected Strictness strictness = null;
+    protected String mockMaker;
+    protected MockType mockType;
 
     public CreationSettings() {}
 
     @SuppressWarnings("unchecked")
     public CreationSettings(CreationSettings copy) {
-        //TODO can we have a reflection test here? We had a couple of bugs here in the past.
+        // TODO can we have a reflection test here? We had a couple of bugs here in the past.
         this.typeToMock = copy.typeToMock;
+        this.genericTypeToMock = copy.genericTypeToMock;
         this.extraInterfaces = copy.extraInterfaces;
         this.name = copy.name;
         this.spiedInstance = copy.spiedInstance;
@@ -63,8 +72,10 @@ public CreationSettings(CreationSettings copy) {
         this.useConstructor = copy.isUsingConstructor();
         this.outerClassInstance = copy.getOuterClassInstance();
         this.constructorArgs = copy.getConstructorArgs();
-        this.lenient = copy.lenient;
+        this.strictness = copy.strictness;
         this.stripAnnotations = copy.stripAnnotations;
+        this.mockMaker = copy.mockMaker;
+        this.mockType = copy.mockType;
     }
 
     @Override
@@ -77,6 +88,11 @@ public CreationSettings<T> setTypeToMock(Class<T> typeToMock) {
         return this;
     }
 
+    public CreationSettings<T> setGenericTypeToMock(Type genericTypeToMock) {
+        this.genericTypeToMock = genericTypeToMock;
+        return this;
+    }
+
     @Override
     public Set<Class<?>> getExtraInterfaces() {
         return extraInterfaces;
@@ -111,6 +127,7 @@ public CreationSettings<T> setMockName(MockName mockName) {
         return this;
     }
 
+    @Override
     public boolean isSerializable() {
         return serializableMode != SerializableMode.NONE;
     }
@@ -135,6 +152,7 @@ public List<VerificationStartedListener> getVerificationStartedListeners() {
         return verificationStartedListeners;
     }
 
+    @Override
     public List<StubbingLookupListener> getStubbingLookupListeners() {
         return stubbingLookupListeners;
     }
@@ -166,6 +184,30 @@ public boolean isStubOnly() {
 
     @Override
     public boolean isLenient() {
-        return lenient;
+        return strictness == Strictness.LENIENT;
+    }
+
+    @Override
+    public Strictness getStrictness() {
+        return strictness;
+    }
+
+    @Override
+    public String getMockMaker() {
+        return mockMaker;
+    }
+
+    @Override
+    public Type getGenericTypeToMock() {
+        return genericTypeToMock;
+    }
+
+    @Override
+    public MockType getMockType() {
+        return mockType;
+    }
+
+    public void setMockType(MockType mockType) {
+        this.mockType = mockType;
     }
 }
diff --git a/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java b/mockito-core/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
similarity index 80%
rename from src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
index 585a0c1b73..21642e4c0b 100644
--- a/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
@@ -4,7 +4,7 @@
  */
 package org.mockito.internal.creation.util;
 
-//TODO SF Replace with RealMethod and get rid of (possibly).
+// TODO SF Replace with RealMethod and get rid of (possibly).
 public interface MockitoMethodProxy {
     Object invokeSuper(Object target, Object[] arguments);
 }
diff --git a/src/main/java/org/mockito/internal/creation/util/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/util/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/creation/util/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/creation/util/package-info.java
diff --git a/src/main/java/org/mockito/internal/debugging/FindingsListener.java b/mockito-core/src/main/java/org/mockito/internal/debugging/FindingsListener.java
similarity index 100%
rename from src/main/java/org/mockito/internal/debugging/FindingsListener.java
rename to mockito-core/src/main/java/org/mockito/internal/debugging/FindingsListener.java
diff --git a/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java b/mockito-core/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
similarity index 77%
rename from src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
rename to mockito-core/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
index a643190cf0..d53abf107a 100644
--- a/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
@@ -5,10 +5,10 @@
 package org.mockito.internal.debugging;
 
 import java.util.Collection;
-import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
 
 import org.mockito.Mockito;
-import org.mockito.internal.util.collections.ListUtil;
 import org.mockito.invocation.Invocation;
 import org.mockito.stubbing.Stubbing;
 
@@ -26,22 +26,21 @@ public String printInvocations(Object mock) {
 
         StringBuilder sb = new StringBuilder();
         int x = 1;
-        for(Invocation i:invocations) {
+        for (Invocation i : invocations) {
             if (x == 1) {
                 sb.append("[Mockito] Interactions of: ").append(mock).append("\n");
             }
-            sb.append(" ").append(x++).append(". ").append(i.toString()).append("\n");
+            sb.append(" ").append(x++).append(". ").append(i).append("\n");
             sb.append("  ").append(i.getLocation()).append("\n");
             if (i.stubInfo() != null) {
                 sb.append("   - stubbed ").append(i.stubInfo().stubbedAt()).append("\n");
             }
         }
 
-        LinkedList<Stubbing> unused = ListUtil.filter(stubbings, new ListUtil.Filter<Stubbing>() {
-            public boolean isOut(Stubbing s) {
-                return s.wasUsed();
-            }
-        });
+        List<Stubbing> unused =
+                stubbings.stream()
+                        .filter(stubbing -> !stubbing.wasUsed())
+                        .collect(Collectors.toList());
 
         if (unused.isEmpty()) {
             return sb.toString();
@@ -49,7 +48,7 @@ public boolean isOut(Stubbing s) {
         sb.append("[Mockito] Unused stubbings of: ").append(mock).append("\n");
 
         x = 1;
-        for(Stubbing s:stubbings) {
+        for (Stubbing s : stubbings) {
             sb.append(" ").append(x++).append(". ").append(s.getInvocation()).append("\n");
             sb.append("  - stubbed ").append(s.getInvocation().getLocation()).append("\n");
         }
diff --git a/mockito-core/src/main/java/org/mockito/internal/debugging/Java8LocationImpl.java b/mockito-core/src/main/java/org/mockito/internal/debugging/Java8LocationImpl.java
new file mode 100644
index 0000000000..e8ee387c0a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/Java8LocationImpl.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import java.io.Serializable;
+
+import org.mockito.internal.exceptions.stacktrace.StackTraceFilter;
+import org.mockito.invocation.Location;
+
+class Java8LocationImpl implements Location, Serializable {
+
+    private static final long serialVersionUID = -9054861157390980624L;
+    // Limit the amount of objects being created, as this class is heavily instantiated:
+    private static final StackTraceFilter stackTraceFilter = new StackTraceFilter();
+
+    private String stackTraceLine;
+    private String sourceFile;
+
+    public Java8LocationImpl(Throwable stackTraceHolder, boolean isInline) {
+        this(stackTraceFilter, stackTraceHolder, isInline);
+    }
+
+    private Java8LocationImpl(
+            StackTraceFilter stackTraceFilter, Throwable stackTraceHolder, boolean isInline) {
+        computeStackTraceInformation(stackTraceFilter, stackTraceHolder, isInline);
+    }
+
+    @Override
+    public String toString() {
+        return stackTraceLine;
+    }
+
+    /**
+     * Eagerly compute the stacktrace line from the stackTraceHolder. Storing the Throwable is
+     * memory-intensive for tests that have large stacktraces and have a lot of invocations on
+     * mocks.
+     */
+    private void computeStackTraceInformation(
+            StackTraceFilter stackTraceFilter, Throwable stackTraceHolder, boolean isInline) {
+        StackTraceElement filtered = stackTraceFilter.filterFirst(stackTraceHolder, isInline);
+
+        // there are corner cases where exception can have a null or empty stack trace
+        // for example, a custom exception can override getStackTrace() method
+        if (filtered == null) {
+            this.stackTraceLine = "-> at <<unknown line>>";
+            this.sourceFile = "<unknown source file>";
+        } else {
+            this.stackTraceLine = "-> at " + filtered;
+            this.sourceFile = filtered.getFileName();
+        }
+    }
+
+    @Override
+    public String getSourceFile() {
+        return sourceFile;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/debugging/Localized.java b/mockito-core/src/main/java/org/mockito/internal/debugging/Localized.java
similarity index 91%
rename from src/main/java/org/mockito/internal/debugging/Localized.java
rename to mockito-core/src/main/java/org/mockito/internal/debugging/Localized.java
index 0588042086..3abcf29555 100644
--- a/src/main/java/org/mockito/internal/debugging/Localized.java
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/Localized.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.internal.debugging;
 
-
 import org.mockito.invocation.Location;
 
 public class Localized<T> {
@@ -14,7 +13,7 @@ public class Localized<T> {
 
     public Localized(T object) {
         this.object = object;
-        location = new LocationImpl();
+        location = LocationFactory.create();
     }
 
     public T getObject() {
diff --git a/mockito-core/src/main/java/org/mockito/internal/debugging/LocationFactory.java b/mockito-core/src/main/java/org/mockito/internal/debugging/LocationFactory.java
new file mode 100644
index 0000000000..3b0d0a4ae0
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/LocationFactory.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import org.mockito.internal.util.AndroidPlatform;
+import org.mockito.internal.util.Platform;
+import org.mockito.invocation.Location;
+
+public final class LocationFactory {
+    private static final Factory factory = createLocationFactory();
+
+    private LocationFactory() {}
+
+    public static Location create() {
+        return create(false);
+    }
+
+    public static Location create(boolean inline) {
+        return factory.create(inline);
+    }
+
+    private interface Factory {
+        Location create(boolean inline);
+    }
+
+    private static Factory createLocationFactory() {
+        if (Platform.isAndroid() && !AndroidPlatform.isStackWalkerUsable()) {
+            return new Java8LocationFactory();
+        }
+        try {
+            // On some platforms, like Android, the StackWalker APIs may not be
+            // available, in this case we have to fallback to Java 8 style of stack
+            // traversing.
+            Class.forName("java.lang.StackWalker");
+            return new DefaultLocationFactory();
+        } catch (ClassNotFoundException e) {
+            return new Java8LocationFactory();
+        }
+    }
+
+    private static final class Java8LocationFactory implements Factory {
+        @Override
+        public Location create(boolean inline) {
+            return new Java8LocationImpl(new Throwable(), inline);
+        }
+    }
+
+    private static final class DefaultLocationFactory implements Factory {
+        @Override
+        public Location create(boolean inline) {
+            return new LocationImpl(inline);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/debugging/LocationImpl.java b/mockito-core/src/main/java/org/mockito/internal/debugging/LocationImpl.java
new file mode 100644
index 0000000000..ea72eeb7fd
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/LocationImpl.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.stacktrace.StackTraceCleaner;
+import org.mockito.exceptions.stacktrace.StackTraceCleaner.StackFrameMetadata;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleaner;
+import org.mockito.invocation.Location;
+
+import java.io.Serializable;
+import java.lang.StackWalker.Option;
+import java.lang.StackWalker.StackFrame;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class LocationImpl implements Location, Serializable {
+    private static final long serialVersionUID = 2954388321980069195L;
+
+    private static final String UNEXPECTED_ERROR_SUFFIX =
+            "\nThis is unexpected and is likely due to a change in either Java's StackWalker or Reflection APIs."
+                    + "\nIt's worth trying to upgrade to a newer version of Mockito, or otherwise to file a bug report.";
+
+    /**
+     * This is an unfortunate buffer. Inside StackWalker, a buffer is created, which is resized by
+     * doubling. The resizing also allocates a tonne of StackFrame elements. If we traverse more than
+     * BUFFER_SIZE elements, the resulting resize can significantly affect the overall cost of the operation.
+     * If we traverse fewer than this number, we are inefficient. Empirically, 16 is enough stack frames
+     * for a simple stub+call operation to succeed without resizing, as measured on Java 11.
+     */
+    private static final int BUFFER_SIZE = 16;
+
+    private static final StackWalker STACK_WALKER = stackWalker();
+
+    private static final String PREFIX = "-> at ";
+
+    private static final StackTraceCleaner CLEANER =
+            Plugins.getStackTraceCleanerProvider()
+                    .getStackTraceCleaner(new DefaultStackTraceCleaner());
+
+    /**
+     * In Java, allocating lambdas is cheap, but not free. stream.map(this::doSomething)
+     * will allocate a Function object each time the function is called (although not
+     * per element). By assigning these Functions and Predicates to variables, we can
+     * avoid the memory allocation.
+     */
+    private static final Function<StackFrame, StackFrameMetadata> toStackFrameMetadata =
+            MetadataShim::new;
+
+    private static final Predicate<StackFrameMetadata> cleanerIsIn = CLEANER::isIn;
+
+    private static final int FRAMES_TO_SKIP = framesToSkip();
+
+    private final StackFrameMetadata sfm;
+    private volatile String stackTraceLine;
+
+    LocationImpl(boolean isInline) {
+        this.sfm = getStackFrame(isInline);
+    }
+
+    @Override
+    public String getSourceFile() {
+        return sfm.getFileName();
+    }
+
+    @Override
+    public String toString() {
+        return stackTraceLine();
+    }
+
+    private String stackTraceLine() {
+        if (stackTraceLine == null) {
+            synchronized (this) {
+                if (stackTraceLine == null) {
+                    stackTraceLine = PREFIX + sfm.toString();
+                }
+            }
+        }
+        return stackTraceLine;
+    }
+
+    private static StackFrameMetadata getStackFrame(boolean isInline) {
+        return stackWalk(
+                stream ->
+                        stream.map(toStackFrameMetadata)
+                                .skip(FRAMES_TO_SKIP)
+                                .filter(cleanerIsIn)
+                                .skip(isInline ? 1 : 0)
+                                .findFirst()
+                                .orElseThrow(
+                                        () -> new MockitoException(noStackTraceFailureMessage())));
+    }
+
+    private static boolean usingDefaultStackTraceCleaner() {
+        return CLEANER instanceof DefaultStackTraceCleaner;
+    }
+
+    private static String noStackTraceFailureMessage() {
+        if (usingDefaultStackTraceCleaner()) {
+            return "Mockito could not find the first non-Mockito stack frame."
+                    + UNEXPECTED_ERROR_SUFFIX;
+        } else {
+            String cleanerType = CLEANER.getClass().getName();
+            String fmt =
+                    "Mockito could not find the first non-Mockito stack frame. A custom stack frame cleaner \n"
+                            + "(type %s) is in use and this has mostly likely filtered out all the relevant stack frames.";
+            return String.format(fmt, cleanerType);
+        }
+    }
+
+    /**
+     * In order to trigger the stack walker, we create some reflective frames. These need to be skipped so as to
+     * ensure there are no non-Mockito frames at the top of the stack trace.
+     */
+    private static int framesToSkip() {
+        return stackWalk(
+                stream -> {
+                    List<String> metadata =
+                            stream.map(toStackFrameMetadata)
+                                    .map(StackFrameMetadata::getClassName)
+                                    .collect(Collectors.toList());
+                    return metadata.indexOf(LocationImpl.class.getName());
+                });
+    }
+
+    private static <T> T stackWalk(Function<Stream<StackFrame>, T> function) {
+        return (T) STACK_WALKER.walk(function);
+    }
+
+    private static StackWalker stackWalker() {
+        return StackWalker.getInstance(
+                Collections.singleton(Option.SHOW_REFLECT_FRAMES), BUFFER_SIZE);
+    }
+
+    private static final class MetadataShim implements StackFrameMetadata, Serializable {
+        private static final long serialVersionUID = 8491903719411428648L;
+        private final StackFrame stackFrame;
+
+        private MetadataShim(StackFrame stackFrame) {
+            this.stackFrame = stackFrame;
+        }
+
+        @Override
+        public String getClassName() {
+            return stackFrame.getClassName();
+        }
+
+        @Override
+        public String getMethodName() {
+            return stackFrame.getMethodName();
+        }
+
+        @Override
+        public String getFileName() {
+            return stackFrame.getFileName();
+        }
+
+        @Override
+        public int getLineNumber() {
+            return stackFrame.getLineNumber();
+        }
+
+        @Override
+        public String toString() {
+            return stackFrame.toString();
+        }
+
+        /**
+         * Ensure that this type remains serializable.
+         */
+        private Object writeReplace() {
+            return new SerializableShim(stackFrame.toStackTraceElement());
+        }
+    }
+
+    private static final class SerializableShim implements StackFrameMetadata, Serializable {
+        private static final long serialVersionUID = 7908320459080898690L;
+        private final StackTraceElement ste;
+
+        private SerializableShim(StackTraceElement ste) {
+            this.ste = ste;
+        }
+
+        @Override
+        public String getClassName() {
+            return ste.getClassName();
+        }
+
+        @Override
+        public String getMethodName() {
+            return ste.getMethodName();
+        }
+
+        @Override
+        public String getFileName() {
+            return ste.getFileName();
+        }
+
+        @Override
+        public int getLineNumber() {
+            return ste.getLineNumber();
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/debugging/LoggingListener.java b/mockito-core/src/main/java/org/mockito/internal/debugging/LoggingListener.java
new file mode 100644
index 0000000000..c5ebee4aa5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/LoggingListener.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.invocation.Invocation;
+
+public class LoggingListener implements FindingsListener {
+    private final boolean warnAboutUnstubbed;
+
+    private final List<String> argMismatchStubs = new LinkedList<>();
+    private final List<String> unusedStubs = new LinkedList<>();
+    private final List<String> unstubbedCalls = new LinkedList<>();
+
+    public LoggingListener(boolean warnAboutUnstubbed) {
+        this.warnAboutUnstubbed = warnAboutUnstubbed;
+    }
+
+    @Override
+    public void foundStubCalledWithDifferentArgs(Invocation unused, InvocationMatcher unstubbed) {
+        // TODO there is not good reason we should get Invocation and InvocationMatcher here
+        // we should pass 2 InvocationMatchers and testing is easier
+        // it's also confusing that unstubbed invocation is passed as InvocationMatcher (should be
+        // rather Invocation)
+
+        // this information comes in pairs
+        String index = Integer.toString(indexOfNextPair(argMismatchStubs.size()));
+        // making sure indentation is correct
+        String padding = index.replaceAll("\\d", " ");
+        argMismatchStubs.add(index + ". Stubbed " + unused.getLocation());
+        argMismatchStubs.add(padding + "  Invoked " + unstubbed.getInvocation().getLocation());
+    }
+
+    static int indexOfNextPair(int collectionSize) {
+        return (collectionSize / 2) + 1;
+    }
+
+    @Override
+    public void foundUnusedStub(Invocation unused) {
+        unusedStubs.add((unusedStubs.size() + 1) + ". " + unused.getLocation());
+    }
+
+    @Override
+    public void foundUnstubbed(InvocationMatcher unstubbed) {
+        if (warnAboutUnstubbed) {
+            unstubbedCalls.add(
+                    (unstubbedCalls.size() + 1) + ". " + unstubbed.getInvocation().getLocation());
+        }
+    }
+
+    public String getStubbingInfo() {
+        if (argMismatchStubs.isEmpty() && unusedStubs.isEmpty() && unstubbedCalls.isEmpty()) {
+            return "";
+        }
+
+        List<String> lines = new LinkedList<>();
+        lines.add(
+                "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):");
+
+        if (!argMismatchStubs.isEmpty()) {
+            lines.add("[Mockito]");
+            lines.add(
+                    "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):");
+            lines.add("[Mockito]");
+            addOrderedList(lines, argMismatchStubs);
+        }
+
+        if (!unusedStubs.isEmpty()) {
+            lines.add("[Mockito]");
+            lines.add("[Mockito] Unused stubbing (perhaps can be removed from the test?):");
+            lines.add("[Mockito]");
+            addOrderedList(lines, unusedStubs);
+        }
+
+        if (!unstubbedCalls.isEmpty()) {
+            lines.add("[Mockito]");
+            lines.add(
+                    "[Mockito] Un-stubbed method invocations (perhaps missing stubbing in the test?):");
+            lines.add("[Mockito]");
+            addOrderedList(lines, unstubbedCalls);
+        }
+        return join("", lines);
+    }
+
+    private void addOrderedList(List<String> target, List<String> additions) {
+        for (String a : additions) {
+            target.add("[Mockito] " + a);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java b/mockito-core/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
new file mode 100644
index 0000000000..a78be3163e
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import java.io.PrintStream;
+
+import org.mockito.invocation.DescribedInvocation;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.MethodInvocationReport;
+
+/**
+ * Logs all invocations to standard output.
+ *
+ * Used for debugging interactions with a mock.
+ */
+public class VerboseMockInvocationLogger implements InvocationListener {
+
+    // visible for testing
+    final PrintStream printStream;
+
+    private int mockInvocationsCounter = 0;
+
+    public VerboseMockInvocationLogger() {
+        this(System.out);
+    }
+
+    public VerboseMockInvocationLogger(PrintStream printStream) {
+        this.printStream = printStream;
+    }
+
+    @Override
+    public void reportInvocation(MethodInvocationReport methodInvocationReport) {
+        printHeader();
+        printStubInfo(methodInvocationReport);
+        printInvocation(methodInvocationReport.getInvocation());
+        printReturnedValueOrThrowable(methodInvocationReport);
+        printFooter();
+    }
+
+    private void printReturnedValueOrThrowable(MethodInvocationReport methodInvocationReport) {
+        if (methodInvocationReport.threwException()) {
+            String message =
+                    methodInvocationReport.getThrowable().getMessage() == null
+                            ? ""
+                            : " with message " + methodInvocationReport.getThrowable().getMessage();
+            printlnIndented(
+                    "has thrown: " + methodInvocationReport.getThrowable().getClass() + message);
+        } else {
+            String type =
+                    (methodInvocationReport.getReturnedValue() == null)
+                            ? ""
+                            : " ("
+                                    + methodInvocationReport.getReturnedValue().getClass().getName()
+                                    + ")";
+            printlnIndented(
+                    "has returned: \"" + methodInvocationReport.getReturnedValue() + "\"" + type);
+        }
+    }
+
+    private void printStubInfo(MethodInvocationReport methodInvocationReport) {
+        if (methodInvocationReport.getLocationOfStubbing() != null) {
+            printlnIndented("stubbed: " + methodInvocationReport.getLocationOfStubbing());
+        }
+    }
+
+    private void printHeader() {
+        mockInvocationsCounter++;
+        printStream.println(
+                "############ Logging method invocation #"
+                        + mockInvocationsCounter
+                        + " on mock/spy ########");
+    }
+
+    private void printInvocation(DescribedInvocation invocation) {
+        printStream.println(invocation);
+        //        printStream.println("Handling method call on a mock/spy.");
+        printlnIndented("invoked: " + invocation.getLocation());
+    }
+
+    private void printFooter() {
+        printStream.println();
+    }
+
+    private void printlnIndented(String message) {
+        printStream.println("   " + message);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/debugging/WarningsFinder.java b/mockito-core/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
similarity index 84%
rename from src/main/java/org/mockito/internal/debugging/WarningsFinder.java
rename to mockito-core/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
index 68ab15e7e1..c766366ae6 100644
--- a/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
@@ -21,16 +21,16 @@ public WarningsFinder(List<Invocation> unusedStubs, List<InvocationMatcher> allI
     }
 
     public void find(FindingsListener findingsListener) {
-        List<Invocation> unusedStubs = new LinkedList<Invocation>(this.baseUnusedStubs);
-        List<InvocationMatcher> allInvocations = new LinkedList<InvocationMatcher>(this.baseAllInvocations);
+        List<Invocation> unusedStubs = new LinkedList<>(this.baseUnusedStubs);
+        List<InvocationMatcher> allInvocations = new LinkedList<>(this.baseAllInvocations);
 
         Iterator<Invocation> unusedIterator = unusedStubs.iterator();
-        while(unusedIterator.hasNext()) {
+        while (unusedIterator.hasNext()) {
             Invocation unused = unusedIterator.next();
             Iterator<InvocationMatcher> unstubbedIterator = allInvocations.iterator();
-            while(unstubbedIterator.hasNext()) {
+            while (unstubbedIterator.hasNext()) {
                 InvocationMatcher unstubbed = unstubbedIterator.next();
-                if(unstubbed.hasSimilarMethod(unused)) {
+                if (unstubbed.hasSimilarMethod(unused)) {
                     findingsListener.foundStubCalledWithDifferentArgs(unused, unstubbed);
                     unusedIterator.remove();
                     unstubbedIterator.remove();
diff --git a/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java b/mockito-core/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
similarity index 83%
rename from src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
index 9f235e7ee6..e02e139b0f 100644
--- a/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
@@ -14,7 +14,10 @@ public class WarningsPrinterImpl {
     private final boolean warnAboutUnstubbed;
     private final WarningsFinder finder;
 
-    public WarningsPrinterImpl(List<Invocation> unusedStubs, List<InvocationMatcher> allInvocations, boolean warnAboutUnstubbed) {
+    public WarningsPrinterImpl(
+            List<Invocation> unusedStubs,
+            List<InvocationMatcher> allInvocations,
+            boolean warnAboutUnstubbed) {
         this(warnAboutUnstubbed, new WarningsFinder(unusedStubs, allInvocations));
     }
 
diff --git a/src/main/java/org/mockito/internal/debugging/package-info.java b/mockito-core/src/main/java/org/mockito/internal/debugging/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/debugging/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/debugging/package-info.java
diff --git a/src/main/java/org/mockito/internal/exceptions/ExceptionIncludingMockitoWarnings.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/ExceptionIncludingMockitoWarnings.java
similarity index 100%
rename from src/main/java/org/mockito/internal/exceptions/ExceptionIncludingMockitoWarnings.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/ExceptionIncludingMockitoWarnings.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/exceptions/Reporter.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/Reporter.java
new file mode 100644
index 0000000000..410964acca
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/exceptions/Reporter.java
@@ -0,0 +1,1217 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.exceptions;
+
+import static org.mockito.internal.reporting.Pluralizer.pluralize;
+import static org.mockito.internal.reporting.Pluralizer.were_exactly_x_interactions;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.base.MockitoInitializationException;
+import org.mockito.exceptions.misusing.CannotStubVoidMethodWithReturnValue;
+import org.mockito.exceptions.misusing.CannotVerifyStubOnlyMock;
+import org.mockito.exceptions.misusing.FriendlyReminderException;
+import org.mockito.exceptions.misusing.InjectMocksException;
+import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
+import org.mockito.exceptions.misusing.MissingMethodInvocationException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.RedundantListenerException;
+import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
+import org.mockito.exceptions.misusing.UnfinishedStubbingException;
+import org.mockito.exceptions.misusing.UnfinishedVerificationException;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
+import org.mockito.exceptions.verification.MoreThanAllowedActualInvocations;
+import org.mockito.exceptions.verification.NeverWantedButInvoked;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.SmartNullPointerException;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.exceptions.verification.TooManyActualInvocations;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.exceptions.util.ScenarioPrinter;
+import org.mockito.internal.junit.ExceptionFactory;
+import org.mockito.internal.matchers.LocalizedMatcher;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool;
+import org.mockito.invocation.DescribedInvocation;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.mock.MockName;
+import org.mockito.mock.SerializableMode;
+
+/**
+ * Reports verification and misusing errors.
+ * <p>
+ * One of the key points of mocking library is proper verification/exception
+ * messages. All messages in one place makes it easier to tune and amend them.
+ * <p>
+ * Reporter can be injected and therefore is easily testable.
+ * <p>
+ * Generally, exception messages are full of line breaks to make them easy to
+ * read (xunit plugins take only fraction of screen on modern IDEs).
+ */
+public class Reporter {
+
+    private static final String NON_PUBLIC_PARENT =
+            "Mocking methods declared on non-public parent classes is not supported.";
+
+    private Reporter() {}
+
+    public static MockitoException checkedExceptionInvalid(Throwable t) {
+        return new MockitoException(
+                join("Checked exception is invalid for this method!", "Invalid: " + t));
+    }
+
+    public static MockitoException cannotStubWithNullThrowable() {
+        return new MockitoException(join("Cannot stub with null throwable!"));
+    }
+
+    public static MockitoException unfinishedStubbing(Location location) {
+        return new UnfinishedStubbingException(
+                join(
+                        "Unfinished stubbing detected here:",
+                        location,
+                        "",
+                        "E.g. thenReturn() may be missing.",
+                        "Examples of correct stubbing:",
+                        "    when(mock.isOk()).thenReturn(true);",
+                        "    when(mock.isOk()).thenThrow(exception);",
+                        "    doThrow(exception).when(mock).someVoidMethod();",
+                        "Hints:",
+                        " 1. missing thenReturn()",
+                        " 2. you are trying to stub a final method, which is not supported",
+                        " 3. you are stubbing the behaviour of another mock inside before 'thenReturn' instruction is completed",
+                        ""));
+    }
+
+    public static MockitoException incorrectUseOfApi() {
+        return new MockitoException(
+                join(
+                        "Incorrect use of API detected here:",
+                        LocationFactory.create(),
+                        "",
+                        "You probably stored a reference to OngoingStubbing returned by when() and called stubbing methods like thenReturn() on this reference more than once.",
+                        "Examples of correct usage:",
+                        "    when(mock.isOk()).thenReturn(true).thenReturn(false).thenThrow(exception);",
+                        "    when(mock.isOk()).thenReturn(true, false).thenThrow(exception);",
+                        ""));
+    }
+
+    public static MockitoException missingMethodInvocation() {
+        return new MissingMethodInvocationException(
+                join(
+                        "when() requires an argument which has to be 'a method call on a mock'.",
+                        "For example:",
+                        "    when(mock.getArticles()).thenReturn(articles);",
+                        "",
+                        "Also, this error might show up because:",
+                        "1. you stub either of: final/private/native/equals()/hashCode() methods.",
+                        "   Those methods *cannot* be stubbed/verified.",
+                        "   " + NON_PUBLIC_PARENT,
+                        "2. inside when() you don't call method on mock but on some other object.",
+                        ""));
+    }
+
+    public static MockitoException unfinishedVerificationException(Location location) {
+        return new UnfinishedVerificationException(
+                join(
+                        "Missing method call for verify(mock) here:",
+                        location,
+                        "",
+                        "Example of correct verification:",
+                        "    verify(mock).doSomething()",
+                        "",
+                        "Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.",
+                        "Those methods *cannot* be stubbed/verified.",
+                        NON_PUBLIC_PARENT,
+                        ""));
+    }
+
+    public static MockitoException notAMockPassedToVerify(Class<?> type) {
+        return new NotAMockException(
+                join(
+                        "Argument passed to verify() is of type "
+                                + type.getSimpleName()
+                                + " and is not a mock!",
+                        "Make sure you place the parenthesis correctly!",
+                        "See the examples of correct verifications:",
+                        "    verify(mock).someMethod();",
+                        "    verify(mock, times(10)).someMethod();",
+                        "    verify(mock, atLeastOnce()).someMethod();"));
+    }
+
+    public static MockitoException nullPassedToVerify() {
+        return new NullInsteadOfMockException(
+                join(
+                        "Argument passed to verify() should be a mock but is null!",
+                        "Examples of correct verifications:",
+                        "    verify(mock).someMethod();",
+                        "    verify(mock, times(10)).someMethod();",
+                        "    verify(mock, atLeastOnce()).someMethod();",
+                        "    not: verify(mock.someMethod());",
+                        "Also, if you use @Mock annotation don't miss openMocks()"));
+    }
+
+    public static MockitoException notAMockPassedToWhenMethod() {
+        return new NotAMockException(
+                join(
+                        "Argument passed to when() is not a mock!",
+                        "Example of correct stubbing:",
+                        "    doThrow(new RuntimeException()).when(mock).someMethod();"));
+    }
+
+    public static MockitoException nullPassedToWhenMethod() {
+        return new NullInsteadOfMockException(
+                join(
+                        "Argument passed to when() is null!",
+                        "Example of correct stubbing:",
+                        "    doThrow(new RuntimeException()).when(mock).someMethod();",
+                        "Also, if you use @Mock annotation don't miss openMocks()"));
+    }
+
+    public static MockitoException mocksHaveToBePassedToVerifyNoMoreInteractions() {
+        return new MockitoException(
+                join(
+                        "Method requires argument(s)!",
+                        "Pass mocks that should be verified, e.g:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);",
+                        ""));
+    }
+
+    public static MockitoException notAMockPassedToVerifyNoMoreInteractions() {
+        return new NotAMockException(
+                join(
+                        "Argument(s) passed is not a mock!",
+                        "Examples of correct verifications:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);",
+                        ""));
+    }
+
+    public static MockitoException nullPassedToVerifyNoMoreInteractions() {
+        return new NullInsteadOfMockException(
+                join(
+                        "Argument(s) passed is null!",
+                        "Examples of correct verifications:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);"));
+    }
+
+    public static MockitoException notAMockPassedWhenCreatingInOrder() {
+        return new NotAMockException(
+                join(
+                        "Argument(s) passed is not a mock!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);"));
+    }
+
+    public static MockitoException nullPassedWhenCreatingInOrder() {
+        return new NullInsteadOfMockException(
+                join(
+                        "Argument(s) passed is null!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);"));
+    }
+
+    public static MockitoException mocksHaveToBePassedWhenCreatingInOrder() {
+        return new MockitoException(
+                join(
+                        "Method requires argument(s)!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);"));
+    }
+
+    public static MockitoException inOrderRequiresFamiliarMock() {
+        return new MockitoException(
+                join(
+                        "InOrder can only verify mocks that were passed in during creation of InOrder.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne);",
+                        "    inOrder.verify(mockOne).doStuff();"));
+    }
+
+    public static MockitoException invalidUseOfMatchers(
+            int expectedMatchersCount, List<LocalizedMatcher> recordedMatchers) {
+        return new InvalidUseOfMatchersException(
+                join(
+                        "Invalid use of argument matchers!",
+                        expectedMatchersCount
+                                + " matchers expected, "
+                                + recordedMatchers.size()
+                                + " recorded:"
+                                + locationsOf(recordedMatchers),
+                        "",
+                        "This exception may occur if matchers are combined with raw values:",
+                        "    //incorrect:",
+                        "    someMethod(any(), \"raw String\");",
+                        "When using matchers, all arguments have to be provided by matchers.",
+                        "For example:",
+                        "    //correct:",
+                        "    someMethod(any(), eq(\"String by matcher\"));",
+                        "",
+                        "For more info see javadoc for Matchers class.",
+                        ""));
+    }
+
+    public static MockitoException incorrectUseOfAdditionalMatchers(
+            String additionalMatcherName,
+            int expectedSubMatchersCount,
+            Collection<LocalizedMatcher> matcherStack) {
+        return new InvalidUseOfMatchersException(
+                join(
+                        "Invalid use of argument matchers inside additional matcher "
+                                + additionalMatcherName
+                                + " !",
+                        LocationFactory.create(),
+                        "",
+                        expectedSubMatchersCount
+                                + " sub matchers expected, "
+                                + matcherStack.size()
+                                + " recorded:",
+                        locationsOf(matcherStack),
+                        "",
+                        "This exception may occur if matchers are combined with raw values:",
+                        "    //incorrect:",
+                        "    someMethod(AdditionalMatchers.and(isNotNull(), \"raw String\");",
+                        "When using matchers, all arguments have to be provided by matchers.",
+                        "For example:",
+                        "    //correct:",
+                        "    someMethod(AdditionalMatchers.and(isNotNull(), eq(\"raw String\"));",
+                        "",
+                        "For more info see javadoc for Matchers and AdditionalMatchers classes.",
+                        ""));
+    }
+
+    public static MockitoException stubPassedToVerify(Object mock) {
+        return new CannotVerifyStubOnlyMock(
+                join(
+                        "Argument \""
+                                + MockUtil.getMockName(mock)
+                                + "\" passed to verify is a stubOnly() mock which cannot be verified.",
+                        "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings."));
+    }
+
+    public static MockitoException reportNoSubMatchersFound(String additionalMatcherName) {
+        return new InvalidUseOfMatchersException(
+                join(
+                        "No matchers found for additional matcher " + additionalMatcherName,
+                        LocationFactory.create(),
+                        ""));
+    }
+
+    private static Object locationsOf(Collection<LocalizedMatcher> matchers) {
+        List<String> description = new ArrayList<>();
+        for (LocalizedMatcher matcher : matchers) {
+            description.add(matcher.getLocation().toString());
+        }
+        return join(description.toArray());
+    }
+
+    public static AssertionError argumentsAreDifferent(
+            Invocation actualInvocation,
+            MatchableInvocation matchableInvocation,
+            String wanted,
+            List<String> actualCalls,
+            List<Location> actualLocations) {
+        if (actualCalls == null
+                || actualLocations == null
+                || actualCalls.size() != actualLocations.size()) {
+            throw new IllegalArgumentException("actualCalls and actualLocations list must match");
+        }
+
+        StringBuilder actualBuilder = new StringBuilder();
+        StringBuilder messageBuilder = new StringBuilder();
+        messageBuilder
+                .append("\n")
+                .append("Argument(s) are different! Wanted:\n")
+                .append(wanted)
+                .append("\n")
+                .append(LocationFactory.create())
+                .append("\n")
+                .append("Actual invocations have different arguments");
+
+        appendNotMatchingPositions(actualInvocation, matchableInvocation, messageBuilder);
+
+        messageBuilder.append(":\n");
+
+        for (int i = 0; i < actualCalls.size(); i++) {
+            actualBuilder.append(actualCalls.get(i)).append("\n");
+
+            messageBuilder
+                    .append(actualCalls.get(i))
+                    .append("\n")
+                    .append(actualLocations.get(i))
+                    .append("\n");
+        }
+
+        return ExceptionFactory.createArgumentsAreDifferentException(
+                messageBuilder.toString(), wanted, actualBuilder.toString());
+    }
+
+    /*
+     * Will append the non matching positions only if there are more than 1 arguments to the method.
+     */
+    private static void appendNotMatchingPositions(
+            Invocation actualInvocation,
+            MatchableInvocation matchableInvocation,
+            StringBuilder messageBuilder) {
+        Object[] args = actualInvocation.getArguments();
+        if (args.length <= 1) {
+            return;
+        }
+
+        List<Integer> indexes =
+                ArgumentMatchingTool.getNotMatchingArgsIndexes(
+                        matchableInvocation.getMatchers(), actualInvocation.getArguments());
+
+        if (!indexes.isEmpty()) {
+            messageBuilder
+                    .append(" at ")
+                    .append(indexes.size() == 1 ? "position " : "positions ")
+                    .append(indexes);
+        }
+    }
+
+    public static MockitoAssertionError wantedButNotInvoked(DescribedInvocation wanted) {
+        return new WantedButNotInvoked(createWantedButNotInvokedMessage(wanted));
+    }
+
+    public static MockitoAssertionError wantedButNotInvoked(
+            DescribedInvocation wanted, List<? extends DescribedInvocation> invocations) {
+        String allInvocations;
+        if (invocations.isEmpty()) {
+            allInvocations = "Actually, there were zero interactions with this mock.\n";
+        } else {
+            StringBuilder sb =
+                    new StringBuilder("\nHowever, there ")
+                            .append(were_exactly_x_interactions(invocations.size()))
+                            .append(" with this mock:\n");
+            for (DescribedInvocation i : invocations) {
+                sb.append(i).append("\n").append(i.getLocation()).append("\n\n");
+            }
+            allInvocations = sb.toString();
+        }
+
+        String message = createWantedButNotInvokedMessage(wanted);
+        return new WantedButNotInvoked(message + allInvocations);
+    }
+
+    private static String createWantedButNotInvokedMessage(DescribedInvocation wanted) {
+        return join("Wanted but not invoked:", wanted.toString(), LocationFactory.create(), "");
+    }
+
+    public static MockitoAssertionError wantedButNotInvokedInOrder(
+            DescribedInvocation wanted, DescribedInvocation previous) {
+        return new VerificationInOrderFailure(
+                join(
+                        "Verification in order failure",
+                        "Wanted but not invoked:",
+                        wanted.toString(),
+                        LocationFactory.create(),
+                        "Wanted anywhere AFTER following interaction:",
+                        previous.toString(),
+                        previous.getLocation(),
+                        ""));
+    }
+
+    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,
+            List<Location> invocations) {
+        return join(
+                wanted.toString(),
+                "Wanted " + pluralize(wantedCount) + ":",
+                LocationFactory.create(),
+                "But was " + pluralize(actualCount) + ":",
+                createAllLocationsMessage(invocations),
+                "");
+    }
+
+    public static MockitoAssertionError neverWantedButInvoked(
+            DescribedInvocation wanted, List<Invocation> invocations) {
+
+        return new NeverWantedButInvoked(
+                join(
+                        wanted.toString(),
+                        "Never wanted here:",
+                        LocationFactory.create(),
+                        "But invoked here:",
+                        createAllLocationsArgsMessage(invocations)));
+    }
+
+    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 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 createAllLocationsArgsMessage(List<Invocation> invocations) {
+        StringBuilder sb = new StringBuilder();
+        for (Invocation invocation : invocations) {
+            Location location = invocation.getLocation();
+            if (location == null) {
+                continue;
+            }
+            sb.append(location)
+                    .append(" with arguments: ")
+                    .append(Arrays.toString(invocation.getArguments()))
+                    .append("\n");
+        }
+        return sb.toString();
+    }
+
+    private static String createTooFewInvocationsMessage(
+            org.mockito.internal.reporting.Discrepancy discrepancy,
+            DescribedInvocation wanted,
+            List<Location> locations) {
+        return join(
+                wanted.toString(),
+                "Wanted "
+                        + discrepancy.getPluralizedWantedCount()
+                        + (discrepancy.getWantedCount() == 0 ? "." : ":"),
+                LocationFactory.create(),
+                "But was "
+                        + discrepancy.getPluralizedActualCount()
+                        + (discrepancy.getActualCount() == 0 ? "." : ":"),
+                createAllLocationsMessage(locations));
+    }
+
+    public static MockitoAssertionError tooFewActualInvocations(
+            org.mockito.internal.reporting.Discrepancy discrepancy,
+            DescribedInvocation wanted,
+            List<Location> allLocations) {
+        String message = createTooFewInvocationsMessage(discrepancy, wanted, allLocations);
+
+        return new TooFewActualInvocations(message);
+    }
+
+    public static MockitoAssertionError tooFewActualInvocationsInOrder(
+            org.mockito.internal.reporting.Discrepancy discrepancy,
+            DescribedInvocation wanted,
+            List<Location> locations) {
+        String message = createTooFewInvocationsMessage(discrepancy, wanted, locations);
+
+        return new VerificationInOrderFailure(join("Verification in order failure:" + message));
+    }
+
+    public static MockitoAssertionError noMoreInteractionsWanted(
+            Invocation undesired, List<VerificationAwareInvocation> invocations) {
+        ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
+        String scenario = scenarioPrinter.print(invocations);
+
+        return new NoInteractionsWanted(
+                join(
+                        "No interactions wanted here:",
+                        LocationFactory.create(),
+                        "But found this interaction on mock '"
+                                + MockUtil.getMockName(undesired.getMock())
+                                + "':",
+                        undesired.getLocation(),
+                        scenario));
+    }
+
+    public static MockitoAssertionError noMoreInteractionsWantedInOrder(Invocation undesired) {
+        return new VerificationInOrderFailure(
+                join(
+                        "No interactions wanted here:",
+                        LocationFactory.create(),
+                        "But found this interaction on mock '"
+                                + MockUtil.getMockName(undesired.getMock())
+                                + "':",
+                        undesired.getLocation()));
+    }
+
+    public static MockitoAssertionError noInteractionsWanted(
+            Object mock, List<VerificationAwareInvocation> invocations) {
+        ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
+        String scenario = scenarioPrinter.print(invocations);
+
+        List<Location> locations = new ArrayList<>();
+        for (VerificationAwareInvocation invocation : invocations) {
+            locations.add(invocation.getLocation());
+        }
+        return new NoInteractionsWanted(
+                join(
+                        "No interactions wanted here:",
+                        LocationFactory.create(),
+                        "But found these interactions on mock '"
+                                + MockUtil.getMockName(mock)
+                                + "':",
+                        join("", locations),
+                        scenario));
+    }
+
+    public static MockitoException cannotMockClass(Class<?> clazz, String reason) {
+        return new MockitoException(
+                join(
+                        "Cannot mock/spy " + clazz,
+                        "Mockito cannot mock/spy because :",
+                        " - " + reason));
+    }
+
+    public static MockitoException cannotStubVoidMethodWithAReturnValue(String methodName) {
+        return new CannotStubVoidMethodWithReturnValue(
+                join(
+                        "'"
+                                + methodName
+                                + "' is a *void method* and it *cannot* be stubbed with a *return value*!",
+                        "Voids are usually stubbed with Throwables:",
+                        "    doThrow(exception).when(mock).someVoidMethod();",
+                        "If you need to set the void method to do nothing you can use:",
+                        "    doNothing().when(mock).someVoidMethod();",
+                        "For more information, check out the javadocs for Mockito.doNothing().",
+                        "***",
+                        "If you're unsure why you're getting above error read on.",
+                        "Due to the nature of the syntax above problem might occur because:",
+                        "1. The method you are trying to stub is *overloaded*. Make sure you are calling the right overloaded version.",
+                        "2. Somewhere in your test you are stubbing *final methods*. Sorry, Mockito does not verify/stub final methods.",
+                        "3. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
+                        "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
+                        "4. " + NON_PUBLIC_PARENT,
+                        ""));
+    }
+
+    public static MockitoException onlyVoidMethodsCanBeSetToDoNothing() {
+        return new MockitoException(
+                join(
+                        "Only void methods can doNothing()!",
+                        "Example of correct use of doNothing():",
+                        "    doNothing().",
+                        "    doThrow(new RuntimeException())",
+                        "    .when(mock).someVoidMethod();",
+                        "Above means:",
+                        "someVoidMethod() does nothing the 1st time but throws an exception the 2nd time is called"));
+    }
+
+    public static MockitoException wrongTypeOfReturnValue(
+            String expectedType, String actualType, String methodName) {
+        return new WrongTypeOfReturnValue(
+                join(
+                        actualType + " cannot be returned by " + methodName + "()",
+                        methodName + "() should return " + expectedType,
+                        "***",
+                        "If you're unsure why you're getting above error read on.",
+                        "Due to the nature of the syntax above problem might occur because:",
+                        "1. This exception *might* occur in wrongly written multi-threaded tests.",
+                        "   Please refer to Mockito FAQ on limitations of concurrency testing.",
+                        "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
+                        "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
+                        ""));
+    }
+
+    public static MockitoException wrongTypeReturnedByDefaultAnswer(
+            Object mock, String expectedType, String actualType, String methodName) {
+        return new WrongTypeOfReturnValue(
+                join(
+                        "Default answer returned a result with the wrong type:",
+                        actualType + " cannot be returned by " + methodName + "()",
+                        methodName + "() should return " + expectedType,
+                        "",
+                        "The default answer of "
+                                + MockUtil.getMockName(mock)
+                                + " that was configured on the mock is probably incorrectly implemented.",
+                        ""));
+    }
+
+    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) {
+        return new InvalidUseOfMatchersException(
+                join(
+                        "Misplaced or misused argument matcher detected here:",
+                        locationsOf(lastMatchers),
+                        "",
+                        "You cannot use argument matchers outside of verification or stubbing.",
+                        "Examples of correct usage of argument matchers:",
+                        "    when(mock.get(anyInt())).thenReturn(null);",
+                        "    doThrow(new RuntimeException()).when(mock).someVoidMethod(any());",
+                        "    verify(mock).someMethod(contains(\"foo\"))",
+                        "",
+                        "This message may appear after an NullPointerException if the last matcher is returning an object ",
+                        "like any() but the stubbed method signature expect a primitive argument, in this case,",
+                        "use primitive alternatives.",
+                        "    when(mock.get(any())); // bad use, will raise NPE",
+                        "    when(mock.get(anyInt())); // correct usage use",
+                        "",
+                        "Also, this error might show up because you use argument matchers with methods that cannot be mocked.",
+                        "Following methods *cannot* be stubbed/verified: final/private/equals()/hashCode().",
+                        NON_PUBLIC_PARENT,
+                        ""));
+    }
+
+    public static MockitoException smartNullPointerException(String invocation, Location location) {
+        return new SmartNullPointerException(
+                join(
+                        "You have a NullPointerException here:",
+                        LocationFactory.create(),
+                        "because this method call was *not* stubbed correctly:",
+                        location,
+                        invocation,
+                        ""));
+    }
+
+    public static MockitoException noArgumentValueWasCaptured() {
+        return new MockitoException(
+                join(
+                        "No argument value was captured!",
+                        "You might have forgotten to use argument.capture() in verify()...",
+                        "...or you used capture() in stubbing but stubbed method was not called.",
+                        "Be aware that it is recommended to use capture() only with verify()",
+                        "",
+                        "Examples of correct argument capturing:",
+                        "    ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);",
+                        "    verify(mock).doSomething(argument.capture());",
+                        "    assertEquals(\"John\", argument.getValue().getName());",
+                        ""));
+    }
+
+    public static MockitoException extraInterfacesDoesNotAcceptNullParameters() {
+        return new MockitoException(join("extraInterfaces() does not accept null parameters."));
+    }
+
+    public static MockitoException extraInterfacesAcceptsOnlyInterfaces(Class<?> wrongType) {
+        return new MockitoException(
+                join(
+                        "extraInterfaces() accepts only interfaces.",
+                        "You passed following type: "
+                                + wrongType.getSimpleName()
+                                + " which is not an interface."));
+    }
+
+    public static MockitoException extraInterfacesCannotContainMockedType(Class<?> wrongType) {
+        return new MockitoException(
+                join(
+                        "extraInterfaces() does not accept the same type as the mocked type.",
+                        "You mocked following type: " + wrongType.getSimpleName(),
+                        "and you passed the same very interface to the extraInterfaces()"));
+    }
+
+    public static MockitoException extraInterfacesRequiresAtLeastOneInterface() {
+        return new MockitoException(join("extraInterfaces() requires at least one interface."));
+    }
+
+    public static MockitoException mockedTypeIsInconsistentWithSpiedInstanceType(
+            Class<?> mockedType, Object spiedInstance) {
+        return new MockitoException(
+                join(
+                        "Mocked type must be the same as the type of your spied instance.",
+                        "Mocked type must be: "
+                                + spiedInstance.getClass().getSimpleName()
+                                + ", but is: "
+                                + mockedType.getSimpleName(),
+                        "  //correct spying:",
+                        "  spy = mock( ->ArrayList.class<- , withSettings().spiedInstance( ->new ArrayList()<- );",
+                        "  //incorrect - types don't match:",
+                        "  spy = mock( ->List.class<- , withSettings().spiedInstance( ->new ArrayList()<- );"));
+    }
+
+    public static MockitoException cannotCallAbstractRealMethod() {
+        return new MockitoException(
+                join(
+                        "Cannot call abstract real method on java object!",
+                        "Calling real methods is only possible when mocking non abstract method.",
+                        "  //correct example:",
+                        "  when(mockOfConcreteClass.nonAbstractMethod()).thenCallRealMethod();"));
+    }
+
+    public static MockitoException cannotVerifyToString() {
+        return new MockitoException(
+                join(
+                        "Mockito cannot verify toString()",
+                        "toString() is too often used behind of scenes  (i.e. during String concatenation, in IDE debugging views). "
+                                + "Verifying it may give inconsistent or hard to understand results. "
+                                + "Not to mention that verifying toString() most likely hints awkward design (hard to explain in a short exception message. Trust me...)",
+                        "However, it is possible to stub toString(). Stubbing toString() smells a bit funny but there are rare, legitimate use cases."));
+    }
+
+    public static MockitoException moreThanOneAnnotationNotAllowed(String fieldName) {
+        return new MockitoException(
+                "You cannot have more than one Mockito annotation on a field!\n"
+                        + "The field '"
+                        + fieldName
+                        + "' has multiple Mockito annotations.\n"
+                        + "For info how to use annotations see examples in javadoc for MockitoAnnotations class.");
+    }
+
+    public static MockitoException unsupportedCombinationOfAnnotations(
+            String undesiredAnnotationOne, String undesiredAnnotationTwo) {
+        return new MockitoException(
+                "This combination of annotations is not permitted on a single field:\n"
+                        + "@"
+                        + undesiredAnnotationOne
+                        + " and @"
+                        + undesiredAnnotationTwo);
+    }
+
+    public static MockitoException cannotInitializeForSpyAnnotation(
+            String fieldName, Exception details) {
+        return new MockitoException(
+                join(
+                        "Cannot instantiate a @Spy for '" + fieldName + "' field.",
+                        "You haven't provided the instance for spying at field declaration so I tried to construct the instance.",
+                        "However, I failed because: " + details.getMessage(),
+                        "Examples of correct usage of @Spy:",
+                        "   @Spy List mock = new LinkedList();",
+                        "   @Spy Foo foo; //only if Foo has parameterless constructor",
+                        "   //also, don't forget about MockitoAnnotations.openMocks();",
+                        ""),
+                details);
+    }
+
+    public static MockitoException cannotInitializeForInjectMocksAnnotation(
+            String fieldName, String causeMessage) {
+        return new MockitoException(
+                join(
+                        "Cannot instantiate @InjectMocks field named '"
+                                + fieldName
+                                + "'! Cause: "
+                                + causeMessage,
+                        "You haven't provided the instance at field declaration so I tried to construct the instance.",
+                        "Examples of correct usage of @InjectMocks:",
+                        "   @InjectMocks Service service = new Service();",
+                        "   @InjectMocks Service service;",
+                        "   //and... don't forget about some @Mocks for injection :)",
+                        ""));
+    }
+
+    public static MockitoException atMostAndNeverShouldNotBeUsedWithTimeout() {
+        return new FriendlyReminderException(
+                join(
+                        "",
+                        "Don't panic! I'm just a friendly reminder!",
+                        "timeout() should not be used with atMost() or never() because...",
+                        "...it does not make much sense - the test would have passed immediately in concurrency",
+                        "We kept this method only to avoid compilation errors when upgrading Mockito.",
+                        "In future release we will remove timeout(x).atMost(y) from the API.",
+                        "If you want to find out more please refer to issue 235",
+                        ""));
+    }
+
+    public static MockitoException fieldInitialisationThrewException(
+            Field field, Throwable details) {
+        return new InjectMocksException(
+                join(
+                        "Cannot instantiate @InjectMocks field named '"
+                                + field.getName()
+                                + "' of type '"
+                                + field.getType()
+                                + "'.",
+                        "You haven't provided the instance at field declaration so I tried to construct the instance.",
+                        "However the constructor or the initialization block threw an exception : "
+                                + details.getMessage(),
+                        ""),
+                details);
+    }
+
+    public static MockitoException methodDoesNotAcceptParameter(String method, String parameter) {
+        return new MockitoException(
+                method + "() does not accept " + parameter + " See the Javadoc.");
+    }
+
+    public static MockitoException requiresAtLeastOneListener(String method) {
+        return new MockitoException(method + "() requires at least one listener");
+    }
+
+    public static MockitoException invocationListenerThrewException(
+            InvocationListener listener, Throwable listenerThrowable) {
+        return new MockitoException(
+                join(
+                        "The invocation listener with type " + listener.getClass().getName(),
+                        "threw an exception : "
+                                + listenerThrowable.getClass().getName()
+                                + listenerThrowable.getMessage()),
+                listenerThrowable);
+    }
+
+    public static MockitoException cannotInjectDependency(
+            Field field, Object matchingMock, Exception details) {
+        return new MockitoException(
+                join(
+                        "Mockito couldn't inject mock dependency '"
+                                + MockUtil.getMockName(matchingMock)
+                                + "' on field ",
+                        "'" + field + "'",
+                        "whose type '"
+                                + field.getDeclaringClass().getCanonicalName()
+                                + "' was annotated by @InjectMocks in your test.",
+                        "Also I failed because: " + exceptionCauseMessageIfAvailable(details),
+                        ""),
+                details);
+    }
+
+    public static MockitoException moreThanOneMockCandidate(
+            Field field, Collection<?> mockCandidates) {
+        List<String> mockNames =
+                mockCandidates.stream()
+                        .map(MockUtil::getMockName)
+                        .map(MockName::toString)
+                        .collect(Collectors.toList());
+        return new MockitoException(
+                join(
+                        "Mockito couldn't inject mock dependency on field "
+                                + "'"
+                                + field
+                                + "' that is annotated with @InjectMocks in your test, ",
+                        "because there were multiple matching mocks (i.e. "
+                                + "fields annotated with @Mock and having matching type): "
+                                + String.join(", ", mockNames)
+                                + ".",
+                        "If you have multiple fields of same type in your class under test "
+                                + "then consider naming the @Mock fields "
+                                + "identically to the respective class under test's fields, "
+                                + "so Mockito can match them by name."));
+    }
+
+    private static String exceptionCauseMessageIfAvailable(Exception details) {
+        if (details.getCause() == null) {
+            return details.getMessage();
+        }
+        return details.getCause().getMessage();
+    }
+
+    public static MockitoException mockedTypeIsInconsistentWithDelegatedInstanceType(
+            Class<?> mockedType, Object delegatedInstance) {
+        return new MockitoException(
+                join(
+                        "Mocked type must be the same as the type of your delegated instance.",
+                        "Mocked type must be: "
+                                + delegatedInstance.getClass().getSimpleName()
+                                + ", but is: "
+                                + mockedType.getSimpleName(),
+                        "  //correct delegate:",
+                        "  spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new ArrayList()<- );",
+                        "  //incorrect - types don't match:",
+                        "  spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new HashSet()<- );"));
+    }
+
+    public static MockitoException spyAndDelegateAreMutuallyExclusive() {
+        return new MockitoException(
+                join(
+                        "Settings should not define a spy instance and a delegated instance at the same time."));
+    }
+
+    public static MockitoException invalidArgumentRangeAtIdentityAnswerCreationTime() {
+        return new MockitoException(
+                join(
+                        "Invalid argument index.",
+                        "The index need to be a positive number that indicates the position of the argument to return.",
+                        "However it is possible to use the -1 value to indicates that the last argument should be",
+                        "returned."));
+    }
+
+    public static MockitoException invalidArgumentPositionRangeAtInvocationTime(
+            InvocationOnMock invocation, boolean willReturnLastParameter, int argumentIndex) {
+        return new MockitoException(
+                join(
+                        "Invalid argument index for the current invocation of method : ",
+                        " -> "
+                                + MockUtil.getMockName(invocation.getMock())
+                                + "."
+                                + invocation.getMethod().getName()
+                                + "()",
+                        "",
+                        (willReturnLastParameter
+                                        ? "Last parameter wanted"
+                                        : "Wanted parameter at position " + argumentIndex)
+                                + " but "
+                                + possibleArgumentTypesOf(invocation),
+                        "The index need to be a positive number that indicates a valid position of the argument in the invocation.",
+                        "However it is possible to use the -1 value to indicates that the last argument should be returned.",
+                        ""));
+    }
+
+    private static StringBuilder possibleArgumentTypesOf(InvocationOnMock invocation) {
+        Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
+        if (parameterTypes.length == 0) {
+            return new StringBuilder("the method has no arguments.\n");
+        }
+
+        StringBuilder stringBuilder =
+                new StringBuilder("the possible argument indexes for this method are :\n");
+        for (int i = 0, parameterTypesLength = parameterTypes.length;
+                i < parameterTypesLength;
+                i++) {
+            stringBuilder.append("    [").append(i);
+
+            if (invocation.getMethod().isVarArgs() && i == parameterTypesLength - 1) {
+                stringBuilder
+                        .append("+] ")
+                        .append(parameterTypes[i].getComponentType().getSimpleName())
+                        .append("  <- Vararg")
+                        .append("\n");
+            } else {
+                stringBuilder.append("] ").append(parameterTypes[i].getSimpleName()).append("\n");
+            }
+        }
+        return stringBuilder;
+    }
+
+    public static MockitoException wrongTypeOfArgumentToReturn(
+            InvocationOnMock invocation,
+            String expectedType,
+            Class<?> actualType,
+            int argumentIndex) {
+        return new WrongTypeOfReturnValue(
+                join(
+                        "The argument of type '"
+                                + actualType.getSimpleName()
+                                + "' cannot be returned because the following ",
+                        "method should return the type '" + expectedType + "'",
+                        " -> "
+                                + MockUtil.getMockName(invocation.getMock())
+                                + "."
+                                + invocation.getMethod().getName()
+                                + "()",
+                        "",
+                        "The reason for this error can be :",
+                        "1. The wanted argument position is incorrect.",
+                        "2. The answer is used on the wrong interaction.",
+                        "",
+                        "Position of the wanted argument is "
+                                + argumentIndex
+                                + " and "
+                                + possibleArgumentTypesOf(invocation),
+                        "***",
+                        "However if you're still unsure why you're getting above error read on.",
+                        "Due to the nature of the syntax above problem might occur because:",
+                        "1. This exception *might* occur in wrongly written multi-threaded tests.",
+                        "   Please refer to Mockito FAQ on limitations of concurrency testing.",
+                        "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
+                        "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
+                        ""));
+    }
+
+    public static MockitoException defaultAnswerDoesNotAcceptNullParameter() {
+        return new MockitoException("defaultAnswer() does not accept null parameter");
+    }
+
+    public static MockitoException strictnessDoesNotAcceptNullParameter() {
+        return new MockitoException("strictness() does not accept null parameter");
+    }
+
+    public static MockitoException serializableWontWorkForObjectsThatDontImplementSerializable(
+            Class<?> classToMock) {
+        return new MockitoException(
+                join(
+                        "You are using the setting 'withSettings().serializable()' however the type you are trying to mock '"
+                                + classToMock.getSimpleName()
+                                + "'",
+                        "do not implement Serializable AND do not have a no-arg constructor.",
+                        "This combination is requested, otherwise you will get an 'java.io.InvalidClassException' when the mock will be serialized",
+                        "",
+                        "Also note that as requested by the Java serialization specification, the whole hierarchy need to implements Serializable,",
+                        "i.e. the top-most superclass has to implements Serializable.",
+                        ""));
+    }
+
+    public static MockitoException delegatedMethodHasWrongReturnType(
+            Method mockMethod, Method delegateMethod, Object mock, Object delegate) {
+        return new MockitoException(
+                join(
+                        "Methods called on delegated instance must have compatible return types with the mock.",
+                        "When calling: " + mockMethod + " on mock: " + MockUtil.getMockName(mock),
+                        "return type should be: "
+                                + mockMethod.getReturnType().getSimpleName()
+                                + ", but was: "
+                                + delegateMethod.getReturnType().getSimpleName(),
+                        "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
+                        "(delegate instance had type: "
+                                + delegate.getClass().getSimpleName()
+                                + ")"));
+    }
+
+    public static MockitoException delegatedMethodDoesNotExistOnDelegate(
+            Method mockMethod, Object mock, Object delegate) {
+        return new MockitoException(
+                join(
+                        "Methods called on mock must exist in delegated instance.",
+                        "When calling: " + mockMethod + " on mock: " + MockUtil.getMockName(mock),
+                        "no such method was found.",
+                        "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
+                        "(delegate instance had type: "
+                                + delegate.getClass().getSimpleName()
+                                + ")"));
+    }
+
+    public static MockitoException usingConstructorWithFancySerializable(SerializableMode mode) {
+        return new MockitoException(
+                "Mocks instantiated with constructor cannot be combined with "
+                        + mode
+                        + " serialization mode.");
+    }
+
+    public static MockitoException cannotCreateTimerWithNegativeDurationTime(long durationMillis) {
+        return new FriendlyReminderException(
+                join(
+                        "",
+                        "Don't panic! I'm just a friendly reminder!",
+                        "It is impossible for time to go backward, therefore...",
+                        "You cannot put negative value of duration: (" + durationMillis + ")",
+                        "as argument of timer methods (after(), timeout())",
+                        ""));
+    }
+
+    public static MockitoException notAnException() {
+        return new MockitoException(
+                join(
+                        "Exception type cannot be null.",
+                        "This may happen with doThrow(Class)|thenThrow(Class) family of methods if passing null parameter."));
+    }
+
+    public static MockitoException inlineClassWithoutUnboxImpl(
+            Class<?> inlineClass, Exception details) {
+        return new MockitoException(
+                join(
+                        "Kotlin inline class should have unbox-impl() method,",
+                        "but " + inlineClass + " does not."),
+                details);
+    }
+
+    public static UnnecessaryStubbingException formatUnncessaryStubbingException(
+            Class<?> testClass, Collection<Invocation> unnecessaryStubbings) {
+        StringBuilder stubbings = new StringBuilder();
+        int count = 1;
+        for (Invocation u : unnecessaryStubbings) {
+            stubbings.append("\n  ").append(count++).append(". ").append(u.getLocation());
+        }
+        String heading =
+                (testClass != null)
+                        ? "Unnecessary stubbings detected in test class: "
+                                + testClass.getSimpleName()
+                        : "Unnecessary stubbings detected.";
+
+        return new UnnecessaryStubbingException(
+                join(
+                        heading,
+                        "Clean & maintainable test code requires zero unnecessary code.",
+                        "Following stubbings are unnecessary (click to navigate to relevant line of code):"
+                                + stubbings,
+                        "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."));
+    }
+
+    public static void unncessaryStubbingException(List<Invocation> unused) {
+        throw formatUnncessaryStubbingException(null, unused);
+    }
+
+    public static void potentialStubbingProblem(
+            Invocation actualInvocation, Collection<Invocation> argMismatchStubbings) {
+        StringBuilder stubbings = new StringBuilder();
+        int count = 1;
+        for (Invocation s : argMismatchStubbings) {
+            stubbings.append("    ").append(count++).append(". ").append(s);
+            stubbings.append("\n      ").append(s.getLocation()).append("\n");
+        }
+        stubbings.deleteCharAt(stubbings.length() - 1); // remove trailing end of line
+
+        throw new PotentialStubbingProblem(
+                join(
+                        "Strict stubbing argument mismatch. Please check:",
+                        " - this invocation of '"
+                                + actualInvocation.getMethod().getName()
+                                + "' method:",
+                        "    " + actualInvocation,
+                        "    " + actualInvocation.getLocation(),
+                        " - has following stubbing(s) with different arguments:",
+                        stubbings,
+                        "Typically, stubbing argument mismatch indicates user mistake when writing tests.",
+                        "Mockito fails early so that you can debug potential problem easily.",
+                        "However, there are legit scenarios when this exception generates false negative signal:",
+                        "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API",
+                        "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.",
+                        "  - stubbed method is intentionally invoked with different arguments by code under test",
+                        "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).",
+                        "For more information see javadoc for PotentialStubbingProblem class."));
+    }
+
+    public static void redundantMockitoListener(String listenerType) {
+        throw new RedundantListenerException(
+                join(
+                        "Problems adding Mockito listener.",
+                        "Listener of type '"
+                                + listenerType
+                                + "' has already been added and not removed.",
+                        "It indicates that previous listener was not removed according to the API.",
+                        "When you add a listener, don't forget to remove the listener afterwards:",
+                        "  Mockito.framework().removeListener(myListener);",
+                        "For more information, see the javadoc for RedundantListenerException class."));
+    }
+
+    public static void unfinishedMockingSession() {
+        throw new UnfinishedMockingSessionException(
+                join(
+                        "Unfinished mocking session detected.",
+                        "Previous MockitoSession was not concluded with 'finishMocking()'.",
+                        "For examples of correct usage see javadoc for MockitoSession class."));
+    }
+
+    public static void missingByteBuddyDependency(Throwable t) {
+        if (t instanceof NoClassDefFoundError
+                && t.getMessage() != null
+                && t.getMessage().startsWith("net/bytebuddy/")) {
+            throw new MockitoInitializationException(
+                    join(
+                            "It seems like you are running Mockito with an incomplete or inconsistent class path. Byte Buddy could not be loaded.",
+                            "",
+                            "Byte Buddy is available on Maven Central as 'net.bytebuddy:byte-buddy' with the module name 'net.bytebuddy'.",
+                            "For the inline mock maker, 'net.bytebuddy:byte-buddy-agent' with the module name 'net.bytebuddy.agent' is also required.",
+                            "Normally, your IDE or build tool (such as Maven or Gradle) should take care of your class path completion but "),
+                    t);
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
similarity index 99%
rename from src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
index f5bcd4e21f..865ee586ec 100644
--- a/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
+++ b/mockito-core/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
@@ -9,5 +9,4 @@
 public interface VerificationAwareInvocation extends DescribedInvocation {
 
     boolean isVerified();
-
 }
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java
similarity index 100%
rename from src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
new file mode 100644
index 0000000000..797515dea1
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.exceptions.stacktrace;
+
+import org.mockito.exceptions.stacktrace.StackTraceCleaner;
+
+/**
+ * This predicate is used to filter "good" {@link StackTraceElement}. Good
+ */
+public class DefaultStackTraceCleaner implements StackTraceCleaner {
+
+    @Override
+    public boolean isIn(StackTraceElement e) {
+        return isIn(e.getClassName());
+    }
+
+    @Override
+    public boolean isIn(StackFrameMetadata e) {
+        return isIn(e.getClassName());
+    }
+
+    private boolean isIn(String className) {
+        if (isFromMockitoRunner(className) || isFromMockitoRule(className)) {
+            return true;
+        } else if (isMockDispatcher(className)
+                || isFromMockito(className)
+                || isMethodHandle(className)) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /* Some mock makers (like inline) use java.lang.invoke.MethodHandle to dispatch calls */
+    private static boolean isMethodHandle(String className) {
+        return className.startsWith("java.lang.invoke.MethodHandle");
+    }
+
+    private static boolean isMockDispatcher(String className) {
+        return (className.contains("$$EnhancerByMockitoWithCGLIB$$")
+                || className.contains("$MockitoMock$"));
+    }
+
+    private static boolean isFromMockito(String className) {
+        return className.startsWith("org.mockito.");
+    }
+
+    private static boolean isFromMockitoRule(String className) {
+        return className.startsWith("org.mockito.internal.junit.JUnitRule");
+    }
+
+    private static boolean isFromMockitoRunner(String className) {
+        return className.startsWith("org.mockito.internal.runners.")
+                || className.startsWith("org.mockito.runners.")
+                || className.startsWith("org.mockito.junit.");
+    }
+}
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
similarity index 97%
rename from src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
index ef500ceb95..4a23639751 100644
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
+++ b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
@@ -12,6 +12,7 @@
  */
 public class DefaultStackTraceCleanerProvider implements StackTraceCleanerProvider {
 
+    @Override
     public StackTraceCleaner getStackTraceCleaner(StackTraceCleaner defaultCleaner) {
         return defaultCleaner;
     }
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
similarity index 82%
rename from src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
index e846795d6d..3ac9e1389d 100644
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
+++ b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
@@ -17,7 +17,8 @@ public class StackTraceFilter implements Serializable {
     static final long serialVersionUID = -5499819791513105700L;
 
     private static final StackTraceCleaner CLEANER =
-            Plugins.getStackTraceCleanerProvider().getStackTraceCleaner(new DefaultStackTraceCleaner());
+            Plugins.getStackTraceCleanerProvider()
+                    .getStackTraceCleaner(new DefaultStackTraceCleaner());
 
     private static Object JAVA_LANG_ACCESS;
     private static Method GET_STACK_TRACE_ELEMENT;
@@ -25,12 +26,12 @@ public class StackTraceFilter implements Serializable {
     static {
         try {
             JAVA_LANG_ACCESS =
-                Class.forName("sun.misc.SharedSecrets")
-                    .getMethod("getJavaLangAccess")
-                    .invoke(null);
+                    Class.forName("sun.misc.SharedSecrets")
+                            .getMethod("getJavaLangAccess")
+                            .invoke(null);
             GET_STACK_TRACE_ELEMENT =
-                Class.forName("sun.misc.JavaLangAccess")
-                    .getMethod("getStackTraceElement", Throwable.class, int.class);
+                    Class.forName("sun.misc.JavaLangAccess")
+                            .getMethod("getStackTraceElement", Throwable.class, int.class);
         } catch (Exception ignored) {
             // Use the slow computational path for filtering stacktraces if fast path does not exist
             // in JVM
@@ -44,9 +45,9 @@ public class StackTraceFilter implements Serializable {
      * <strike>If any good are in the middle of bad those are also removed.</strike>
      */
     public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) {
-        //TODO: profile
-        //TODO: investigate "keepTop" commit history - no effect!
-        final List<StackTraceElement> filtered = new ArrayList<StackTraceElement>();
+        // TODO: profile
+        // TODO: investigate "keepTop" commit history - no effect!
+        final List<StackTraceElement> filtered = new ArrayList<>();
         for (StackTraceElement element : target) {
             if (CLEANER.isIn(element)) {
                 filtered.add(element);
@@ -58,10 +59,10 @@ public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) {
 
     /**
      * This filtering strategy makes use of a fast-path computation to retrieve stackTraceElements
-     * from a Stacktrace of a Throwable. It does so, by taking advantage of {@link
-     * sun.misc.SharedSecrets} and {@link sun.misc.JavaLangAccess}.
+     * from a Stacktrace of a Throwable. It does so, by taking advantage of {@see
+     * sun.misc.SharedSecrets} and {@see sun.misc.JavaLangAccess}.
      *
-     * <p>The {@link sun.misc.SharedSecrets} provides a method to obtain an instance of an {@link
+     * <p>The {@see sun.misc.SharedSecrets} provides a method to obtain an instance of an {@see
      * sun.misc.JavaLangAccess}. The latter class has a method to fast-path into {@link
      * Throwable#getStackTrace()} and retrieve a single {@link StackTraceElement}. This prevents the
      * JVM from having to generate a full stacktrace, which could potentially be expensive if
@@ -85,8 +86,8 @@ public StackTraceElement filterFirst(Throwable target, boolean isInline) {
             while (true) {
                 try {
                     StackTraceElement stackTraceElement =
-                        (StackTraceElement)
-                            GET_STACK_TRACE_ELEMENT.invoke(JAVA_LANG_ACCESS, target, i);
+                            (StackTraceElement)
+                                    GET_STACK_TRACE_ELEMENT.invoke(JAVA_LANG_ACCESS, target, i);
 
                     if (CLEANER.isIn(stackTraceElement)) {
                         if (shouldSkip) {
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/package-info.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/exceptions/stacktrace/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/stacktrace/package-info.java
diff --git a/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java b/mockito-core/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
similarity index 78%
rename from src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
rename to mockito-core/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
index a3e60fe6e1..7b4375d423 100644
--- a/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
+++ b/mockito-core/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
@@ -14,9 +14,10 @@ public String print(List<VerificationAwareInvocation> invocations) {
         if (invocations.size() == 1) {
             return "Actually, above is the only interaction with this mock.";
         }
-        StringBuilder sb = new StringBuilder(
-                "***\n" +
-                "For your reference, here is the list of all invocations ([?] - means unverified).\n");
+        StringBuilder sb =
+                new StringBuilder(
+                        "***\n"
+                                + "For your reference, here is the list of all invocations ([?] - means unverified).\n");
 
         int counter = 0;
         for (VerificationAwareInvocation i : invocations) {
@@ -28,5 +29,4 @@ public String print(List<VerificationAwareInvocation> invocations) {
         }
         return sb.toString();
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java b/mockito-core/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
similarity index 98%
rename from src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
rename to mockito-core/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
index cb9818e543..f4a988231a 100644
--- a/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
+++ b/mockito-core/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
@@ -18,12 +18,14 @@
 
 public class DefaultMockitoFramework implements MockitoFramework {
 
+    @Override
     public MockitoFramework addListener(MockitoListener listener) {
         Checks.checkNotNull(listener, "listener");
         mockingProgress().addListener(listener);
         return this;
     }
 
+    @Override
     public MockitoFramework removeListener(MockitoListener listener) {
         Checks.checkNotNull(listener, "listener");
         mockingProgress().removeListener(listener);
diff --git a/mockito-core/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java b/mockito-core/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
new file mode 100644
index 0000000000..549019d135
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.framework;
+
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.MockitoSession;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.RedundantListenerException;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.junit.TestFinishedEvent;
+import org.mockito.internal.junit.UniversalTestListener;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DefaultMockitoSession implements MockitoSession {
+
+    private final String name;
+    private final UniversalTestListener listener;
+
+    private final List<AutoCloseable> closeables = new ArrayList<>();
+
+    public DefaultMockitoSession(
+            List<Object> testClassInstances,
+            String name,
+            Strictness strictness,
+            MockitoLogger logger) {
+        this.name = name;
+        listener = new UniversalTestListener(strictness, logger);
+        try {
+            // So that the listener can capture mock creation events
+            Mockito.framework().addListener(listener);
+        } catch (RedundantListenerException e) {
+            Reporter.unfinishedMockingSession();
+        }
+        try {
+            for (Object testClassInstance : testClassInstances) {
+                closeables.add(MockitoAnnotations.openMocks(testClassInstance));
+            }
+        } catch (RuntimeException e) {
+            try {
+                release();
+            } catch (Throwable t) {
+                e.addSuppressed(t);
+            }
+
+            // clean up in case 'openMocks' fails
+            listener.setListenerDirty();
+            throw e;
+        }
+    }
+
+    @Override
+    public void setStrictness(Strictness strictness) {
+        listener.setStrictness(strictness);
+    }
+
+    @Override
+    public void finishMocking() {
+        finishMocking(null);
+    }
+
+    @Override
+    public void finishMocking(final Throwable failure) {
+        try {
+            // Cleaning up the state, we no longer need the listener hooked up
+            // The listener implements MockCreationListener and at this point
+            // we no longer need to listen on mock creation events. We are wrapping up the session
+            Mockito.framework().removeListener(listener);
+
+            // Emit test finished event so that validation such as strict stubbing can take place
+            listener.testFinished(
+                    new TestFinishedEvent() {
+                        @Override
+                        public Throwable getFailure() {
+                            return failure;
+                        }
+
+                        @Override
+                        public String getTestName() {
+                            return name;
+                        }
+                    });
+
+            // Validate only when there is no test failure to avoid reporting multiple problems
+            if (failure == null) {
+                // Finally, validate user's misuse of Mockito framework.
+                Mockito.validateMockitoUsage();
+            }
+        } finally {
+            release();
+        }
+    }
+
+    private void release() {
+        for (AutoCloseable closeable : closeables) {
+            try {
+                closeable.close();
+            } catch (Exception e) {
+                throw new MockitoException("Failed to release " + closeable, e);
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/framework/DisabledMockHandler.java b/mockito-core/src/main/java/org/mockito/internal/framework/DisabledMockHandler.java
new file mode 100644
index 0000000000..7803ec2d83
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/framework/DisabledMockHandler.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.framework;
+
+import org.mockito.MockitoFramework;
+import org.mockito.exceptions.misusing.DisabledMockException;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
+import org.mockito.invocation.MockHandler;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.listeners.VerificationStartedListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
+import org.mockito.mock.SerializableMode;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
+import java.io.Serializable;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Throws {@link DisabledMockException} when a mock is accessed after it has been disabled by
+ * {@link MockitoFramework#clearInlineMocks()}.
+ */
+public class DisabledMockHandler implements MockHandler {
+    public static MockHandler HANDLER = new DisabledMockHandler();
+
+    private DisabledMockHandler() {
+        // private, use HANDLER instead
+    }
+
+    @Override
+    public Object handle(Invocation invocation) {
+        throw new DisabledMockException();
+    }
+
+    @Override
+    public MockCreationSettings getMockSettings() {
+        return DisabledMockCreationSettings.INSTANCE;
+    }
+
+    @Override
+    public InvocationContainer getInvocationContainer() {
+        return null;
+    }
+
+    private static class DisabledMockCreationSettings
+            implements Serializable, MockCreationSettings {
+        private static DisabledMockCreationSettings INSTANCE = new DisabledMockCreationSettings();
+
+        private DisabledMockCreationSettings() {
+            // USE INSTANCE
+        }
+
+        @Override
+        public Class getTypeToMock() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Type getGenericTypeToMock() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Set<Class<?>> getExtraInterfaces() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public MockName getMockName() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Answer<?> getDefaultAnswer() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Object getSpiedInstance() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public boolean isSerializable() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public SerializableMode getSerializableMode() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public boolean isStubOnly() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public boolean isStripAnnotations() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public List<StubbingLookupListener> getStubbingLookupListeners() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public List<InvocationListener> getInvocationListeners() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public List<VerificationStartedListener> getVerificationStartedListeners() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public boolean isUsingConstructor() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Object[] getConstructorArgs() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Object getOuterClassInstance() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public boolean isLenient() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public Strictness getStrictness() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public String getMockMaker() {
+            throw new DisabledMockException();
+        }
+
+        @Override
+        public MockType getMockType() {
+            throw new DisabledMockException();
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java b/mockito-core/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
new file mode 100644
index 0000000000..f9ef55d528
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.hamcrest;
+
+import org.hamcrest.Matcher;
+import org.hamcrest.StringDescription;
+import org.mockito.ArgumentMatcher;
+
+import static java.util.Objects.requireNonNull;
+
+public class HamcrestArgumentMatcher<T> implements ArgumentMatcher<T> {
+
+    private final Matcher<T> matcher;
+    private final Class<?> type;
+
+    public HamcrestArgumentMatcher(Matcher<T> matcher) {
+        this(Void.class, matcher);
+    }
+
+    public HamcrestArgumentMatcher(Matcher<T> matcher, Class<T> type) {
+        this(type, matcher);
+    }
+
+    private HamcrestArgumentMatcher(Class<?> type, Matcher<T> matcher) {
+        this.type = requireNonNull(type, "type");
+        this.matcher = requireNonNull(matcher, "matcher");
+    }
+
+    @Override
+    public boolean matches(Object argument) {
+        return this.matcher.matches(argument);
+    }
+
+    @Override
+    public String toString() {
+        // TODO SF add unit tests and integ test coverage for toString()
+        return StringDescription.toString(matcher);
+    }
+
+    @Override
+    public Class<?> type() {
+        return type;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java b/mockito-core/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
similarity index 75%
rename from src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
rename to mockito-core/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
index 5c154f4d4c..5d46ad796f 100644
--- a/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
+++ b/mockito-core/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
@@ -9,17 +9,17 @@
 import org.hamcrest.BaseMatcher;
 import org.hamcrest.Matcher;
 
-/**
- * Extracts generic type of matcher
- */
-public class MatcherGenericTypeExtractor {
+/** Extracts generic type of matcher */
+public final class MatcherGenericTypeExtractor {
 
     /**
      * Gets the generic type of given matcher. For example,
      * for matcher class that extends BaseMatcher[Integer] this method returns Integer
      */
     public static Class<?> genericTypeOfMatcher(Class<?> matcherClass) {
-        //TODO SF check if we can reuse it for Mockito ArgumentMatcher
+        // TODO SF check if we can reuse it for Mockito ArgumentMatcher
         return genericTypeOf(matcherClass, BaseMatcher.class, Matcher.class);
     }
+
+    private MatcherGenericTypeExtractor() {}
 }
diff --git a/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java b/mockito-core/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
similarity index 83%
rename from src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
rename to mockito-core/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
index 2c26b3ddfa..b1c84dfd9c 100644
--- a/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
+++ b/mockito-core/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
@@ -28,23 +28,24 @@ public InvocationNotifierHandler(MockHandler<T> mockHandler, MockCreationSetting
         this.invocationListeners = settings.getInvocationListeners();
     }
 
+    @Override
     public Object handle(Invocation invocation) throws Throwable {
         try {
             Object returnedValue = mockHandler.handle(invocation);
             notifyMethodCall(invocation, returnedValue);
             return returnedValue;
-        } catch (Throwable t){
+        } catch (Throwable t) {
             notifyMethodCallException(invocation, t);
             throw t;
         }
     }
 
-
     private void notifyMethodCall(Invocation invocation, Object returnValue) {
         for (InvocationListener listener : invocationListeners) {
             try {
-                listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, returnValue));
-            } catch(Throwable listenerThrowable) {
+                listener.reportInvocation(
+                        new NotifiedMethodInvocationReport(invocation, returnValue));
+            } catch (Throwable listenerThrowable) {
                 throw invocationListenerThrewException(listener, listenerThrowable);
             }
         }
@@ -53,19 +54,21 @@ private void notifyMethodCall(Invocation invocation, Object returnValue) {
     private void notifyMethodCallException(Invocation invocation, Throwable exception) {
         for (InvocationListener listener : invocationListeners) {
             try {
-                listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, exception));
-            } catch(Throwable listenerThrowable) {
+                listener.reportInvocation(
+                        new NotifiedMethodInvocationReport(invocation, exception));
+            } catch (Throwable listenerThrowable) {
                 throw invocationListenerThrewException(listener, listenerThrowable);
             }
         }
     }
 
+    @Override
     public MockCreationSettings<T> getMockSettings() {
         return mockHandler.getMockSettings();
     }
 
+    @Override
     public InvocationContainer getInvocationContainer() {
         return mockHandler.getInvocationContainer();
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java b/mockito-core/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
similarity index 82%
rename from src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
rename to mockito-core/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
index e8b44cb44c..c735cd43c0 100644
--- a/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
+++ b/mockito-core/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
@@ -7,14 +7,14 @@
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
 
-/**
- * by Szczepan Faber, created at: 5/21/12
- */
-public class MockHandlerFactory {
+/** by Szczepan Faber, created at: 5/21/12 */
+public final class MockHandlerFactory {
 
     public static <T> MockHandler<T> createMockHandler(MockCreationSettings<T> settings) {
         MockHandler<T> handler = new MockHandlerImpl<T>(settings);
         MockHandler<T> nullResultGuardian = new NullResultGuardian<T>(handler);
         return new InvocationNotifierHandler<T>(nullResultGuardian, settings);
     }
+
+    private MockHandlerFactory() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java b/mockito-core/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
new file mode 100644
index 0000000000..e58659a166
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.handler;
+
+import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.invocation.MatchersBinder;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockito.internal.stubbing.OngoingStubbingImpl;
+import org.mockito.internal.stubbing.StubbedInvocationMatcher;
+import org.mockito.internal.stubbing.answers.DefaultAnswerValidator;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.verification.MockAwareVerificationMode;
+import org.mockito.internal.verification.VerificationDataImpl;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.verification.VerificationMode;
+
+/**
+ * Invocation handler set on mock objects.
+ *
+ * @param <T> type of mock object to handle
+ */
+public class MockHandlerImpl<T> implements MockHandler<T> {
+
+    private static final long serialVersionUID = -2917871070982574165L;
+
+    InvocationContainerImpl invocationContainer;
+
+    MatchersBinder matchersBinder = new MatchersBinder();
+
+    private final MockCreationSettings<T> mockSettings;
+
+    public MockHandlerImpl(MockCreationSettings<T> mockSettings) {
+        this.mockSettings = mockSettings;
+
+        this.matchersBinder = new MatchersBinder();
+        this.invocationContainer = new InvocationContainerImpl(mockSettings);
+    }
+
+    @Override
+    public Object handle(Invocation invocation) throws Throwable {
+        if (invocationContainer.hasAnswersForStubbing()) {
+            // stubbing voids with doThrow() or doAnswer() style
+            InvocationMatcher invocationMatcher =
+                    matchersBinder.bindMatchers(
+                            mockingProgress().getArgumentMatcherStorage(), invocation);
+            invocationContainer.setMethodForStubbing(invocationMatcher);
+            return null;
+        }
+        VerificationMode verificationMode = mockingProgress().pullVerificationMode();
+
+        InvocationMatcher invocationMatcher =
+                matchersBinder.bindMatchers(
+                        mockingProgress().getArgumentMatcherStorage(), invocation);
+
+        mockingProgress().validateState();
+
+        // if verificationMode is not null then someone is doing verify()
+        if (verificationMode != null) {
+            // We need to check if verification was started on the correct mock
+            // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
+            if (MockUtil.areSameMocks(
+                    ((MockAwareVerificationMode) verificationMode).getMock(),
+                    invocation.getMock())) {
+                VerificationDataImpl data =
+                        new VerificationDataImpl(invocationContainer, invocationMatcher);
+                verificationMode.verify(data);
+                return null;
+            } else {
+                // this means there is an invocation on a different mock. Re-adding verification
+                // mode
+                // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
+                mockingProgress().verificationStarted(verificationMode);
+            }
+        }
+
+        // prepare invocation for stubbing
+        invocationContainer.setInvocationForPotentialStubbing(invocationMatcher);
+        OngoingStubbingImpl<T> ongoingStubbing = new OngoingStubbingImpl<T>(invocationContainer);
+        mockingProgress().reportOngoingStubbing(ongoingStubbing);
+
+        // look for existing answer for this invocation
+        StubbedInvocationMatcher stubbing = invocationContainer.findAnswerFor(invocation);
+        // 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);
+
+            try {
+                return stubbing.answer(invocation);
+            } finally {
+                // Needed so that we correctly isolate stubbings in some scenarios
+                // see MockitoStubbedCallInAnswerTest or issue #1279
+                mockingProgress().reportOngoingStubbing(ongoingStubbing);
+            }
+        } else {
+            try {
+                Object ret = mockSettings.getDefaultAnswer().answer(invocation);
+                DefaultAnswerValidator.validateReturnValueFor(invocation, ret);
+
+                return ret;
+            } finally {
+                // Mockito uses it to redo setting invocation for potential stubbing in case of
+                // partial
+                // mocks / spies.
+                // Without it, the real method inside 'when' might have delegated to other self
+                // method
+                // and overwrite the intended stubbed method with a different one.
+                // This means we would be stubbing a wrong method.
+                // Typically this would led to runtime exception that validates return type with
+                // stubbed
+                // method signature.
+                invocationContainer.resetInvocationForPotentialStubbing(invocationMatcher);
+                mockingProgress().reportOngoingStubbing(ongoingStubbing);
+            }
+        }
+    }
+
+    @Override
+    public MockCreationSettings<T> getMockSettings() {
+        return mockSettings;
+    }
+
+    @Override
+    public InvocationContainer getInvocationContainer() {
+        return invocationContainer;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java b/mockito-core/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
similarity index 80%
rename from src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
rename to mockito-core/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
index e44543df57..39871c8fc7 100644
--- a/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
+++ b/mockito-core/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
@@ -18,7 +18,6 @@ public class NotifiedMethodInvocationReport implements MethodInvocationReport {
     private final Object returnedValue;
     private final Throwable throwable;
 
-
     /**
      * Build a new {@link org.mockito.listeners.MethodInvocationReport} with a return value.
      *
@@ -45,38 +44,50 @@ public NotifiedMethodInvocationReport(Invocation invocation, Throwable throwable
         this.throwable = throwable;
     }
 
+    @Override
     public DescribedInvocation getInvocation() {
         return invocation;
     }
 
+    @Override
     public Object getReturnedValue() {
         return returnedValue;
     }
 
+    @Override
     public Throwable getThrowable() {
         return throwable;
     }
 
+    @Override
     public boolean threwException() {
         return throwable != null;
     }
 
+    @Override
     public String getLocationOfStubbing() {
-        return (invocation.stubInfo() == null) ? null : invocation.stubInfo().stubbedAt().toString();
+        return (invocation.stubInfo() == null)
+                ? null
+                : invocation.stubInfo().stubbedAt().toString();
     }
 
-
+    @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
 
         NotifiedMethodInvocationReport that = (NotifiedMethodInvocationReport) o;
 
-        return areEqual(invocation, that.invocation) &&
-               areEqual(returnedValue, that.returnedValue) &&
-               areEqual(throwable, that.throwable);
+        return areEqual(invocation, that.invocation)
+                && areEqual(returnedValue, that.returnedValue)
+                && areEqual(throwable, that.throwable);
     }
 
+    @Override
     public int hashCode() {
         int result = invocation != null ? invocation.hashCode() : 0;
         result = 31 * result + (returnedValue != null ? returnedValue.hashCode() : 0);
diff --git a/src/main/java/org/mockito/internal/handler/NullResultGuardian.java b/mockito-core/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
similarity index 92%
rename from src/main/java/org/mockito/internal/handler/NullResultGuardian.java
rename to mockito-core/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
index 10671d7ced..65de62e069 100644
--- a/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
+++ b/mockito-core/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
@@ -28,12 +28,12 @@ public NullResultGuardian(MockHandler<T> delegate) {
     public Object handle(Invocation invocation) throws Throwable {
         Object result = delegate.handle(invocation);
         Class<?> returnType = invocation.getMethod().getReturnType();
-        if(result == null && returnType.isPrimitive()) {
-            //primitive values cannot be null
+        if (result == null && returnType.isPrimitive()) {
+            // primitive values cannot be null
             return defaultValue(returnType);
         }
         return result;
-     }
+    }
 
     @Override
     public MockCreationSettings<T> getMockSettings() {
diff --git a/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java b/mockito-core/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java
similarity index 100%
rename from src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java
diff --git a/src/main/java/org/mockito/internal/invocation/ArgumentMatcherAction.java b/mockito-core/src/main/java/org/mockito/internal/invocation/ArgumentMatcherAction.java
similarity index 100%
rename from src/main/java/org/mockito/internal/invocation/ArgumentMatcherAction.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/ArgumentMatcherAction.java
diff --git a/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java b/mockito-core/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
similarity index 75%
rename from src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
index be642bfc1e..aa3edf0bda 100644
--- a/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
@@ -12,23 +12,26 @@
 import org.mockito.internal.matchers.ArrayEquals;
 import org.mockito.internal.matchers.Equals;
 
-/**
- * by Szczepan Faber, created at: 3/31/12
- */
-public class ArgumentsProcessor {
-    // drops hidden synthetic parameters (last continuation parameter from Kotlin suspending functions)
+/** by Szczepan Faber, created at: 3/31/12 */
+public final class ArgumentsProcessor {
+    // drops hidden synthetic parameters (last continuation parameter from Kotlin suspending
+    // functions)
     // and expands varargs
     public static Object[] expandArgs(MockitoMethod method, Object[] args) {
         int nParams = method.getParameterTypes().length;
-        if (args != null && args.length > nParams)
-            args = Arrays.copyOf(args, nParams); // drop extra args (currently -- Kotlin continuation synthetic arg)
+        if (args != null && args.length > nParams) {
+            args = Arrays.copyOf(args, nParams);
+        } // drop extra args (currently -- Kotlin continuation synthetic
+        // arg)
         return expandVarArgs(method.isVarArgs(), args);
     }
 
     // expands array varArgs that are given by runtime (1, [a, b]) into true
     // varArgs (1, a, b);
     private static Object[] expandVarArgs(final boolean isVarArgs, final Object[] args) {
-        if (!isVarArgs || isNullOrEmpty(args) || args[args.length - 1] != null && !args[args.length - 1].getClass().isArray()) {
+        if (!isVarArgs
+                || isNullOrEmpty(args)
+                || (args[args.length - 1] != null && !args[args.length - 1].getClass().isArray())) {
             return args == null ? new Object[0] : args;
         }
 
@@ -36,7 +39,7 @@ private static Object[] expandVarArgs(final boolean isVarArgs, final Object[] ar
         Object[] varArgs;
         if (args[nonVarArgsCount] == null) {
             // in case someone deliberately passed null varArg array
-            varArgs = new Object[] { null };
+            varArgs = new Object[] {null};
         } else {
             varArgs = ArrayEquals.createObjectArray(args[nonVarArgsCount]);
         }
@@ -52,7 +55,7 @@ private static <T> boolean isNullOrEmpty(T[] array) {
     }
 
     public static List<ArgumentMatcher> argumentsToMatchers(Object[] arguments) {
-        List<ArgumentMatcher> matchers = new ArrayList<ArgumentMatcher>(arguments.length);
+        List<ArgumentMatcher> matchers = new ArrayList<>(arguments.length);
         for (Object arg : arguments) {
             if (arg != null && arg.getClass().isArray()) {
                 matchers.add(new ArrayEquals(arg));
@@ -63,5 +66,5 @@ public static List<ArgumentMatcher> argumentsToMatchers(Object[] arguments) {
         return matchers;
     }
 
-
+    private ArgumentsProcessor() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java b/mockito-core/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
new file mode 100644
index 0000000000..4921f4006d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+
+import org.mockito.internal.creation.DelegatingMethod;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
+import org.mockito.internal.progress.SequenceNumber;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
+import org.mockito.invocation.Location;
+import org.mockito.mock.MockCreationSettings;
+
+public class DefaultInvocationFactory implements InvocationFactory {
+
+    public Invocation createInvocation(
+            Object target,
+            MockCreationSettings settings,
+            Method method,
+            final Callable realMethod,
+            Object... args) {
+        RealMethod superMethod = new RealMethod.FromCallable(realMethod);
+        return createInvocation(target, settings, method, superMethod, args);
+    }
+
+    @Override
+    public Invocation createInvocation(
+            Object target,
+            MockCreationSettings settings,
+            Method method,
+            RealMethodBehavior realMethod,
+            Object... args) {
+        RealMethod superMethod = new RealMethod.FromBehavior(realMethod);
+        return createInvocation(target, settings, method, superMethod, args);
+    }
+
+    private Invocation createInvocation(
+            Object target,
+            MockCreationSettings settings,
+            Method method,
+            RealMethod superMethod,
+            Object[] args) {
+        return createInvocation(target, method, args, superMethod, settings);
+    }
+
+    public static InterceptedInvocation createInvocation(
+            Object mock,
+            Method invokedMethod,
+            Object[] arguments,
+            RealMethod realMethod,
+            MockCreationSettings settings,
+            Location location) {
+        return new InterceptedInvocation(
+                new MockWeakReference<Object>(mock),
+                createMockitoMethod(invokedMethod, settings),
+                arguments,
+                realMethod,
+                location,
+                SequenceNumber.next());
+    }
+
+    private static InterceptedInvocation createInvocation(
+            Object mock,
+            Method invokedMethod,
+            Object[] arguments,
+            RealMethod realMethod,
+            MockCreationSettings settings) {
+        return createInvocation(
+                mock, invokedMethod, arguments, realMethod, settings, LocationFactory.create());
+    }
+
+    private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
+        if (settings.isSerializable()) {
+            return new SerializableMethod(method);
+        } else {
+            return new DelegatingMethod(method);
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java b/mockito-core/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
similarity index 79%
rename from src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
index 0c7535cc47..20316ecd04 100644
--- a/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
@@ -25,7 +25,8 @@ public class InterceptedInvocation implements Invocation, VerificationAwareInvoc
 
     private final MockReference<Object> mockRef;
     private final MockitoMethod mockitoMethod;
-    private final Object[] arguments, rawArguments;
+    private final Object[] arguments;
+    private final Object[] rawArguments;
     private final RealMethod realMethod;
 
     private final int sequenceNumber;
@@ -36,12 +37,13 @@ public class InterceptedInvocation implements Invocation, VerificationAwareInvoc
     private boolean isIgnoredForVerification;
     private StubInfo stubInfo;
 
-    public InterceptedInvocation(MockReference<Object> mockRef,
-                                 MockitoMethod mockitoMethod,
-                                 Object[] arguments,
-                                 RealMethod realMethod,
-                                 Location location,
-                                 int sequenceNumber) {
+    public InterceptedInvocation(
+            MockReference<Object> mockRef,
+            MockitoMethod mockitoMethod,
+            Object[] arguments,
+            RealMethod realMethod,
+            Location location,
+            int sequenceNumber) {
         this.mockRef = mockRef;
         this.mockitoMethod = mockitoMethod;
         this.arguments = ArgumentsProcessor.expandArgs(mockitoMethod, arguments);
@@ -122,16 +124,9 @@ public <T> T getArgument(int index) {
         return (T) arguments[index];
     }
 
-    public MockReference<Object> getMockRef() {
-        return mockRef;
-    }
-
-    public MockitoMethod getMockitoMethod() {
-        return mockitoMethod;
-    }
-
-    public RealMethod getRealMethod() {
-        return realMethod;
+    @Override
+    public <T> T getArgument(int index, Class<T> clazz) {
+        return clazz.cast(arguments[index]);
     }
 
     @Override
@@ -139,11 +134,6 @@ public List<ArgumentMatcher> getArgumentsAsMatchers() {
         return argumentsToMatchers(getArguments());
     }
 
-    @Override
-    public <T> T getArgument(int index, Class<T> clazz) {
-        return clazz.cast(arguments[index]);
-    }
-
     @Override
     public Object callRealMethod() throws Throwable {
         if (!realMethod.isInvokable()) {
@@ -152,15 +142,40 @@ public Object callRealMethod() throws Throwable {
         return realMethod.invoke();
     }
 
+    /**
+     * @deprecated Not used by Mockito but by mockito-scala
+     */
+    @Deprecated
+    public MockReference<Object> getMockRef() {
+        return mockRef;
+    }
+
+    /**
+     * @deprecated Not used by Mockito but by mockito-scala
+     */
+    @Deprecated
+    public MockitoMethod getMockitoMethod() {
+        return mockitoMethod;
+    }
+
+    /**
+     * @deprecated Not used by Mockito but by mockito-scala
+     */
+    @Deprecated
+    public RealMethod getRealMethod() {
+        return realMethod;
+    }
+
     @Override
     public int hashCode() {
-        //TODO SF we need to provide hash code implementation so that there are no unexpected, slight perf issues
+        // TODO SF we need to provide hash code implementation so that there are no unexpected,
+        // slight perf issues
         return 1;
     }
 
     @Override
     public boolean equals(Object o) {
-        if (o == null || !o.getClass().equals(this.getClass())) {
+        if (!(o instanceof InterceptedInvocation)) {
             return false;
         }
         InterceptedInvocation other = (InterceptedInvocation) o;
@@ -173,17 +188,20 @@ private boolean equalArguments(Object[] arguments) {
         return Arrays.equals(arguments, this.arguments);
     }
 
+    @Override
     public String toString() {
         return new PrintSettings().print(getArgumentsAsMatchers(), this);
     }
 
-    public final static RealMethod NO_OP = new RealMethod() {
-        public boolean isInvokable() {
-            return false;
-        }
-        public Object invoke() throws Throwable {
-            return null;
-        }
-    };
+    public static final RealMethod NO_OP =
+            new RealMethod() {
+                @Override
+                public boolean isInvokable() {
+                    return false;
+                }
 
+                public Object invoke() throws Throwable {
+                    return null;
+                }
+            };
 }
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationComparator.java b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
similarity index 82%
rename from src/main/java/org/mockito/internal/invocation/InvocationComparator.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
index f15964c71a..2af9358950 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
@@ -12,7 +12,8 @@
  * Compares invocations based on the sequence number
  */
 public class InvocationComparator implements Comparator<Invocation> {
+    @Override
     public int compare(Invocation o1, Invocation o2) {
-        return Integer.valueOf(o1.getSequenceNumber()).compareTo(o2.getSequenceNumber());
+        return Integer.compare(o1.getSequenceNumber(), o2.getSequenceNumber());
     }
 }
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationMarker.java b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
similarity index 84%
rename from src/main/java/org/mockito/internal/invocation/InvocationMarker.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
index d960e86b13..5f32dea4b8 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
@@ -12,7 +12,7 @@
 
 public class InvocationMarker {
 
-    private InvocationMarker(){}
+    private InvocationMarker() {}
 
     public static void markVerified(List<Invocation> invocations, MatchableInvocation wanted) {
         for (Invocation invocation : invocations) {
@@ -25,7 +25,8 @@ public static void markVerified(Invocation invocation, MatchableInvocation wante
         wanted.captureArgumentsFrom(invocation);
     }
 
-    public static void markVerifiedInOrder(List<Invocation> chunk, MatchableInvocation wanted, InOrderContext context) {
+    public static void markVerifiedInOrder(
+            List<Invocation> chunk, MatchableInvocation wanted, InOrderContext context) {
         markVerified(chunk, wanted);
 
         for (Invocation i : chunk) {
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
similarity index 86%
rename from src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
index 81bd483ab1..6cc7a8c49f 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
@@ -31,7 +31,7 @@ public class InvocationMatcher implements MatchableInvocation, DescribedInvocati
     private final Invocation invocation;
     private final List<ArgumentMatcher<?>> matchers;
 
-    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public InvocationMatcher(Invocation invocation, List<ArgumentMatcher> matchers) {
         this.invocation = invocation;
         if (matchers.isEmpty()) {
@@ -43,11 +43,11 @@ public InvocationMatcher(Invocation invocation, List<ArgumentMatcher> matchers)
 
     @SuppressWarnings("rawtypes")
     public InvocationMatcher(Invocation invocation) {
-        this(invocation, Collections.<ArgumentMatcher> emptyList());
+        this(invocation, Collections.<ArgumentMatcher>emptyList());
     }
 
     public static List<InvocationMatcher> createFrom(List<Invocation> invocations) {
-        LinkedList<InvocationMatcher> out = new LinkedList<InvocationMatcher>();
+        LinkedList<InvocationMatcher> out = new LinkedList<>();
         for (Invocation i : invocations) {
             out.add(new InvocationMatcher(i));
         }
@@ -64,20 +64,22 @@ public Invocation getInvocation() {
     }
 
     @Override
-    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @SuppressWarnings({"unchecked", "rawtypes"})
     public List<ArgumentMatcher> getMatchers() {
         return (List) matchers;
     }
 
     @Override
-    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @SuppressWarnings({"unchecked", "rawtypes"})
     public String toString() {
         return new PrintSettings().print((List) matchers, invocation);
     }
 
     @Override
     public boolean matches(Invocation candidate) {
-        return invocation.getMock().equals(candidate.getMock()) && hasSameMethod(candidate) && argumentsMatch(candidate);
+        return invocation.getMock() == candidate.getMock()
+                && hasSameMethod(candidate)
+                && argumentsMatch(candidate);
     }
 
     /**
@@ -107,7 +109,8 @@ public boolean hasSimilarMethod(Invocation candidate) {
     @Override
     public boolean hasSameMethod(Invocation candidate) {
         // not using method.equals() for 1 good reason:
-        // sometimes java generates forwarding methods when generics are in play see JavaGenericsForwardingMethodsTest
+        // sometimes java generates forwarding methods when generics are in play see
+        // JavaGenericsForwardingMethodsTest
         Method m1 = invocation.getMethod();
         Method m2 = candidate.getMethod();
 
@@ -127,7 +130,8 @@ public Location getLocation() {
 
     @Override
     public void captureArgumentsFrom(Invocation invocation) {
-        MatcherApplicationStrategy strategy = getMatcherApplicationStrategyFor(invocation, matchers);
+        MatcherApplicationStrategy strategy =
+                getMatcherApplicationStrategyFor(invocation, matchers);
         strategy.forEachMatcherAndArgument(captureArgument());
     }
 
@@ -145,9 +149,10 @@ public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
         };
     }
 
-    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @SuppressWarnings({"rawtypes", "unchecked"})
     private boolean argumentsMatch(Invocation actual) {
         List matchers = getMatchers();
-        return getMatcherApplicationStrategyFor(actual, matchers).forEachMatcherAndArgument( matchesTypeSafe());
+        return getMatcherApplicationStrategyFor(actual, matchers)
+                .forEachMatcherAndArgument(matchesTypeSafe());
     }
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
new file mode 100644
index 0000000000..111b588ccf
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+
+public class InvocationsFinder {
+
+    private InvocationsFinder() {}
+
+    public static List<Invocation> findInvocations(
+            List<Invocation> invocations, MatchableInvocation wanted) {
+        return invocations.stream().filter(wanted::matches).collect(Collectors.toList());
+    }
+
+    public static List<Invocation> findAllMatchingUnverifiedChunks(
+            List<Invocation> invocations,
+            MatchableInvocation wanted,
+            InOrderContext orderingContext) {
+        List<Invocation> unverified = removeVerifiedInOrder(invocations, orderingContext);
+        return unverified.stream().filter(wanted::matches).collect(Collectors.toList());
+    }
+
+    /**
+     * some examples how it works:
+     *
+     * Given invocations sequence:
+     * 1,1,2,1
+     *
+     * if wanted is 1 and mode is times(2) then returns
+     * 1,1
+     *
+     * if wanted is 1 and mode is atLeast() then returns
+     * 1,1,1
+     *
+     * if wanted is 1 and mode is times(x), where x != 2 then returns
+     * 1,1,1
+     */
+    public static List<Invocation> findMatchingChunk(
+            List<Invocation> invocations,
+            MatchableInvocation wanted,
+            int wantedCount,
+            InOrderContext context) {
+        List<Invocation> unverified = removeVerifiedInOrder(invocations, context);
+        List<Invocation> firstChunk = getFirstMatchingChunk(wanted, unverified);
+
+        if (wantedCount != firstChunk.size()) {
+            return findAllMatchingUnverifiedChunks(invocations, wanted, context);
+        } else {
+            return firstChunk;
+        }
+    }
+
+    private static List<Invocation> getFirstMatchingChunk(
+            MatchableInvocation wanted, List<Invocation> unverified) {
+        List<Invocation> firstChunk = new LinkedList<>();
+        for (Invocation invocation : unverified) {
+            if (wanted.matches(invocation)) {
+                firstChunk.add(invocation);
+            } else if (!firstChunk.isEmpty()) {
+                break;
+            }
+        }
+        return firstChunk;
+    }
+
+    public static Invocation findFirstMatchingUnverifiedInvocation(
+            List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context) {
+        for (Invocation invocation : removeVerifiedInOrder(invocations, context)) {
+            if (wanted.matches(invocation)) {
+                return invocation;
+            }
+        }
+        return null;
+    }
+
+    public static Invocation findSimilarInvocation(
+            List<Invocation> invocations, MatchableInvocation wanted) {
+        Invocation firstSimilar = null;
+        for (Invocation invocation : invocations) {
+            if (!wanted.hasSimilarMethod(invocation)) {
+                continue;
+            }
+            if (firstSimilar == null) {
+                firstSimilar = invocation;
+            }
+            if (wanted.hasSameMethod(invocation)) {
+                return invocation;
+            }
+        }
+
+        return firstSimilar;
+    }
+
+    public static Invocation findFirstUnverified(List<Invocation> invocations) {
+        return findFirstUnverified(invocations, null);
+    }
+
+    static Invocation findFirstUnverified(List<Invocation> invocations, Object mock) {
+        for (Invocation i : invocations) {
+            boolean mockIsValid = mock == null || mock == i.getMock();
+            if (!i.isVerified() && mockIsValid) {
+                return i;
+            }
+        }
+        return null;
+    }
+
+    public static Location getLastLocation(List<Invocation> invocations) {
+        if (invocations.isEmpty()) {
+            return null;
+        } else {
+            Invocation last = invocations.get(invocations.size() - 1);
+            return last.getLocation();
+        }
+    }
+
+    public static Invocation findPreviousVerifiedInOrder(
+            List<Invocation> invocations, InOrderContext context) {
+        List<Invocation> verifiedOnly =
+                invocations.stream().filter(context::isVerified).collect(Collectors.toList());
+
+        if (verifiedOnly.isEmpty()) {
+            return null;
+        } else {
+            return verifiedOnly.get(verifiedOnly.size() - 1);
+        }
+    }
+
+    private static List<Invocation> removeVerifiedInOrder(
+            List<Invocation> invocations, InOrderContext orderingContext) {
+        List<Invocation> unverified = new LinkedList<>();
+        for (Invocation i : invocations) {
+            if (orderingContext.isVerified(i)) {
+                unverified.clear();
+            } else {
+                unverified.add(i);
+            }
+        }
+        return unverified;
+    }
+
+    public static List<Location> getAllLocations(List<Invocation> invocations) {
+        List<Location> locations = new LinkedList<>();
+        for (Invocation invocation : invocations) {
+            locations.add(invocation.getLocation());
+        }
+        return locations;
+    }
+
+    /**
+     * i3 is unverified here:
+     *
+     * i1, i2, i3
+     *     v
+     *
+     * all good here:
+     *
+     * i1, i2, i3
+     *     v   v
+     *
+     * @param context
+     * @param orderedInvocations
+     */
+    public static Invocation findFirstUnverifiedInOrder(
+            InOrderContext context, List<Invocation> orderedInvocations) {
+        Invocation candidate = null;
+        for (Invocation i : orderedInvocations) {
+            if (!context.isVerified(i)) {
+                candidate = candidate != null ? candidate : i;
+            } else {
+                candidate = null;
+            }
+        }
+        return candidate;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java b/mockito-core/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
new file mode 100644
index 0000000000..8b50da635d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import java.util.List;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.CapturingMatcher;
+import org.mockito.invocation.Invocation;
+
+public class MatcherApplicationStrategy {
+
+    private final Invocation invocation;
+    private final List<? extends ArgumentMatcher<?>> matchers;
+
+    private MatcherApplicationStrategy(
+            Invocation invocation, List<? extends ArgumentMatcher<?>> matchers) {
+        this.invocation = invocation;
+        this.matchers = matchers;
+    }
+
+    /**
+     * Returns the {@link MatcherApplicationStrategy} that must be used to capture the
+     * arguments of the given <b>invocation</b> using the given <b>matchers</b>.
+     *
+     * @param invocation
+     *            that contain the arguments to capture
+     * @param matchers
+     *            that will be used to capture the arguments of the invocation,
+     *            the passed {@link List} is not required to contain a
+     *            {@link CapturingMatcher}
+     * @return never <code>null</code>
+     */
+    public static MatcherApplicationStrategy getMatcherApplicationStrategyFor(
+            Invocation invocation, List<? extends ArgumentMatcher<?>> matchers) {
+        return new MatcherApplicationStrategy(invocation, matchers);
+    }
+
+    /**
+     * Applies the given {@link ArgumentMatcherAction} to all arguments and
+     * corresponding matchers
+     *
+     * @param action
+     *            must not be <code>null</code>
+     * @return
+     *         <ul>
+     *         <li><code>true</code> if the given <b>action</b> returned
+     *         <code>true</code> for all arguments and matchers passed to it.
+     *         <li><code>false</code> if the given <b>action</b> returned
+     *         <code>false</code> for one of the passed arguments and matchers
+     *         <li><code>false</code> if the given matchers don't fit to the given invocation
+     *         because too many or to few matchers are available.
+     *         </ul>
+     */
+    public boolean forEachMatcherAndArgument(ArgumentMatcherAction action) {
+        final boolean maybeVararg =
+                invocation.getMethod().isVarArgs()
+                        && invocation.getRawArguments().length == matchers.size();
+
+        if (maybeVararg) {
+            final Class<?> matcherType = lastMatcherType();
+            final Class<?> paramType = lastParameterType();
+            if (paramType.isAssignableFrom(matcherType)) {
+                return argsMatch(invocation.getRawArguments(), matchers, action);
+            }
+        }
+
+        if (invocation.getArguments().length == matchers.size()) {
+            return argsMatch(invocation.getArguments(), matchers, action);
+        }
+
+        return false;
+    }
+
+    private boolean argsMatch(
+            Object[] arguments,
+            List<? extends ArgumentMatcher<?>> matchers,
+            ArgumentMatcherAction action) {
+        for (int i = 0; i < arguments.length; i++) {
+            ArgumentMatcher<?> matcher = matchers.get(i);
+            Object argument = arguments[i];
+
+            if (!action.apply(matcher, argument)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private Class<?> lastMatcherType() {
+        return matchers.get(matchers.size() - 1).type();
+    }
+
+    private Class<?> lastParameterType() {
+        final Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
+        return parameterTypes[parameterTypes.length - 1];
+    }
+}
diff --git a/src/main/java/org/mockito/internal/invocation/MatchersBinder.java b/mockito-core/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
similarity index 87%
rename from src/main/java/org/mockito/internal/invocation/MatchersBinder.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
index 68c2caf2fb..dd3f2392b1 100644
--- a/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.internal.invocation;
 
-
 import static org.mockito.internal.exceptions.Reporter.invalidUseOfMatchers;
 
 import java.io.Serializable;
@@ -19,11 +18,12 @@
 @SuppressWarnings("unchecked")
 public class MatchersBinder implements Serializable {
 
-    public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
+    public InvocationMatcher bindMatchers(
+            ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
         List<LocalizedMatcher> lastMatchers = argumentMatcherStorage.pullLocalizedMatchers();
         validateMatchers(invocation, lastMatchers);
 
-        List<ArgumentMatcher> matchers = new LinkedList<ArgumentMatcher>();
+        List<ArgumentMatcher> matchers = new LinkedList<>();
         for (LocalizedMatcher m : lastMatchers) {
             matchers.add(m.getMatcher());
         }
diff --git a/src/main/java/org/mockito/internal/invocation/MockitoMethod.java b/mockito-core/src/main/java/org/mockito/internal/invocation/MockitoMethod.java
similarity index 100%
rename from src/main/java/org/mockito/internal/invocation/MockitoMethod.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/MockitoMethod.java
diff --git a/src/main/java/org/mockito/internal/invocation/RealMethod.java b/mockito-core/src/main/java/org/mockito/internal/invocation/RealMethod.java
similarity index 85%
rename from src/main/java/org/mockito/internal/invocation/RealMethod.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/RealMethod.java
index a7b5a150e7..8cb8b721a0 100644
--- a/src/main/java/org/mockito/internal/invocation/RealMethod.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/RealMethod.java
@@ -18,7 +18,6 @@
 public interface RealMethod extends Serializable {
 
     enum IsIllegal implements RealMethod {
-
         INSTANCE;
 
         @Override
@@ -34,12 +33,13 @@ public Object invoke() {
 
     class FromCallable extends FromBehavior implements RealMethod {
         public FromCallable(final Callable<?> callable) {
-            super(new InvocationFactory.RealMethodBehavior() {
-                @Override
-                public Object call() throws Throwable {
-                    return callable.call();
-                }
-            });
+            super(
+                    new InvocationFactory.RealMethodBehavior() {
+                        @Override
+                        public Object call() throws Throwable {
+                            return callable.call();
+                        }
+                    });
         }
     }
 
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/SerializableMethod.java b/mockito-core/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
new file mode 100644
index 0000000000..f007371486
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.SuspendMethod;
+
+public class SerializableMethod implements Serializable, MockitoMethod {
+
+    private static final long serialVersionUID = 6005610965006048445L;
+
+    private final Class<?> declaringClass;
+    private final String methodName;
+    private final Class<?>[] parameterTypes;
+    private final Class<?> returnType;
+    private final Class<?>[] exceptionTypes;
+    private final boolean isVarArgs;
+    private final boolean isAbstract;
+
+    private transient volatile Method method;
+
+    public SerializableMethod(Method method) {
+        this.method = method;
+        declaringClass = method.getDeclaringClass();
+        methodName = method.getName();
+        parameterTypes = SuspendMethod.trimSuspendParameterTypes(method.getParameterTypes());
+        returnType = method.getReturnType();
+        exceptionTypes = method.getExceptionTypes();
+        isVarArgs = method.isVarArgs();
+        isAbstract = (method.getModifiers() & Modifier.ABSTRACT) != 0;
+    }
+
+    @Override
+    public String getName() {
+        return methodName;
+    }
+
+    @Override
+    public Class<?> getReturnType() {
+        return returnType;
+    }
+
+    @Override
+    public Class<?>[] getParameterTypes() {
+        return parameterTypes;
+    }
+
+    @Override
+    public Class<?>[] getExceptionTypes() {
+        return exceptionTypes;
+    }
+
+    @Override
+    public boolean isVarArgs() {
+        return isVarArgs;
+    }
+
+    @Override
+    public boolean isAbstract() {
+        return isAbstract;
+    }
+
+    @Override
+    public Method getJavaMethod() {
+        if (method != null) {
+            return method;
+        }
+        try {
+            method = declaringClass.getDeclaredMethod(methodName, parameterTypes);
+            return method;
+        } catch (SecurityException e) {
+            String message =
+                    String.format(
+                            "The method %1$s.%2$s is probably private or protected and cannot be mocked.\n"
+                                    + "Please report this as a defect with an example of how to reproduce it.",
+                            declaringClass, methodName);
+            throw new MockitoException(message, e);
+        } catch (NoSuchMethodException e) {
+            String message =
+                    String.format(
+                            "The method %1$s.%2$s does not exists and you should not get to this point.\n"
+                                    + "Please report this as a defect with an example of how to reproduce it.",
+                            declaringClass, methodName);
+            throw new MockitoException(message, e);
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return 1;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        SerializableMethod other = (SerializableMethod) obj;
+        if (declaringClass == null) {
+            if (other.declaringClass != null) {
+                return false;
+            }
+        } else if (!declaringClass.equals(other.declaringClass)) {
+            return false;
+        }
+        if (methodName == null) {
+            if (other.methodName != null) {
+                return false;
+            }
+        } else if (!methodName.equals(other.methodName)) {
+            return false;
+        }
+        if (!Arrays.equals(parameterTypes, other.parameterTypes)) {
+            return false;
+        }
+        if (returnType == null) {
+            if (other.returnType != null) {
+                return false;
+            }
+        } else if (!returnType.equals(other.returnType)) {
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java b/mockito-core/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
similarity index 98%
rename from src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
index 6508971d76..c2720d3594 100644
--- a/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
@@ -18,6 +18,7 @@ public StubInfoImpl(DescribedInvocation stubbedAt) {
         this.stubbedAt = stubbedAt;
     }
 
+    @Override
     public Location stubbedAt() {
         return stubbedAt.getLocation();
     }
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java b/mockito-core/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
new file mode 100644
index 0000000000..8f8af6dbdb
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import org.mockito.ArgumentMatcher;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class TypeSafeMatching implements ArgumentMatcherAction {
+
+    private static final ArgumentMatcherAction TYPE_SAFE_MATCHING_ACTION = new TypeSafeMatching();
+
+    /**
+     * This cache is in theory unbounded. However, its max size is bounded by the number of types of argument matchers
+     * that are both in the system and being used, which is expected to bound the cache's size to a low number
+     * (<200) in all but the most contrived cases, and form a small percentage of the overall memory usage of those
+     * classes.
+     */
+    private static final ConcurrentMap<Class<?>, Class<?>> argumentTypeCache =
+            new ConcurrentHashMap<>();
+
+    private TypeSafeMatching() {}
+
+    public static ArgumentMatcherAction matchesTypeSafe() {
+        return TYPE_SAFE_MATCHING_ACTION;
+    }
+
+    @Override
+    public boolean apply(ArgumentMatcher matcher, Object argument) {
+        return isCompatible(matcher, argument) && matcher.matches(argument);
+    }
+
+    /**
+     * Returns <code>true</code> if the given <b>argument</b> can be passed to
+     * the given <code>argumentMatcher</code> without causing a
+     * {@link ClassCastException}.
+     */
+    private static boolean isCompatible(ArgumentMatcher<?> argumentMatcher, Object argument) {
+        if (argument == null) {
+            return true;
+        }
+
+        Class<?> expectedArgumentType = getArgumentType(argumentMatcher);
+
+        return expectedArgumentType.isInstance(argument);
+    }
+
+    private static Class<?> getArgumentType(ArgumentMatcher<?> matcher) {
+        Class<?> argumentMatcherType = matcher.getClass();
+        Class<?> cached = argumentTypeCache.get(argumentMatcherType);
+        // Avoids a lambda allocation on invocations >=2 for worse perf on invocation 1.
+        if (cached != null) {
+            return cached;
+        } else {
+            return argumentTypeCache.computeIfAbsent(
+                    argumentMatcherType, unusedKey -> getArgumentTypeUncached(matcher));
+        }
+    }
+
+    /**
+     * Returns the type of {@link ArgumentMatcher#matches(Object)} of the given
+     * {@link ArgumentMatcher} implementation.
+     */
+    private static Class<?> getArgumentTypeUncached(ArgumentMatcher<?> argumentMatcher) {
+        Method[] methods = argumentMatcher.getClass().getMethods();
+
+        for (Method method : methods) {
+            if (isMatchesMethod(method)) {
+                return method.getParameterTypes()[0];
+            }
+        }
+        throw new NoSuchMethodError(
+                "Method 'matches(T)' not found in ArgumentMatcher: "
+                        + argumentMatcher
+                        + " !\r\n Please file a bug with this stack trace at: https://github.com/mockito/mockito/issues/new ");
+    }
+
+    /**
+     * Returns <code>true</code> if the given method is
+     * {@link ArgumentMatcher#matches(Object)}
+     */
+    private static boolean isMatchesMethod(Method method) {
+        if (method.getParameterTypes().length != 1) {
+            return false;
+        }
+        if (method.isBridge()) {
+            return false;
+        }
+        return "matches".equals(method.getName());
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java b/mockito-core/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
new file mode 100644
index 0000000000..4d1e7679c9
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation.finder;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import org.mockito.internal.invocation.InvocationComparator;
+import org.mockito.internal.stubbing.StubbingComparator;
+import org.mockito.internal.util.DefaultMockingDetails;
+import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
+
+public class AllInvocationsFinder {
+
+    private AllInvocationsFinder() {}
+
+    /**
+     * gets all invocations from mocks. Invocations are ordered earlier first.
+     *
+     * @param mocks mocks
+     * @return invocations
+     */
+    public static List<Invocation> find(Iterable<?> mocks) {
+        Set<Invocation> invocationsInOrder = new TreeSet<>(new InvocationComparator());
+        for (Object mock : mocks) {
+            Collection<Invocation> fromSingleMock =
+                    new DefaultMockingDetails(mock).getInvocations();
+            invocationsInOrder.addAll(fromSingleMock);
+        }
+
+        return new LinkedList<>(invocationsInOrder);
+    }
+
+    /**
+     * Gets all stubbings from mocks. Invocations are ordered earlier first.
+     *
+     * @param mocks mocks
+     * @return stubbings
+     */
+    public static Set<Stubbing> findStubbings(Iterable<?> mocks) {
+        Set<Stubbing> stubbings = new TreeSet<>(new StubbingComparator());
+        for (Object mock : mocks) {
+            // TODO due to the limited scope of static mocks they cannot be processed
+            //  it would rather be required to trigger this stubbing control upon releasing
+            //  the static mock.
+            if (mock instanceof Class<?>) {
+                continue;
+            }
+            Collection<? extends Stubbing> fromSingleMock =
+                    new DefaultMockingDetails(mock).getStubbings();
+            stubbings.addAll(fromSingleMock);
+        }
+
+        return stubbings;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java b/mockito-core/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
new file mode 100644
index 0000000000..9f60910af0
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation.finder;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.mockito.invocation.Invocation;
+
+/**
+ * Author: Szczepan Faber, created at: 4/3/11
+ */
+public class VerifiableInvocationsFinder {
+
+    private VerifiableInvocationsFinder() {}
+
+    public static List<Invocation> find(List<?> mocks) {
+        return AllInvocationsFinder.find(mocks).stream()
+                .filter(invocation -> !invocation.isIgnoredForVerification())
+                .collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java b/mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
similarity index 100%
rename from src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java b/mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
similarity index 100%
rename from src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java b/mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
new file mode 100644
index 0000000000..ddf7f6814b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation.mockref;
+
+import java.io.ObjectStreamException;
+import java.lang.ref.WeakReference;
+
+/**
+ * A weak reference that is converted into a strong reference when serialized.
+ * See {@link MockReference}.
+ */
+public class MockWeakReference<T> implements MockReference<T> {
+
+    private final WeakReference<T> ref;
+
+    public MockWeakReference(T t) {
+        this.ref = new WeakReference<T>(t);
+    }
+
+    private Object writeReplace() throws ObjectStreamException {
+        return new MockStrongReference<T>(get(), true);
+    }
+
+    @Override
+    public T get() {
+        T ref = this.ref.get();
+
+        if (ref == null) {
+            throw new IllegalStateException(
+                    "The mock object was garbage collected. "
+                            + "This should not happen in normal circumstances when using public API. "
+                            + "Typically, the test class keeps strong reference to the mock object "
+                            + "and it prevents getting the mock collected. Mockito internally needs "
+                            + "to keep weak references to mock objects to avoid memory leaks for "
+                            + "certain types of MockMaker implementations. If you see this exception "
+                            + "using Mockito public API, please file a bug. For more information see "
+                            + "issue #1313.");
+        }
+
+        return ref;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/invocation/package-info.java b/mockito-core/src/main/java/org/mockito/internal/invocation/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/invocation/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/invocation/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java b/mockito-core/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
new file mode 100644
index 0000000000..9c4ec4442c
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import org.mockito.internal.invocation.finder.AllInvocationsFinder;
+import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
+
+/**
+ * For given mocks, finds stubbing arg mismatches
+ */
+class ArgMismatchFinder {
+
+    StubbingArgMismatches getStubbingArgMismatches(Iterable<?> mocks) {
+        StubbingArgMismatches mismatches = new StubbingArgMismatches();
+        for (Invocation i : AllInvocationsFinder.find(mocks)) {
+            if (i.stubInfo() != null) {
+                continue;
+            }
+            for (Stubbing stubbing : AllInvocationsFinder.findStubbings(mocks)) {
+                // method name & mock matches
+                if (!stubbing.wasUsed()
+                        && stubbing.getInvocation().getMock() == i.getMock()
+                        && stubbing.getInvocation()
+                                .getMethod()
+                                .getName()
+                                .equals(i.getMethod().getName())) {
+                    mismatches.add(i, stubbing.getInvocation());
+                }
+            }
+        }
+        return mismatches;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java b/mockito-core/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
new file mode 100644
index 0000000000..48ba775100
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import static org.mockito.internal.stubbing.StrictnessSelector.determineStrictness;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.stubbing.UnusedStubbingReporting;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.StubbingLookupEvent;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Stubbing;
+
+/**
+ * Default implementation of stubbing lookup listener.
+ * Fails early if stub called with unexpected arguments, but only if current strictness is set to STRICT_STUBS.
+ */
+class DefaultStubbingLookupListener implements StubbingLookupListener, Serializable {
+
+    private static final long serialVersionUID = -6789800638070123629L;
+
+    private Strictness currentStrictness;
+    private boolean mismatchesReported;
+
+    DefaultStubbingLookupListener(Strictness strictness) {
+        this.currentStrictness = strictness;
+    }
+
+    @Override
+    public void onStubbingLookup(StubbingLookupEvent event) {
+        Strictness actualStrictness =
+                determineStrictness(
+                        event.getStubbingFound(), event.getMockSettings(), currentStrictness);
+
+        if (actualStrictness != Strictness.STRICT_STUBS) {
+            return;
+        }
+
+        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(event.getInvocation(), event.getAllStubbings());
+            if (!argMismatchStubbings.isEmpty()) {
+                mismatchesReported = true;
+                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)
+            event.getInvocation().markVerified();
+        }
+    }
+
+    private static List<Invocation> potentialArgMismatches(
+            Invocation invocation, Collection<Stubbing> stubbings) {
+        List<Invocation> matchingStubbings = new LinkedList<>();
+        for (Stubbing s : stubbings) {
+            if (UnusedStubbingReporting.shouldBeReported(s)
+                    && Objects.equals(
+                            s.getInvocation().getMethod().getName(),
+                            invocation.getMethod().getName())
+                    // If stubbing and invocation are in the same source file we assume they are in
+                    // the test code,
+                    // and we don't flag it as mismatch:
+                    && !Objects.equals(
+                            s.getInvocation().getLocation().getSourceFile(),
+                            invocation.getLocation().getSourceFile())) {
+                matchingStubbings.add(s.getInvocation());
+            }
+        }
+        return matchingStubbings;
+    }
+
+    /**
+     * Enables resetting the strictness to desired level
+     */
+    void setCurrentStrictness(Strictness currentStrictness) {
+        this.currentStrictness = currentStrictness;
+    }
+
+    /**
+     * Indicates that stubbing argument mismatch was reported
+     */
+    boolean isMismatchesReported() {
+        return mismatchesReported;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java b/mockito-core/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
similarity index 85%
rename from src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
index c3b348bb5d..269ab9cc27 100644
--- a/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
@@ -9,7 +9,8 @@ public class DefaultTestFinishedEvent implements TestFinishedEvent {
     private final String testMethodName;
     private final Throwable testFailure;
 
-    public DefaultTestFinishedEvent(Object testClassInstance, String testMethodName, Throwable testFailure) {
+    public DefaultTestFinishedEvent(
+            Object testClassInstance, String testMethodName, Throwable testFailure) {
         this.testClassInstance = testClassInstance;
         this.testMethodName = testMethodName;
         this.testFailure = testFailure;
diff --git a/src/main/java/org/mockito/internal/junit/ExceptionFactory.java b/mockito-core/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
similarity index 87%
rename from src/main/java/org/mockito/internal/junit/ExceptionFactory.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
index 171024cb7a..a1331d2602 100644
--- a/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
@@ -8,14 +8,13 @@
 
 public class ExceptionFactory {
 
-    private ExceptionFactory() {
-    }
+    private ExceptionFactory() {}
 
     private static interface ExceptionFactoryImpl {
         AssertionError create(String message, String wanted, String actual);
     }
 
-    private final static ExceptionFactoryImpl factory;
+    private static final ExceptionFactoryImpl factory;
 
     static {
         ExceptionFactoryImpl theFactory = null;
@@ -37,12 +36,13 @@ private static interface ExceptionFactoryImpl {
      * Returns an AssertionError that describes the fact that the arguments of an invocation are different.
      * If {@link org.opentest4j.AssertionFailedError} is on the class path (used by JUnit 5 and others),
      * it returns a class that extends it. Otherwise, if {@link junit.framework.ComparisonFailure} is on the
-     * class path (shipped with JUnit 3 and 4), it will return a class that extends that. This provides
+     * class path (shipped with JUnit 4), it will return a class that extends that. This provides
      * better IDE support as the comparison result can be opened in a visual diff. If neither are available,
      * it returns an instance of
      * {@link org.mockito.exceptions.verification.ArgumentsAreDifferent}.
      */
-    public static AssertionError createArgumentsAreDifferentException(String message, String wanted, String actual) {
+    public static AssertionError createArgumentsAreDifferentException(
+            String message, String wanted, String actual) {
         return factory.create(message, wanted, actual);
     }
 }
diff --git a/src/main/java/org/mockito/internal/junit/JUnitRule.java b/mockito-core/src/main/java/org/mockito/internal/junit/JUnitRule.java
similarity index 77%
rename from src/main/java/org/mockito/internal/junit/JUnitRule.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/JUnitRule.java
index 2ab4be2b1a..0439f98e9e 100644
--- a/src/main/java/org/mockito/internal/junit/JUnitRule.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/JUnitRule.java
@@ -21,14 +21,18 @@ public JUnitRule(MockitoLogger logger, Strictness strictness) {
     }
 
     @Override
-    public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
-        return sessionStore.createStatement(base, target.getClass().getSimpleName() + "." + method.getName(), target);
+    public Statement apply(
+            final Statement base, final FrameworkMethod method, final Object target) {
+        return sessionStore.createStatement(
+                base, target.getClass().getSimpleName() + "." + method.getName(), target);
     }
 
+    @Override
     public MockitoRule silent() {
         return strictness(Strictness.LENIENT);
     }
 
+    @Override
     public MockitoRule strictness(Strictness strictness) {
         sessionStore.setStrictness(strictness);
         return this;
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java b/mockito-core/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java
new file mode 100644
index 0000000000..5aa155797e
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import org.junit.runners.model.Statement;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.MockitoSession;
+import org.mockito.internal.session.MockitoSessionLoggerAdapter;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+
+class JUnitSessionStore {
+
+    private final MockitoLogger logger;
+    private MockitoSession session;
+    protected Strictness strictness;
+
+    JUnitSessionStore(MockitoLogger logger, Strictness strictness) {
+        this.logger = logger;
+        this.strictness = strictness;
+    }
+
+    Statement createStatement(final Statement base, final String methodName, final Object target) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                AutoCloseable closeable;
+                if (session == null) {
+                    session =
+                            Mockito.mockitoSession()
+                                    .name(methodName)
+                                    .strictness(strictness)
+                                    .logger(new MockitoSessionLoggerAdapter(logger))
+                                    .initMocks(target)
+                                    .startMocking();
+                    closeable = null;
+                } else {
+                    closeable = MockitoAnnotations.openMocks(target);
+                }
+                Throwable testFailure = evaluateSafely(base);
+                session.finishMocking(testFailure);
+                if (closeable != null) {
+                    closeable.close();
+                }
+                if (testFailure != null) {
+                    throw testFailure;
+                }
+            }
+
+            private Throwable evaluateSafely(Statement base) {
+                try {
+                    base.evaluate();
+                    return null;
+                } catch (Throwable throwable) {
+                    return throwable;
+                }
+            }
+        };
+    }
+
+    void setStrictness(Strictness strictness) {
+        this.strictness = strictness;
+        // session is null when this method is called during initialization of
+        // the @Rule field of the test class
+        if (session != null) {
+            session.setStrictness(strictness);
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/JUnitTestRule.java b/mockito-core/src/main/java/org/mockito/internal/junit/JUnitTestRule.java
similarity index 97%
rename from src/main/java/org/mockito/internal/junit/JUnitTestRule.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/JUnitTestRule.java
index 3caa82e87b..3cbf2c607b 100644
--- a/src/main/java/org/mockito/internal/junit/JUnitTestRule.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/JUnitTestRule.java
@@ -25,10 +25,12 @@ public Statement apply(Statement base, Description description) {
         return sessionStore.createStatement(base, description.getDisplayName(), this.testInstance);
     }
 
+    @Override
     public MockitoTestRule silent() {
         return strictness(Strictness.LENIENT);
     }
 
+    @Override
     public MockitoTestRule strictness(Strictness strictness) {
         sessionStore.setStrictness(strictness);
         return this;
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java b/mockito-core/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
new file mode 100644
index 0000000000..ec877b508d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockitoLogger;
+
+/**
+ * Reports stubbing argument mismatches to the supplied logger
+ */
+public class MismatchReportingTestListener implements MockitoTestListener {
+
+    private final MockitoLogger logger;
+    private List<Object> mocks = new LinkedList<>();
+
+    public MismatchReportingTestListener(MockitoLogger logger) {
+        this.logger = logger;
+    }
+
+    @Override
+    public void testFinished(TestFinishedEvent event) {
+        Collection<Object> createdMocks = mocks;
+        // At this point, we don't need the mocks any more and we can mark all collected mocks for
+        // gc
+        // TODO make it better, it's easy to forget to clean up mocks and we still create new
+        // instance of list that nobody will read, it's also duplicated
+        mocks = new LinkedList<>();
+
+        if (event.getFailure() != null) {
+            // print unused stubbings only when test succeeds to avoid reporting multiple problems
+            // and confusing users
+            new ArgMismatchFinder()
+                    .getStubbingArgMismatches(createdMocks)
+                    .format(event.getTestName(), logger);
+        }
+    }
+
+    @Override
+    public void onMockCreated(Object mock, MockCreationSettings settings) {
+        this.mocks.add(mock);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/MockitoTestListener.java b/mockito-core/src/main/java/org/mockito/internal/junit/MockitoTestListener.java
similarity index 100%
rename from src/main/java/org/mockito/internal/junit/MockitoTestListener.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/MockitoTestListener.java
diff --git a/src/main/java/org/mockito/internal/junit/NoOpTestListener.java b/mockito-core/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
similarity index 93%
rename from src/main/java/org/mockito/internal/junit/NoOpTestListener.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
index f6eea7eef9..77c7d4ecd2 100644
--- a/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
@@ -8,7 +8,9 @@
 
 public class NoOpTestListener implements MockitoTestListener {
 
+    @Override
     public void testFinished(TestFinishedEvent event) {}
 
+    @Override
     public void onMockCreated(Object mock, MockCreationSettings settings) {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java b/mockito-core/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
new file mode 100644
index 0000000000..8d6cc6c73a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.quality.Strictness;
+
+/**
+ * Fails early when mismatched arguments used for stubbing
+ */
+public class StrictStubsRunnerTestListener implements MockitoTestListener {
+
+    private final DefaultStubbingLookupListener stubbingLookupListener =
+            new DefaultStubbingLookupListener(Strictness.STRICT_STUBS);
+
+    @Override
+    public void testFinished(TestFinishedEvent event) {}
+
+    @Override
+    public void onMockCreated(Object mock, MockCreationSettings settings) {
+        // It is not ideal that we modify the state of MockCreationSettings object
+        // MockCreationSettings is intended to be an immutable view of the creation settings
+        // However, we our previous listeners work this way and it hasn't backfired.
+        // Since it is simple and pragmatic, we'll keep it for now.
+        settings.getStubbingLookupListeners().add(stubbingLookupListener);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java b/mockito-core/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
similarity index 82%
rename from src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
index 1c7b00ad32..3fb3badb99 100644
--- a/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
@@ -17,14 +17,12 @@
  */
 class StubbingArgMismatches {
 
-    final Map<Invocation, Set<Invocation>> mismatches = new LinkedHashMap<Invocation, Set<Invocation>>();
+    final Map<Invocation, Set<Invocation>> mismatches = new LinkedHashMap<>();
 
     public void add(Invocation invocation, Invocation stubbing) {
-        Set<Invocation> matchingInvocations = mismatches.get(stubbing);
-        if (matchingInvocations == null) {
-            matchingInvocations = new LinkedHashSet<Invocation>();
-            mismatches.put(stubbing, matchingInvocations);
-        }
+        Set<Invocation> matchingInvocations =
+                mismatches.computeIfAbsent(
+                        stubbing, (Invocation k) -> new LinkedHashSet<Invocation>());
         matchingInvocations.add(invocation);
     }
 
@@ -49,6 +47,7 @@ public int size() {
         return mismatches.size();
     }
 
+    @Override
     public String toString() {
         return "" + mismatches;
     }
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/StubbingHint.java b/mockito-core/src/main/java/org/mockito/internal/junit/StubbingHint.java
new file mode 100644
index 0000000000..27104258f5
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/StubbingHint.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+/**
+ * Stubbing hint emitted to the user
+ */
+class StubbingHint {
+
+    private final StringBuilder hint;
+
+    StubbingHint(String testName) {
+        hint =
+                new StringBuilder("[MockitoHint] ")
+                        .append(testName)
+                        .append(" (see javadoc for MockitoHint):");
+    }
+
+    void appendLine(Object... elements) {
+        hint.append("\n[MockitoHint] ");
+        for (Object e : elements) {
+            hint.append(e);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return hint + "\n";
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java b/mockito-core/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
similarity index 99%
rename from src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
index 43b373a56f..a2c10cfb73 100644
--- a/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
@@ -9,5 +9,4 @@ public interface TestFinishedEvent {
     Throwable getFailure();
 
     String getTestName();
-
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/UniversalTestListener.java b/mockito-core/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
new file mode 100644
index 0000000000..72e3c0912d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.listeners.AutoCleanableListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+
+/**
+ * Universal test listener that behaves accordingly to current setting of strictness.
+ * Will come handy when we offer tweaking strictness at the method level with annotation.
+ * Should be relatively easy to improve and offer tweaking strictness per mock.
+ */
+public class UniversalTestListener implements MockitoTestListener, AutoCleanableListener {
+
+    private Strictness currentStrictness;
+    private final MockitoLogger logger;
+
+    private IdentityHashMap mocks = new IdentityHashMap<Object, MockCreationSettings>();
+    private final DefaultStubbingLookupListener stubbingLookupListener;
+    private boolean listenerDirty;
+
+    public UniversalTestListener(Strictness initialStrictness, MockitoLogger logger) {
+        this.currentStrictness = initialStrictness;
+        this.logger = logger;
+
+        // creating single stubbing lookup listener per junit rule instance / test method
+        // this way, when strictness is updated in the middle of the test it will affect the
+        // behavior of the stubbing listener
+        this.stubbingLookupListener = new DefaultStubbingLookupListener(currentStrictness);
+    }
+
+    @Override
+    public void testFinished(TestFinishedEvent event) {
+        Collection<Object> createdMocks = mocks.keySet();
+        // At this point, we don't need the mocks any more and we can mark all collected mocks for
+        // gc
+        // TODO make it better, it's easy to forget to clean up mocks and we still create new
+        // instance of list that nobody will read, it's also duplicated
+        // TODO clean up all other state, null out stubbingLookupListener
+        mocks = new IdentityHashMap<>();
+
+        switch (currentStrictness) {
+            case WARN:
+                emitWarnings(logger, event, createdMocks);
+                break;
+            case STRICT_STUBS:
+                reportUnusedStubs(event, createdMocks);
+                break;
+            case LENIENT:
+                break;
+            default:
+                throw new IllegalStateException("Unknown strictness: " + currentStrictness);
+        }
+    }
+
+    private void reportUnusedStubs(TestFinishedEvent event, Collection<Object> mocks) {
+        // If there is some other failure (or mismatches were detected) don't report another
+        // exception to avoid confusion
+        if (event.getFailure() == null && !stubbingLookupListener.isMismatchesReported()) {
+            UnusedStubbings unused = new UnusedStubbingsFinder().getUnusedStubbings(mocks);
+            unused.reportUnused();
+        }
+    }
+
+    private static void emitWarnings(
+            MockitoLogger logger, TestFinishedEvent event, Collection<Object> mocks) {
+        if (event.getFailure() != null) {
+            // print stubbing mismatches only when there is a test failure
+            // to avoid false negatives. Give hint only when test fails.
+            new ArgMismatchFinder()
+                    .getStubbingArgMismatches(mocks)
+                    .format(event.getTestName(), logger);
+        } else {
+            // print unused stubbings only when test succeeds to avoid reporting multiple problems
+            // and confusing users
+            new UnusedStubbingsFinder()
+                    .getUnusedStubbings(mocks)
+                    .format(event.getTestName(), logger);
+        }
+    }
+
+    @Override
+    public void onMockCreated(Object mock, MockCreationSettings settings) {
+        this.mocks.put(mock, settings);
+
+        // It is not ideal that we modify the state of MockCreationSettings object
+        // MockCreationSettings is intended to be an immutable view of the creation settings
+        // In future, we should start passing MockSettings object to the creation listener
+        // TODO #793 - when completed, we should be able to get rid of the CreationSettings casting
+        // below
+        ((CreationSettings) settings).getStubbingLookupListeners().add(stubbingLookupListener);
+    }
+
+    public void setStrictness(Strictness strictness) {
+        this.currentStrictness = strictness;
+        this.stubbingLookupListener.setCurrentStrictness(strictness);
+    }
+
+    /**
+     * See {@link AutoCleanableListener#isListenerDirty()}
+     */
+    @Override
+    public boolean isListenerDirty() {
+        return listenerDirty;
+    }
+
+    /**
+     * Marks listener as dirty, scheduled for cleanup when the next session starts
+     */
+    public void setListenerDirty() {
+        this.listenerDirty = true;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java b/mockito-core/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
new file mode 100644
index 0000000000..2ba1fb962c
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.MockCreationListener;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Reports unnecessary stubbings
+ */
+public class UnnecessaryStubbingsReporter implements MockCreationListener {
+
+    private final List<Object> mocks = new LinkedList<Object>();
+
+    public void validateUnusedStubs(Class<?> testClass, RunNotifier notifier) {
+        Collection<Invocation> unused =
+                new UnusedStubbingsFinder().getUnusedStubbingsByLocation(mocks);
+        if (unused.isEmpty()) {
+            return; // whoa!!! All stubbings were used!
+        }
+
+        // Oups, there are unused stubbings
+        Description unnecessaryStubbings =
+                Description.createTestDescription(testClass, "unnecessary Mockito stubbings");
+        notifier.fireTestFailure(
+                new Failure(
+                        unnecessaryStubbings,
+                        Reporter.formatUnncessaryStubbingException(testClass, unused)));
+    }
+
+    @Override
+    public void onMockCreated(Object mock, MockCreationSettings settings) {
+        mocks.add(mock);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java b/mockito-core/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
similarity index 95%
rename from src/main/java/org/mockito/internal/junit/UnusedStubbings.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
index 787b3ff901..4c4fbf913b 100644
--- a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
@@ -43,6 +43,7 @@ public int size() {
         return unused.size();
     }
 
+    @Override
     public String toString() {
         return unused.toString();
     }
@@ -52,7 +53,7 @@ void reportUnused() {
             return;
         }
 
-        List<Invocation> invocations = new LinkedList<Invocation>();
+        List<Invocation> invocations = new LinkedList<>();
         for (Stubbing stubbing : unused) {
             invocations.add(stubbing.getInvocation());
         }
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java b/mockito-core/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
new file mode 100644
index 0000000000..e51d2ebd45
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.mockito.internal.invocation.finder.AllInvocationsFinder;
+import org.mockito.internal.stubbing.UnusedStubbingReporting;
+import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
+
+/**
+ * Finds unused stubbings
+ */
+public class UnusedStubbingsFinder {
+
+    /**
+     * 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) {
+        return new UnusedStubbings(
+                AllInvocationsFinder.findStubbings(mocks).stream()
+                        .filter(UnusedStubbingReporting::shouldBeReported)
+                        .collect(Collectors.toList()));
+    }
+
+    /**
+     * Gets unused stubbings per location. This method is less accurate than {@link #getUnusedStubbings(Iterable)}.
+     * It considers that stubbings with the same location (e.g. ClassFile + line number) are the same.
+     * This is not completely accurate because a stubbing declared in a setup or constructor
+     * is created per each test method. Because those are different test methods,
+     * different mocks are created, different 'Invocation' instance is backing the 'Stubbing' instance.
+     * In certain scenarios (detecting unused stubbings by JUnit runner), we need this exact level of accuracy.
+     * Stubbing declared in constructor but realized in % of test methods is considered as 'used' stubbing.
+     * There are high level unit tests that demonstrate this scenario.
+     */
+    public Collection<Invocation> getUnusedStubbingsByLocation(Iterable<Object> mocks) {
+        Set<Stubbing> stubbings = AllInvocationsFinder.findStubbings(mocks);
+
+        // 1st pass, collect all the locations of the stubbings that were used
+        // note that those are _not_ locations where the stubbings was used
+        Set<String> locationsOfUsedStubbings = new HashSet<>();
+        for (Stubbing s : stubbings) {
+            if (!UnusedStubbingReporting.shouldBeReported(s)) {
+                String location = s.getInvocation().getLocation().toString();
+                locationsOfUsedStubbings.add(location);
+            }
+        }
+
+        // 2nd pass, collect unused stubbings by location
+        // If the location matches we assume the stubbing was used in at least one test method
+        // Also, using map to deduplicate reported unused stubbings
+        // if unused stubbing appear in the setup method / constructor we don't want to report it
+        // per each test case
+        Map<String, Invocation> out = new LinkedHashMap<>();
+        for (Stubbing s : stubbings) {
+            String location = s.getInvocation().getLocation().toString();
+            if (!locationsOfUsedStubbings.contains(location)) {
+                out.put(location, s.getInvocation());
+            }
+        }
+
+        return out.values();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java b/mockito-core/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
new file mode 100644
index 0000000000..dcb4d16b2b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.internal.progress.MockingProgressImpl;
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.junit.VerificationCollector;
+import org.mockito.verification.VerificationMode;
+import org.mockito.verification.VerificationStrategy;
+
+/**
+ * Mockito implementation of VerificationCollector.
+ */
+public class VerificationCollectorImpl implements VerificationCollector {
+
+    private StringBuilder builder;
+    private int numberOfFailures;
+
+    public VerificationCollectorImpl() {
+        this.resetBuilder();
+    }
+
+    @Override
+    public Statement apply(final Statement base, final Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                try {
+                    VerificationCollectorImpl.this.assertLazily();
+                    base.evaluate();
+                    VerificationCollectorImpl.this.collectAndReport();
+                } finally {
+                    // If base.evaluate() throws an error, we must explicitly reset the
+                    // VerificationStrategy
+                    // to prevent subsequent tests to be assert lazily
+                    mockingProgress()
+                            .setVerificationStrategy(
+                                    MockingProgressImpl.getDefaultVerificationStrategy());
+                }
+            }
+        };
+    }
+
+    public void collectAndReport() throws MockitoAssertionError {
+        mockingProgress()
+                .setVerificationStrategy(MockingProgressImpl.getDefaultVerificationStrategy());
+
+        if (this.numberOfFailures > 0) {
+            String error = this.builder.toString();
+
+            this.resetBuilder();
+
+            throw new MockitoAssertionError(error);
+        }
+    }
+
+    @Override
+    public VerificationCollector assertLazily() {
+        mockingProgress()
+                .setVerificationStrategy(
+                        new VerificationStrategy() {
+                            @Override
+                            public VerificationMode maybeVerifyLazily(VerificationMode mode) {
+                                return new VerificationWrapper(mode);
+                            }
+                        });
+        return this;
+    }
+
+    private void resetBuilder() {
+        this.builder = new StringBuilder().append("There were multiple verification failures:");
+        this.numberOfFailures = 0;
+    }
+
+    private void append(String message) {
+        this.numberOfFailures++;
+        this.builder
+                .append('\n')
+                .append(this.numberOfFailures)
+                .append(". ")
+                .append(message.trim())
+                .append('\n');
+    }
+
+    private class VerificationWrapper implements VerificationMode {
+
+        private final VerificationMode delegate;
+
+        private VerificationWrapper(VerificationMode delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public void verify(VerificationData data) {
+            try {
+                this.delegate.verify(data);
+            } catch (AssertionError error) {
+                VerificationCollectorImpl.this.append(error.getMessage());
+            }
+        }
+
+        @Override
+        public VerificationMode description(String description) {
+            throw new IllegalStateException("Should not fail in this mode");
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/junit/package-info.java b/mockito-core/src/main/java/org/mockito/internal/junit/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/junit/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/junit/package-info.java
diff --git a/src/main/java/org/mockito/internal/listeners/AutoCleanableListener.java b/mockito-core/src/main/java/org/mockito/internal/listeners/AutoCleanableListener.java
similarity index 100%
rename from src/main/java/org/mockito/internal/listeners/AutoCleanableListener.java
rename to mockito-core/src/main/java/org/mockito/internal/listeners/AutoCleanableListener.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java b/mockito-core/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
new file mode 100644
index 0000000000..5331628906
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.listeners;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.StubbingLookupEvent;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Stubbing;
+
+public final 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 {
+        private final Invocation invocation;
+        private final Stubbing stubbing;
+        private final Collection<Stubbing> allStubbings;
+        private final 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;
+        }
+    }
+
+    private StubbingLookupNotifier() {}
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java b/mockito-core/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
new file mode 100644
index 0000000000..9a5a890604
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.listeners;
+
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.MockingDetails;
+import org.mockito.Mockito;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.matchers.text.ValuePrinter;
+import org.mockito.listeners.VerificationStartedEvent;
+import org.mockito.listeners.VerificationStartedListener;
+import org.mockito.mock.MockCreationSettings;
+
+public final class VerificationStartedNotifier {
+
+    public static Object notifyVerificationStarted(
+            List<VerificationStartedListener> listeners, MockingDetails originalMockingDetails) {
+        if (listeners.isEmpty()) {
+            return originalMockingDetails.getMock();
+        }
+        VerificationStartedEvent event = new Event(originalMockingDetails);
+        for (VerificationStartedListener listener : listeners) {
+            listener.onVerificationStarted(event);
+        }
+        return event.getMock();
+    }
+
+    static class Event implements VerificationStartedEvent {
+        private final MockingDetails originalMockingDetails;
+        private Object mock;
+
+        public Event(MockingDetails originalMockingDetails) {
+            this.originalMockingDetails = originalMockingDetails;
+            this.mock = originalMockingDetails.getMock();
+        }
+
+        @Override
+        public void setMock(Object mock) {
+            if (mock == null) {
+                throw Reporter.methodDoesNotAcceptParameter(
+                        "VerificationStartedEvent.setMock", "null parameter.");
+            }
+            MockingDetails mockingDetails = Mockito.mockingDetails(mock);
+            if (!mockingDetails.isMock()) {
+                throw Reporter.methodDoesNotAcceptParameter(
+                        "VerificationStartedEvent.setMock",
+                        "parameter which is not a Mockito mock.\n"
+                                + "  Received parameter: "
+                                + ValuePrinter.print(mock)
+                                + ".\n ");
+            }
+            MockCreationSettings originalMockSettings =
+                    this.originalMockingDetails.getMockCreationSettings();
+            assertCompatibleTypes(mock, originalMockSettings);
+            this.mock = mock;
+        }
+
+        @Override
+        public Object getMock() {
+            return mock;
+        }
+    }
+
+    static void assertCompatibleTypes(Object mock, MockCreationSettings originalSettings) {
+        Class originalType = originalSettings.getTypeToMock();
+        if (!originalType.isInstance(mock)) {
+            throw Reporter.methodDoesNotAcceptParameter(
+                    "VerificationStartedEvent.setMock",
+                    "parameter which is not the same type as the original mock.\n"
+                            + "  Required type: "
+                            + originalType.getName()
+                            + "\n"
+                            + "  Received parameter: "
+                            + ValuePrinter.print(mock)
+                            + ".\n ");
+        }
+
+        for (Class iface : (Set<Class>) originalSettings.getExtraInterfaces()) {
+            if (!iface.isInstance(mock)) {
+                throw Reporter.methodDoesNotAcceptParameter(
+                        "VerificationStartedEvent.setMock",
+                        "parameter which does not implement all extra interfaces of the original mock.\n"
+                                + "  Required type: "
+                                + originalType.getName()
+                                + "\n"
+                                + "  Required extra interface: "
+                                + iface.getName()
+                                + "\n"
+                                + "  Received parameter: "
+                                + ValuePrinter.print(mock)
+                                + ".\n ");
+            }
+        }
+    }
+
+    private VerificationStartedNotifier() {}
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/And.java b/mockito-core/src/main/java/org/mockito/internal/matchers/And.java
new file mode 100644
index 0000000000..cffed323f1
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/And.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.io.Serializable;
+
+import org.mockito.ArgumentMatcher;
+
+@SuppressWarnings({"unchecked", "serial", "rawtypes"})
+public class And implements ArgumentMatcher<Object>, Serializable {
+    private final ArgumentMatcher m1;
+    private final ArgumentMatcher m2;
+
+    public And(ArgumentMatcher<?> m1, ArgumentMatcher<?> m2) {
+        this.m1 = m1;
+        this.m2 = m2;
+    }
+
+    @Override
+    public boolean matches(Object actual) {
+        return m1.matches(actual) && m2.matches(actual);
+    }
+
+    @Override
+    public Class<?> type() {
+        return m1.type().isAssignableFrom(m2.type())
+                ? m1.type()
+                : m2.type().isAssignableFrom(m1.type()) ? m2.type() : ArgumentMatcher.super.type();
+    }
+
+    @Override
+    public String toString() {
+        return "and(" + m1 + ", " + m2 + ")";
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/Any.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Any.java
new file mode 100644
index 0000000000..2074f81abc
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Any.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.io.Serializable;
+
+import org.mockito.ArgumentMatcher;
+
+public class Any implements ArgumentMatcher<Object>, Serializable {
+
+    public static final Any ANY = new Any();
+
+    @Override
+    public boolean matches(Object actual) {
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "<any>";
+    }
+
+    @Override
+    public Class<?> type() {
+        return Object.class;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/matchers/ArrayEquals.java b/mockito-core/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
similarity index 95%
rename from src/main/java/org/mockito/internal/matchers/ArrayEquals.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
index 87a9588ecf..b4877734ac 100644
--- a/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
@@ -13,6 +13,7 @@ public ArrayEquals(Object wanted) {
         super(wanted);
     }
 
+    @Override
     public boolean matches(Object actual) {
         Object wanted = getWanted();
         if (wanted == null || actual == null) {
@@ -39,6 +40,7 @@ public boolean matches(Object actual) {
         return false;
     }
 
+    @Override
     public String toString() {
         if (getWanted() != null && getWanted().getClass().isArray()) {
             return appendArray(createObjectArray(getWanted()));
@@ -48,10 +50,10 @@ public String toString() {
     }
 
     private String appendArray(Object[] array) {
-        //TODO SF overlap with ValuePrinter
+        // TODO SF overlap with ValuePrinter
         StringBuilder out = new StringBuilder("[");
         for (int i = 0; i < array.length; i++) {
-            out.append(new Equals(array[i]).toString());
+            out.append(new Equals(array[i]));
             if (i != array.length - 1) {
                 out.append(", ");
             }
diff --git a/src/main/java/org/mockito/internal/matchers/CapturesArguments.java b/mockito-core/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
similarity index 99%
rename from src/main/java/org/mockito/internal/matchers/CapturesArguments.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
index 0c13853ff7..2e1981c47b 100644
--- a/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
@@ -4,9 +4,7 @@
  */
 package org.mockito.internal.matchers;
 
-
 public interface CapturesArguments {
 
     void captureFrom(Object argument);
-
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java b/mockito-core/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
new file mode 100644
index 0000000000..7ce9133651
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import static org.mockito.internal.exceptions.Reporter.noArgumentValueWasCaptured;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.util.Primitives;
+
+public class CapturingMatcher<T> implements ArgumentMatcher<T>, CapturesArguments, Serializable {
+
+    private final Class<? extends T> clazz;
+    private final List<T> arguments = new ArrayList<>();
+
+    private final ReadWriteLock lock = new ReentrantReadWriteLock();
+    private final Lock readLock = lock.readLock();
+    private final Lock writeLock = lock.writeLock();
+
+    public CapturingMatcher(final Class<? extends T> clazz) {
+        this.clazz = Objects.requireNonNull(clazz);
+    }
+
+    @Override
+    public boolean matches(Object argument) {
+        if (argument == null) {
+            return true;
+        }
+
+        if (Primitives.isPrimitiveOrWrapper(clazz)) {
+            return Primitives.isAssignableFromWrapper(clazz, argument.getClass());
+        }
+
+        return clazz.isAssignableFrom(argument.getClass());
+    }
+
+    @Override
+    public String toString() {
+        return "<Capturing argument: " + clazz.getSimpleName() + ">";
+    }
+
+    public T getLastValue() {
+        readLock.lock();
+        try {
+            if (arguments.isEmpty()) {
+                throw noArgumentValueWasCaptured();
+            }
+
+            return arguments.get(arguments.size() - 1);
+        } finally {
+            readLock.unlock();
+        }
+    }
+
+    public List<T> getAllValues() {
+        readLock.lock();
+        try {
+            return new ArrayList<>(arguments);
+        } finally {
+            readLock.unlock();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void captureFrom(Object argument) {
+        writeLock.lock();
+        try {
+            this.arguments.add((T) argument);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public Class<?> type() {
+        return clazz;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/matchers/CompareEqual.java b/mockito-core/src/main/java/org/mockito/internal/matchers/CompareEqual.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/CompareEqual.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/CompareEqual.java
diff --git a/src/main/java/org/mockito/internal/matchers/CompareTo.java b/mockito-core/src/main/java/org/mockito/internal/matchers/CompareTo.java
similarity index 82%
rename from src/main/java/org/mockito/internal/matchers/CompareTo.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/CompareTo.java
index e3acafdcda..587bdc501c 100644
--- a/src/main/java/org/mockito/internal/matchers/CompareTo.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/CompareTo.java
@@ -8,7 +8,8 @@
 
 import org.mockito.ArgumentMatcher;
 
-public abstract class CompareTo<T extends Comparable<T>> implements ArgumentMatcher<T>, Serializable {
+public abstract class CompareTo<T extends Comparable<T>>
+        implements ArgumentMatcher<T>, Serializable {
     private final T wanted;
 
     public CompareTo(T value) {
@@ -20,7 +21,7 @@ public final boolean matches(T actual) {
         if (actual == null) {
             return false;
         }
-        if (!actual.getClass().isInstance(wanted)){
+        if (!actual.getClass().isInstance(wanted)) {
             return false;
         }
 
diff --git a/src/main/java/org/mockito/internal/matchers/Contains.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Contains.java
similarity index 95%
rename from src/main/java/org/mockito/internal/matchers/Contains.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/Contains.java
index 5ece3ccd31..a52f1fb75b 100644
--- a/src/main/java/org/mockito/internal/matchers/Contains.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Contains.java
@@ -8,7 +8,6 @@
 
 import org.mockito.ArgumentMatcher;
 
-
 public class Contains implements ArgumentMatcher<String>, Serializable {
 
     private final String substring;
@@ -17,10 +16,12 @@ public Contains(String substring) {
         this.substring = substring;
     }
 
+    @Override
     public boolean matches(String actual) {
         return actual != null && actual.contains(substring);
     }
 
+    @Override
     public String toString() {
         return "contains(\"" + substring + "\")";
     }
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/mockito-core/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java
new file mode 100644
index 0000000000..8c698fdccf
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+/**
+ * Intended to use in certain ArgumentMatchers.
+ * When ArgumentMatcher fails, chance is that the actual object has the same output of toString() than
+ * the wanted object. This looks weird when failures are reported.
+ * Therefore when matcher fails but toString() yields the same outputs,
+ * we will try to use the {@link #toStringWithType(String)} method.
+ */
+public interface ContainsExtraTypeInfo {
+
+    /**
+     * @param className - name of the class to be printed in description
+     * Returns more verbose description of the object which include type information
+     */
+    String toStringWithType(String className);
+
+    /**
+     * Checks if target target has matching type.
+     * If the type matches, there is no point in rendering result from {@link #toStringWithType(String)}
+     */
+    boolean typeMatches(Object target);
+
+    /**
+     *
+     * @return Returns the wanted argument
+     */
+    Object getWanted();
+}
diff --git a/src/main/java/org/mockito/internal/matchers/EndsWith.java b/mockito-core/src/main/java/org/mockito/internal/matchers/EndsWith.java
similarity index 95%
rename from src/main/java/org/mockito/internal/matchers/EndsWith.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/EndsWith.java
index b3a8068205..40562100d5 100644
--- a/src/main/java/org/mockito/internal/matchers/EndsWith.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/EndsWith.java
@@ -16,10 +16,12 @@ public EndsWith(String suffix) {
         this.suffix = suffix;
     }
 
+    @Override
     public boolean matches(String actual) {
         return actual != null && actual.endsWith(suffix);
     }
 
+    @Override
     public String toString() {
         return "endsWith(\"" + suffix + "\")";
     }
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/Equality.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Equality.java
new file mode 100644
index 0000000000..a1cd701f56
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Equality.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.lang.reflect.Array;
+
+// stolen from hamcrest because I didn't want to have more dependency than Matcher class
+public final class Equality {
+
+    public static boolean areEqual(Object o1, Object o2) {
+        if (o1 == o2) {
+            return true;
+        } else if (o1 == null || o2 == null) {
+            return false;
+        } else if (isArray(o1)) {
+            return isArray(o2) && areArraysEqual(o1, o2);
+        } else {
+            return o1.equals(o2);
+        }
+    }
+
+    static boolean areArraysEqual(Object o1, Object o2) {
+        return areArrayLengthsEqual(o1, o2) && areArrayElementsEqual(o1, o2);
+    }
+
+    static boolean areArrayLengthsEqual(Object o1, Object o2) {
+        return Array.getLength(o1) == Array.getLength(o2);
+    }
+
+    static boolean areArrayElementsEqual(Object o1, Object o2) {
+        for (int i = 0; i < Array.getLength(o1); i++) {
+            if (!areEqual(Array.get(o1, i), Array.get(o2, i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static boolean isArray(Object o) {
+        return o.getClass().isArray();
+    }
+
+    private Equality() {}
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/Equals.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Equals.java
new file mode 100644
index 0000000000..bbfad627c4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Equals.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.matchers;
+
+import java.io.Serializable;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.text.ValuePrinter;
+
+public class Equals implements ArgumentMatcher<Object>, ContainsExtraTypeInfo, Serializable {
+
+    private final Object wanted;
+
+    public Equals(Object wanted) {
+        this.wanted = wanted;
+    }
+
+    @Override
+    public boolean matches(Object actual) {
+        return Equality.areEqual(this.wanted, actual);
+    }
+
+    @Override
+    public Class<?> type() {
+        return wanted != null ? wanted.getClass() : ArgumentMatcher.super.type();
+    }
+
+    @Override
+    public String toString() {
+        return describe(wanted);
+    }
+
+    private String describe(Object object) {
+        return ValuePrinter.print(object);
+    }
+
+    @Override
+    public final Object getWanted() {
+        return wanted;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof Equals)) {
+            return false;
+        }
+        Equals other = (Equals) o;
+        return (this.wanted == null && other.wanted == null)
+                || this.wanted != null && this.wanted.equals(other.wanted);
+    }
+
+    @Override
+    public int hashCode() {
+        return 1;
+    }
+
+    @Override
+    public String toStringWithType(String className) {
+        return "(" + className + ") " + describe(wanted);
+    }
+
+    @Override
+    public boolean typeMatches(Object target) {
+        return wanted != null && target != null && target.getClass() == wanted.getClass();
+    }
+}
diff --git a/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java b/mockito-core/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
similarity index 81%
rename from src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
index d7f062d60e..e417ec2c5d 100644
--- a/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
@@ -6,6 +6,7 @@
 
 import java.io.Serializable;
 
+import java.util.Objects;
 import org.mockito.ArgumentMatcher;
 
 public class EqualsWithDelta implements ArgumentMatcher<Number>, Serializable {
@@ -18,20 +19,21 @@ public EqualsWithDelta(Number value, Number delta) {
         this.delta = delta;
     }
 
+    @Override
     public boolean matches(Number actual) {
         if (wanted == null ^ actual == null) {
             return false;
         }
 
-        if (wanted == actual) {
+        if (Objects.equals(wanted, actual)) {
             return true;
         }
 
         return wanted.doubleValue() - delta.doubleValue() <= actual.doubleValue()
-                && actual.doubleValue() <= wanted.doubleValue()
-                        + delta.doubleValue();
+                && actual.doubleValue() <= wanted.doubleValue() + delta.doubleValue();
     }
 
+    @Override
     public String toString() {
         return "eq(" + wanted + ", " + delta + ")";
     }
diff --git a/src/main/java/org/mockito/internal/matchers/Find.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Find.java
similarity index 86%
rename from src/main/java/org/mockito/internal/matchers/Find.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/Find.java
index 7206ad3bba..530e4c01b3 100644
--- a/src/main/java/org/mockito/internal/matchers/Find.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Find.java
@@ -17,11 +17,13 @@ public Find(String regex) {
         this.regex = regex;
     }
 
+    @Override
     public boolean matches(String actual) {
         return actual != null && Pattern.compile(regex).matcher(actual).find();
     }
 
+    @Override
     public String toString() {
-        return "find(\"" + regex.replaceAll("\\\\", "\\\\\\\\") + "\")";
+        return "find(\"" + regex.replace("\\", "\\\\") + "\")";
     }
 }
diff --git a/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java b/mockito-core/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java
diff --git a/src/main/java/org/mockito/internal/matchers/GreaterThan.java b/mockito-core/src/main/java/org/mockito/internal/matchers/GreaterThan.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/GreaterThan.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/GreaterThan.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/InstanceOf.java b/mockito-core/src/main/java/org/mockito/internal/matchers/InstanceOf.java
new file mode 100644
index 0000000000..a53b1bda0f
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/InstanceOf.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.io.Serializable;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.util.Primitives;
+
+public class InstanceOf implements ArgumentMatcher<Object>, Serializable {
+
+    final Class<?> clazz;
+    private final String description;
+
+    public InstanceOf(Class<?> clazz) {
+        this(clazz, "isA(" + clazz.getCanonicalName() + ")");
+    }
+
+    public InstanceOf(Class<?> clazz, String describedAs) {
+        this.clazz = clazz;
+        this.description = describedAs;
+    }
+
+    @Override
+    public boolean matches(Object actual) {
+        return (actual != null)
+                && (Primitives.isAssignableFromWrapper(actual.getClass(), clazz)
+                        || clazz.isAssignableFrom(actual.getClass()));
+    }
+
+    @Override
+    public Class<?> type() {
+        return clazz;
+    }
+
+    @Override
+    public String toString() {
+        return description;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/matchers/LessOrEqual.java b/mockito-core/src/main/java/org/mockito/internal/matchers/LessOrEqual.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/LessOrEqual.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/LessOrEqual.java
diff --git a/src/main/java/org/mockito/internal/matchers/LessThan.java b/mockito-core/src/main/java/org/mockito/internal/matchers/LessThan.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/LessThan.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/LessThan.java
diff --git a/src/main/java/org/mockito/internal/matchers/LocalizedMatcher.java b/mockito-core/src/main/java/org/mockito/internal/matchers/LocalizedMatcher.java
similarity index 85%
rename from src/main/java/org/mockito/internal/matchers/LocalizedMatcher.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/LocalizedMatcher.java
index 00b47de7a9..a54eb6d79e 100644
--- a/src/main/java/org/mockito/internal/matchers/LocalizedMatcher.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/LocalizedMatcher.java
@@ -5,7 +5,7 @@
 package org.mockito.internal.matchers;
 
 import org.mockito.ArgumentMatcher;
-import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.debugging.LocationFactory;
 import org.mockito.invocation.Location;
 
 @SuppressWarnings("unchecked")
@@ -16,7 +16,7 @@ public class LocalizedMatcher {
 
     public LocalizedMatcher(ArgumentMatcher<?> matcher) {
         this.matcher = matcher;
-        this.location = new LocationImpl();
+        this.location = LocationFactory.create();
     }
 
     public Location getLocation() {
diff --git a/src/main/java/org/mockito/internal/matchers/Matches.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Matches.java
similarity index 84%
rename from src/main/java/org/mockito/internal/matchers/Matches.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/Matches.java
index 63b77ff43a..dcd7347401 100644
--- a/src/main/java/org/mockito/internal/matchers/Matches.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Matches.java
@@ -21,11 +21,13 @@ public Matches(Pattern pattern) {
         this.pattern = pattern;
     }
 
+    @Override
     public boolean matches(Object actual) {
-        return (actual instanceof String) && pattern.matcher((String) actual).matches();
+        return (actual instanceof String) && pattern.matcher((String) actual).find();
     }
 
+    @Override
     public String toString() {
-        return "matches(\"" + pattern.pattern().replaceAll("\\\\", "\\\\\\\\") + "\")";
+        return "matches(\"" + pattern.pattern().replace("\\", "\\\\") + "\")";
     }
 }
diff --git a/src/main/java/org/mockito/internal/matchers/Not.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Not.java
similarity index 78%
rename from src/main/java/org/mockito/internal/matchers/Not.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/Not.java
index f81315e89a..62b91b5c64 100644
--- a/src/main/java/org/mockito/internal/matchers/Not.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Not.java
@@ -8,7 +8,7 @@
 
 import org.mockito.ArgumentMatcher;
 
-@SuppressWarnings({ "unchecked", "serial","rawtypes" })
+@SuppressWarnings({"unchecked", "serial", "rawtypes"})
 public class Not implements ArgumentMatcher<Object>, Serializable {
 
     private final ArgumentMatcher matcher;
@@ -17,10 +17,17 @@ public Not(ArgumentMatcher<?> matcher) {
         this.matcher = matcher;
     }
 
+    @Override
     public boolean matches(Object actual) {
         return !matcher.matches(actual);
     }
 
+    @Override
+    public Class<?> type() {
+        return matcher.type();
+    }
+
+    @Override
     public String toString() {
         return "not(" + matcher + ")";
     }
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/NotNull.java b/mockito-core/src/main/java/org/mockito/internal/matchers/NotNull.java
new file mode 100644
index 0000000000..f3f7fe7d05
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/NotNull.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+import org.mockito.ArgumentMatcher;
+
+public class NotNull<T> implements ArgumentMatcher<T>, Serializable {
+
+    public static final NotNull<Object> NOT_NULL = new NotNull<>(Object.class);
+
+    private final Class<T> type;
+
+    public NotNull(Class<T> type) {
+        this.type = Objects.requireNonNull(type);
+    }
+
+    @Override
+    public boolean matches(Object actual) {
+        return actual != null;
+    }
+
+    @Override
+    public Class<T> type() {
+        return type;
+    }
+
+    @Override
+    public String toString() {
+        return "notNull()";
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/Null.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Null.java
new file mode 100644
index 0000000000..400170a5cc
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Null.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+import org.mockito.ArgumentMatcher;
+
+public class Null<T> implements ArgumentMatcher<T>, Serializable {
+
+    public static final Null<Object> NULL = new Null<>(Object.class);
+    private final Class<T> type;
+
+    public Null(Class<T> type) {
+        this.type = Objects.requireNonNull(type);
+    }
+
+    @Override
+    public boolean matches(Object actual) {
+        return actual == null;
+    }
+
+    @Override
+    public Class<T> type() {
+        return type;
+    }
+
+    @Override
+    public String toString() {
+        return "isNull()";
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/Or.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Or.java
new file mode 100644
index 0000000000..7354814323
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Or.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import java.io.Serializable;
+
+import org.mockito.ArgumentMatcher;
+
+@SuppressWarnings({"unchecked", "serial", "rawtypes"})
+public class Or implements ArgumentMatcher<Object>, Serializable {
+    private final ArgumentMatcher m1;
+    private final ArgumentMatcher m2;
+
+    public Or(ArgumentMatcher<?> m1, ArgumentMatcher<?> m2) {
+        this.m1 = m1;
+        this.m2 = m2;
+    }
+
+    @Override
+    public boolean matches(Object actual) {
+        return m1.matches(actual) || m2.matches(actual);
+    }
+
+    @Override
+    public Class<?> type() {
+        return m1.type().isAssignableFrom(m2.type())
+                ? m1.type()
+                : m2.type().isAssignableFrom(m1.type()) ? m2.type() : ArgumentMatcher.super.type();
+    }
+
+    @Override
+    public String toString() {
+        return "or(" + m1 + ", " + m2 + ")";
+    }
+}
diff --git a/src/main/java/org/mockito/internal/matchers/Same.java b/mockito-core/src/main/java/org/mockito/internal/matchers/Same.java
similarity index 79%
rename from src/main/java/org/mockito/internal/matchers/Same.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/Same.java
index 4349b341de..fa116b53f0 100644
--- a/src/main/java/org/mockito/internal/matchers/Same.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/Same.java
@@ -17,10 +17,17 @@ public Same(Object wanted) {
         this.wanted = wanted;
     }
 
+    @Override
     public boolean matches(Object actual) {
         return wanted == actual;
     }
 
+    @Override
+    public Class<?> type() {
+        return wanted != null ? wanted.getClass() : ArgumentMatcher.super.type();
+    }
+
+    @Override
     public String toString() {
         return "same(" + ValuePrinter.print(wanted) + ")";
     }
diff --git a/src/main/java/org/mockito/internal/matchers/StartsWith.java b/mockito-core/src/main/java/org/mockito/internal/matchers/StartsWith.java
similarity index 95%
rename from src/main/java/org/mockito/internal/matchers/StartsWith.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/StartsWith.java
index c25241f74f..2daae975eb 100644
--- a/src/main/java/org/mockito/internal/matchers/StartsWith.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/StartsWith.java
@@ -16,10 +16,12 @@ public StartsWith(String prefix) {
         this.prefix = prefix;
     }
 
+    @Override
     public boolean matches(String actual) {
         return actual != null && actual.startsWith(prefix);
     }
 
+    @Override
     public String toString() {
         return "startsWith(\"" + prefix + "\")";
     }
diff --git a/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java b/mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
similarity index 90%
rename from src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
index c044ccfe37..eaa1516856 100644
--- a/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
@@ -4,9 +4,12 @@
  */
 package org.mockito.internal.matchers.apachecommons;
 
-import java.lang.reflect.AccessibleObject;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -90,7 +93,7 @@ public EqualsBuilder() {
         // do nothing for now.
     }
 
-    //-------------------------------------------------------------------------
+    // -------------------------------------------------------------------------
 
     /**
      * <p>This method uses reflection to determine if the two <code>Object</code>s
@@ -186,7 +189,8 @@ public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTrans
      * @return <code>true</code> if the two Objects have tested equals.
      * @since 2.1.0
      */
-    public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTransients, Class<?> reflectUpToClass) {
+    public static boolean reflectionEquals(
+            Object lhs, Object rhs, boolean testTransients, Class<?> reflectUpToClass) {
         return reflectionEquals(lhs, rhs, testTransients, reflectUpToClass, null);
     }
 
@@ -216,7 +220,11 @@ public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTrans
      * @return <code>true</code> if the two Objects have tested equals.
      * @since 2.1.0
      */
-    public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTransients, Class<?> reflectUpToClass,
+    public static boolean reflectionEquals(
+            Object lhs,
+            Object rhs,
+            boolean testTransients,
+            Class<?> reflectUpToClass,
             String[] excludeFields) {
         if (lhs == rhs) {
             return true;
@@ -248,20 +256,16 @@ public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTrans
             return false;
         }
         EqualsBuilder equalsBuilder = new EqualsBuilder();
-        try {
-            reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
-            while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
-                testClass = testClass.getSuperclass();
-                reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
-            }
-        } catch (IllegalArgumentException e) {
-            // In this case, we tried to test a subclass vs. a superclass and
-            // the subclass has ivars or the ivars are transient and
-            // we are testing transients.
-            // If a subclass has ivars that we are trying to test them, we get an
-            // exception and we know that the objects are not equal.
+        if (reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields)) {
             return false;
         }
+        while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
+            testClass = testClass.getSuperclass();
+            if (reflectionAppend(
+                    lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields)) {
+                return false;
+            }
+        }
         return equalsBuilder.isEquals();
     }
 
@@ -276,34 +280,41 @@ public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTrans
      * @param useTransients  whether to test transient fields
      * @param excludeFields  array of field names to exclude from testing
      */
-    private static void reflectionAppend(
-        Object lhs,
-        Object rhs,
-        Class<?> clazz,
-        EqualsBuilder builder,
-        boolean useTransients,
-        String[] excludeFields) {
+    private static boolean reflectionAppend(
+            Object lhs,
+            Object rhs,
+            Class<?> clazz,
+            EqualsBuilder builder,
+            boolean useTransients,
+            String[] excludeFields) {
         Field[] fields = clazz.getDeclaredFields();
-        List<String> excludedFieldList = excludeFields != null ? Arrays.asList(excludeFields) : Collections.<String>emptyList();
-        AccessibleObject.setAccessible(fields, true);
+        List<String> excludedFieldList =
+                excludeFields != null
+                        ? Arrays.asList(excludeFields)
+                        : Collections.<String>emptyList();
+        MemberAccessor accessor = Plugins.getMemberAccessor();
         for (int i = 0; i < fields.length && builder.isEquals; i++) {
             Field f = fields[i];
             if (!excludedFieldList.contains(f.getName())
-                && (f.getName().indexOf('$') == -1)
-                && (useTransients || !Modifier.isTransient(f.getModifiers()))
-                && (!Modifier.isStatic(f.getModifiers()))) {
+                    && (f.getName().indexOf('$') == -1)
+                    && (useTransients || !Modifier.isTransient(f.getModifiers()))
+                    && !Modifier.isStatic(f.getModifiers())) {
                 try {
-                    builder.append(f.get(lhs), f.get(rhs));
-                } catch (IllegalAccessException e) {
-                    //this can't happen. Would get a Security exception instead
-                    //throw a runtime exception in case the impossible happens.
-                    throw new InternalError("Unexpected IllegalAccessException");
+                    builder.append(accessor.get(f, lhs), accessor.get(f, rhs));
+                } catch (RuntimeException | IllegalAccessException ignored) {
+                    // In this case, we tried to test a subclass vs. a superclass and
+                    // the subclass has ivars or the ivars are transient and we are
+                    // testing transients. If a subclass has ivars that we are trying
+                    // to test them, we get an exception and we know that the objects
+                    // are not equal.
+                    return true;
                 }
             }
         }
+        return false;
     }
 
-    //-------------------------------------------------------------------------
+    // -------------------------------------------------------------------------
 
     /**
      * <p>Adds the result of <code>super.equals()</code> to this builder.</p>
@@ -317,7 +328,7 @@ public EqualsBuilder appendSuper(boolean superEquals) {
         return this;
     }
 
-    //-------------------------------------------------------------------------
+    // -------------------------------------------------------------------------
 
     /**
      * <p>Test if two <code>Object</code>s are equal using their
@@ -340,8 +351,8 @@ public EqualsBuilder append(Object lhs, Object rhs) {
         }
         Class<?> lhsClass = lhs.getClass();
         if (!lhsClass.isArray()) {
-            if (lhs instanceof java.math.BigDecimal && rhs instanceof java.math.BigDecimal) {
-                isEquals = (((java.math.BigDecimal) lhs).compareTo((java.math.BigDecimal) rhs) == 0);
+            if (lhs instanceof BigDecimal && rhs instanceof BigDecimal) {
+                isEquals = (((BigDecimal) lhs).compareTo((BigDecimal) rhs) == 0);
             } else {
                 // The simple case, not an array, just test the element
                 isEquals = lhs.equals(rhs);
@@ -350,8 +361,8 @@ public EqualsBuilder append(Object lhs, Object rhs) {
             // Here when we compare different dimensions, for example: a boolean[][] to a boolean[]
             this.setEquals(false);
 
-        // 'Switch' on type of array, to dispatch to the correct handler
-        // This handles multi dimensional arrays of the same depth
+            // 'Switch' on type of array, to dispatch to the correct handler
+            // This handles multi dimensional arrays of the same depth
         } else if (lhs instanceof long[]) {
             append((long[]) lhs, (long[]) rhs);
         } else if (lhs instanceof int[]) {
@@ -485,7 +496,7 @@ public EqualsBuilder append(float lhs, float rhs) {
      * @param lhs  the left hand <code>boolean</code>
      * @param rhs  the right hand <code>boolean</code>
      * @return EqualsBuilder - used to chain calls.
-      */
+     */
     public EqualsBuilder append(boolean lhs, boolean rhs) {
         isEquals &= (lhs == rhs);
         return this;
diff --git a/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java b/mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
similarity index 96%
rename from src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
index 5ccbcb96fd..6dcbfc65e2 100644
--- a/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
@@ -18,10 +18,12 @@ public ReflectionEquals(Object wanted, String... excludeFields) {
         this.excludeFields = excludeFields;
     }
 
+    @Override
     public boolean matches(Object actual) {
         return EqualsBuilder.reflectionEquals(wanted, actual, excludeFields);
     }
 
+    @Override
     public String toString() {
         return "refEq(" + wanted + ")";
     }
diff --git a/src/main/java/org/mockito/internal/matchers/apachecommons/commons-lang-license.txt b/mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/commons-lang-license.txt
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/apachecommons/commons-lang-license.txt
rename to mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/commons-lang-license.txt
diff --git a/src/main/java/org/mockito/internal/matchers/apachecommons/package-info.java b/mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/apachecommons/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/apachecommons/package-info.java
diff --git a/src/main/java/org/mockito/internal/matchers/package-info.java b/mockito-core/src/main/java/org/mockito/internal/matchers/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/package-info.java
diff --git a/src/main/java/org/mockito/internal/matchers/text/FormattedText.java b/mockito-core/src/main/java/org/mockito/internal/matchers/text/FormattedText.java
similarity index 100%
rename from src/main/java/org/mockito/internal/matchers/text/FormattedText.java
rename to mockito-core/src/main/java/org/mockito/internal/matchers/text/FormattedText.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java b/mockito-core/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
new file mode 100644
index 0000000000..d59cbac7da
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers.text;
+
+import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
+import static org.mockito.internal.util.StringUtil.decamelizeMatcherName;
+
+import java.lang.reflect.Method;
+
+import org.mockito.ArgumentMatcher;
+
+/** Provides better toString() text for matcher that don't have toString() method declared. */
+final class MatcherToString {
+
+    /**
+     * Attempts to provide more descriptive toString() for given matcher.
+     * Searches matcher class hierarchy for toString() method. If it is found it will be used.
+     * If no toString() is defined for the matcher hierarchy,
+     * uses decamelized class name instead of default Object.toString().
+     * This way we can promote meaningful names for custom matchers.
+     *
+     * @param matcher
+     * @return
+     */
+    static String toString(ArgumentMatcher<?> matcher) {
+        Class<?> cls = matcher.getClass();
+        while (cls != Object.class) {
+            Method[] methods = cls.getDeclaredMethods();
+            for (Method m : methods) {
+                if (isToStringMethod(m)) {
+                    return matcher.toString();
+                }
+            }
+            cls = cls.getSuperclass();
+        }
+
+        String matcherName;
+        Class<?> matcherClass = matcher.getClass();
+        // Lambdas have non-empty getSimpleName() (despite being synthetic)
+        // but that name is not useful for user
+        if (matcherClass.isSynthetic()) {
+            matcherName = "";
+        } else {
+            matcherName = matcherClass.getSimpleName();
+        }
+
+        return decamelizeMatcherName(matcherName);
+    }
+
+    private MatcherToString() {}
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java b/mockito-core/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java
new file mode 100644
index 0000000000..9ceab39755
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers.text;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.ContainsExtraTypeInfo;
+import org.mockito.internal.reporting.PrintSettings;
+
+@SuppressWarnings("unchecked")
+public class MatchersPrinter {
+
+    public String getArgumentsLine(List<ArgumentMatcher> matchers, PrintSettings printSettings) {
+        Iterator args = applyPrintSettings(matchers, printSettings);
+        return ValuePrinter.printValues("(", ", ", ");", args);
+    }
+
+    public String getArgumentsBlock(List<ArgumentMatcher> matchers, PrintSettings printSettings) {
+        Iterator args = applyPrintSettings(matchers, printSettings);
+        return ValuePrinter.printValues("(\n    ", ",\n    ", "\n);", args);
+    }
+
+    private Iterator<FormattedText> applyPrintSettings(
+            List<ArgumentMatcher> matchers, PrintSettings printSettings) {
+        List<FormattedText> out = new LinkedList<>();
+        int i = 0;
+        for (final ArgumentMatcher matcher : matchers) {
+            if (matcher instanceof ContainsExtraTypeInfo) {
+                ContainsExtraTypeInfo typeInfoMatcher = (ContainsExtraTypeInfo) matcher;
+                Object wanted = typeInfoMatcher.getWanted();
+                String simpleNameOfArgument =
+                        wanted != null ? wanted.getClass().getSimpleName() : "";
+                String fullyQualifiedClassName =
+                        wanted != null ? wanted.getClass().getCanonicalName() : "";
+
+                if (printSettings.extraTypeInfoFor(i)) {
+                    out.add(
+                            new FormattedText(
+                                    typeInfoMatcher.toStringWithType(simpleNameOfArgument)));
+                } else if (printSettings.fullyQualifiedNameFor(simpleNameOfArgument)) {
+                    out.add(
+                            new FormattedText(
+                                    typeInfoMatcher.toStringWithType(fullyQualifiedClassName)));
+                } else {
+                    out.add(new FormattedText(MatcherToString.toString(matcher)));
+                }
+            } else {
+                out.add(new FormattedText(MatcherToString.toString(matcher)));
+            }
+            i++;
+        }
+        return out.iterator();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java b/mockito-core/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
new file mode 100644
index 0000000000..4517d7525e
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers.text;
+
+import java.lang.reflect.Array;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Prints a Java object value in a way humans can read it neatly.
+ * Inspired on hamcrest. Used for printing arguments in verification errors.
+ */
+public class ValuePrinter {
+
+    private ValuePrinter() {}
+
+    /**
+     * Prints given value so that it is neatly readable by humans.
+     * Handles explosive toString() implementations.
+     */
+    public static String print(final Object value) {
+        if (value == null) {
+            return "null";
+        }
+        if (value instanceof String) {
+            return '"' + value.toString() + '"';
+        }
+        if (value instanceof Character) {
+            return printChar((Character) value);
+        }
+        if (value instanceof Long) {
+            return value + "L";
+        }
+        if (value instanceof Double) {
+            return value + "d";
+        }
+        if (value instanceof Float) {
+            return value + "f";
+        }
+        if (value instanceof Short) {
+            return "(short) " + value;
+        }
+        if (value instanceof Byte) {
+            return String.format("(byte) 0x%02X", (Byte) value);
+        }
+        if (value instanceof Map) {
+            return printMap((Map<?, ?>) value);
+        }
+        if (value.getClass().isArray()) {
+            return printValues(
+                    "[",
+                    ", ",
+                    "]",
+                    new Iterator<Object>() {
+                        private int currentIndex = 0;
+
+                        @Override
+                        public boolean hasNext() {
+                            return currentIndex < Array.getLength(value);
+                        }
+
+                        public Object next() {
+                            return Array.get(value, currentIndex++);
+                        }
+
+                        public void remove() {
+                            throw new UnsupportedOperationException(
+                                    "cannot remove items from an array");
+                        }
+                    });
+        }
+        if (value instanceof FormattedText) {
+            return (((FormattedText) value).getText());
+        }
+
+        return descriptionOf(value);
+    }
+
+    private static String printMap(Map<?, ?> map) {
+        StringBuilder result = new StringBuilder();
+        Iterator<? extends Map.Entry<?, ?>> iterator = map.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<?, ?> entry = iterator.next();
+            result.append(print(entry.getKey())).append(" = ").append(print(entry.getValue()));
+            if (iterator.hasNext()) {
+                result.append(", ");
+            }
+        }
+        return "{" + result + "}";
+    }
+
+    /**
+     * Print values in a nice format, e.g. (1, 2, 3)
+     *
+     * @param start the beginning of the values, e.g. "("
+     * @param separator the separator of values, e.g. ", "
+     * @param end the end of the values, e.g. ")"
+     * @param values the values to print
+     *
+     * @return neatly formatted value list
+     */
+    public static String printValues(
+            String start, String separator, String end, Iterator<?> values) {
+        if (start == null) {
+            start = "(";
+        }
+        if (separator == null) {
+            separator = ",";
+        }
+        if (end == null) {
+            end = ")";
+        }
+
+        StringBuilder sb = new StringBuilder(start);
+        while (values.hasNext()) {
+            sb.append(print(values.next()));
+            if (values.hasNext()) {
+                sb.append(separator);
+            }
+        }
+        return sb.append(end).toString();
+    }
+
+    private static String printChar(char value) {
+        StringBuilder sb = new StringBuilder();
+        sb.append('\'');
+        switch (value) {
+            case '"':
+                sb.append("\\\"");
+                break;
+            case '\n':
+                sb.append("\\n");
+                break;
+            case '\r':
+                sb.append("\\r");
+                break;
+            case '\t':
+                sb.append("\\t");
+                break;
+            default:
+                sb.append(value);
+        }
+        sb.append('\'');
+        return sb.toString();
+    }
+
+    private static String descriptionOf(Object value) {
+        try {
+            return String.valueOf(value);
+        } catch (RuntimeException e) {
+            return value.getClass().getName() + "@" + Integer.toHexString(value.hashCode());
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/package-info.java b/mockito-core/src/main/java/org/mockito/internal/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/package-info.java
diff --git a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java b/mockito-core/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
similarity index 99%
rename from src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
rename to mockito-core/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
index 4352bda0b0..24bb8a4e21 100644
--- a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
+++ b/mockito-core/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
@@ -25,5 +25,4 @@ public interface ArgumentMatcherStorage {
     void validateState();
 
     void reset();
-
 }
diff --git a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java b/mockito-core/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
similarity index 88%
rename from src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
index b0dfd0232f..a853f23c97 100644
--- a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
@@ -10,8 +10,9 @@
 import static org.mockito.internal.exceptions.Reporter.misplacedArgumentMatcher;
 import static org.mockito.internal.exceptions.Reporter.reportNoSubMatchersFound;
 
-import java.util.*;
-
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
 import org.mockito.ArgumentMatcher;
 import org.mockito.internal.matchers.And;
 import org.mockito.internal.matchers.LocalizedMatcher;
@@ -22,39 +23,42 @@ public class ArgumentMatcherStorageImpl implements ArgumentMatcherStorage {
 
     private static final int TWO_SUB_MATCHERS = 2;
     private static final int ONE_SUB_MATCHER = 1;
-    private final Stack<LocalizedMatcher> matcherStack = new Stack<LocalizedMatcher>();
+    private final Stack<LocalizedMatcher> matcherStack = new Stack<>();
 
+    @Override
     public void reportMatcher(ArgumentMatcher<?> matcher) {
         matcherStack.push(new LocalizedMatcher(matcher));
     }
 
+    @Override
     public List<LocalizedMatcher> pullLocalizedMatchers() {
         if (matcherStack.isEmpty()) {
             return emptyList();
         }
 
-        List<LocalizedMatcher> lastMatchers = resetStack();
-        return lastMatchers;
+        return resetStack();
     }
 
     public void reportAnd() {
         assertStateFor("And(?)", TWO_SUB_MATCHERS);
 
-        ArgumentMatcher<?> m1 = popMatcher();
         ArgumentMatcher<?> m2 = popMatcher();
+        ArgumentMatcher<?> m1 = popMatcher();
 
         reportMatcher(new And(m1, m2));
     }
 
+    @Override
     public void reportOr() {
         assertStateFor("Or(?)", TWO_SUB_MATCHERS);
 
-        ArgumentMatcher<?> m1 = popMatcher();
         ArgumentMatcher<?> m2 = popMatcher();
+        ArgumentMatcher<?> m1 = popMatcher();
 
         reportMatcher(new Or(m1, m2));
     }
 
+    @Override
     public void reportNot() {
         assertStateFor("Not(?)", ONE_SUB_MATCHER);
 
@@ -63,6 +67,7 @@ public void reportNot() {
         reportMatcher(new Not(m));
     }
 
+    @Override
     public void validateState() {
         if (!matcherStack.isEmpty()) {
             List<LocalizedMatcher> lastMatchers = resetStack();
@@ -70,6 +75,7 @@ public void validateState() {
         }
     }
 
+    @Override
     public void reset() {
         matcherStack.clear();
     }
@@ -80,7 +86,8 @@ private void assertStateFor(String additionalMatcherName, int subMatchersCount)
         }
         if (matcherStack.size() < subMatchersCount) {
             List<LocalizedMatcher> lastMatchers = resetStack();
-            throw incorrectUseOfAdditionalMatchers(additionalMatcherName, subMatchersCount, lastMatchers);
+            throw incorrectUseOfAdditionalMatchers(
+                    additionalMatcherName, subMatchersCount, lastMatchers);
         }
     }
 
@@ -89,9 +96,8 @@ private ArgumentMatcher<?> popMatcher() {
     }
 
     private List<LocalizedMatcher> resetStack() {
-        ArrayList<LocalizedMatcher> lastMatchers = new ArrayList<LocalizedMatcher>(matcherStack);
+        ArrayList<LocalizedMatcher> lastMatchers = new ArrayList<>(matcherStack);
         reset();
         return lastMatchers;
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/progress/MockingProgress.java b/mockito-core/src/main/java/org/mockito/internal/progress/MockingProgress.java
similarity index 95%
rename from src/main/java/org/mockito/internal/progress/MockingProgress.java
rename to mockito-core/src/main/java/org/mockito/internal/progress/MockingProgress.java
index 9200c0845f..abdf68d83e 100644
--- a/src/main/java/org/mockito/internal/progress/MockingProgress.java
+++ b/mockito-core/src/main/java/org/mockito/internal/progress/MockingProgress.java
@@ -43,6 +43,8 @@ public interface MockingProgress {
 
     void mockingStarted(Object mock, MockCreationSettings settings);
 
+    void mockingStarted(Class<?> mock, MockCreationSettings settings);
+
     void addListener(MockitoListener listener);
 
     void removeListener(MockitoListener listener);
diff --git a/mockito-core/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java b/mockito-core/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
new file mode 100644
index 0000000000..2585d32cfc
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.progress;
+
+import static org.mockito.internal.exceptions.Reporter.unfinishedStubbing;
+import static org.mockito.internal.exceptions.Reporter.unfinishedVerificationException;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.internal.configuration.GlobalConfiguration;
+import org.mockito.internal.debugging.Localized;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.listeners.AutoCleanableListener;
+import org.mockito.invocation.Location;
+import org.mockito.listeners.MockCreationListener;
+import org.mockito.listeners.MockitoListener;
+import org.mockito.listeners.VerificationListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.verification.VerificationMode;
+import org.mockito.verification.VerificationStrategy;
+
+@SuppressWarnings("unchecked")
+public class MockingProgressImpl implements MockingProgress {
+
+    private final ArgumentMatcherStorage argumentMatcherStorage = new ArgumentMatcherStorageImpl();
+
+    private OngoingStubbing<?> ongoingStubbing;
+    private Localized<VerificationMode> verificationMode;
+    private Location stubbingInProgress = null;
+    private VerificationStrategy verificationStrategy;
+    private final Set<MockitoListener> listeners = new LinkedHashSet<>();
+
+    public MockingProgressImpl() {
+        this.verificationStrategy = getDefaultVerificationStrategy();
+    }
+
+    public static VerificationStrategy getDefaultVerificationStrategy() {
+        return new VerificationStrategy() {
+            @Override
+            public VerificationMode maybeVerifyLazily(VerificationMode mode) {
+                return mode;
+            }
+        };
+    }
+
+    @Override
+    public void reportOngoingStubbing(OngoingStubbing ongoingStubbing) {
+        this.ongoingStubbing = ongoingStubbing;
+    }
+
+    @Override
+    public OngoingStubbing<?> pullOngoingStubbing() {
+        OngoingStubbing<?> temp = ongoingStubbing;
+        ongoingStubbing = null;
+        return temp;
+    }
+
+    @Override
+    public Set<VerificationListener> verificationListeners() {
+        final LinkedHashSet<VerificationListener> verificationListeners = new LinkedHashSet<>();
+
+        for (MockitoListener listener : listeners) {
+            if (listener instanceof VerificationListener) {
+                verificationListeners.add((VerificationListener) listener);
+            }
+        }
+
+        return verificationListeners;
+    }
+
+    @Override
+    public void verificationStarted(VerificationMode verify) {
+        validateState();
+        resetOngoingStubbing();
+        verificationMode = new Localized(verify);
+    }
+
+    /**
+     * (non-Javadoc)
+     *
+     * @see org.mockito.internal.progress.MockingProgress#resetOngoingStubbing()
+     */
+    public void resetOngoingStubbing() {
+        ongoingStubbing = null;
+    }
+
+    @Override
+    public VerificationMode pullVerificationMode() {
+        if (verificationMode == null) {
+            return null;
+        }
+
+        VerificationMode temp = verificationMode.getObject();
+        verificationMode = null;
+        return temp;
+    }
+
+    @Override
+    public void stubbingStarted() {
+        validateState();
+        stubbingInProgress = LocationFactory.create();
+    }
+
+    @Override
+    public void validateState() {
+        validateMostStuff();
+
+        // validate stubbing:
+        if (stubbingInProgress != null) {
+            Location temp = stubbingInProgress;
+            stubbingInProgress = null;
+            throw unfinishedStubbing(temp);
+        }
+    }
+
+    private void validateMostStuff() {
+        // State is cool when GlobalConfiguration is already loaded
+        // this cannot really be tested functionally because I cannot dynamically mess up
+        // org.mockito.configuration.MockitoConfiguration class
+        GlobalConfiguration.validate();
+
+        if (verificationMode != null) {
+            Location location = verificationMode.getLocation();
+            verificationMode = null;
+            throw unfinishedVerificationException(location);
+        }
+
+        getArgumentMatcherStorage().validateState();
+    }
+
+    @Override
+    public void stubbingCompleted() {
+        stubbingInProgress = null;
+    }
+
+    @Override
+    public String toString() {
+        return "ongoingStubbing: "
+                + ongoingStubbing
+                + ", verificationMode: "
+                + verificationMode
+                + ", stubbingInProgress: "
+                + stubbingInProgress;
+    }
+
+    @Override
+    public void reset() {
+        stubbingInProgress = null;
+        verificationMode = null;
+        getArgumentMatcherStorage().reset();
+    }
+
+    @Override
+    public ArgumentMatcherStorage getArgumentMatcherStorage() {
+        return argumentMatcherStorage;
+    }
+
+    @Override
+    public void mockingStarted(Object mock, MockCreationSettings settings) {
+        for (MockitoListener listener : listeners) {
+            if (listener instanceof MockCreationListener) {
+                ((MockCreationListener) listener).onMockCreated(mock, settings);
+            }
+        }
+        validateMostStuff();
+    }
+
+    @Override
+    public void mockingStarted(Class<?> mock, MockCreationSettings settings) {
+        for (MockitoListener listener : listeners) {
+            if (listener instanceof MockCreationListener) {
+                ((MockCreationListener) listener).onStaticMockCreated(mock, settings);
+            }
+        }
+        validateMostStuff();
+    }
+
+    @Override
+    public void addListener(MockitoListener listener) {
+        addListener(listener, listeners);
+    }
+
+    static void addListener(MockitoListener listener, Set<MockitoListener> listeners) {
+        List<MockitoListener> delete = new LinkedList<>();
+        for (MockitoListener existing : listeners) {
+            if (existing.getClass().equals(listener.getClass())) {
+                if (existing instanceof AutoCleanableListener
+                        && ((AutoCleanableListener) existing).isListenerDirty()) {
+                    // dirty listener means that there was an exception even before the test started
+                    // if we fail here with redundant mockito listener exception there will be
+                    // multiple failures causing confusion
+                    // so we simply remove the existing listener and move on
+                    delete.add(existing);
+                } else {
+                    Reporter.redundantMockitoListener(listener.getClass().getSimpleName());
+                }
+            }
+        }
+        // delete dirty listeners so they don't occupy state/memory and don't receive notifications
+        listeners.removeAll(delete);
+        listeners.add(listener);
+    }
+
+    @Override
+    public void removeListener(MockitoListener listener) {
+        this.listeners.remove(listener);
+    }
+
+    @Override
+    public void setVerificationStrategy(VerificationStrategy strategy) {
+        this.verificationStrategy = strategy;
+    }
+
+    @Override
+    public VerificationMode maybeVerifyLazily(VerificationMode mode) {
+        return this.verificationStrategy.maybeVerifyLazily(mode);
+    }
+
+    @Override
+    public void clearListeners() {
+        listeners.clear();
+    }
+
+    /*
+
+    //TODO 545 thread safety of all mockito
+
+    use cases:
+       - single threaded execution throughout
+       - single threaded mock creation, stubbing & verification, multi-threaded interaction with mock
+       - thread per test case
+
+    */
+}
diff --git a/src/main/java/org/mockito/internal/progress/SequenceNumber.java b/mockito-core/src/main/java/org/mockito/internal/progress/SequenceNumber.java
similarity index 80%
rename from src/main/java/org/mockito/internal/progress/SequenceNumber.java
rename to mockito-core/src/main/java/org/mockito/internal/progress/SequenceNumber.java
index bc7a07dc26..50e45cc976 100644
--- a/src/main/java/org/mockito/internal/progress/SequenceNumber.java
+++ b/mockito-core/src/main/java/org/mockito/internal/progress/SequenceNumber.java
@@ -4,11 +4,13 @@
  */
 package org.mockito.internal.progress;
 
-public class SequenceNumber {
+public final class SequenceNumber {
 
     private static int sequenceNumber = 1;
 
     public static synchronized int next() {
         return sequenceNumber++;
     }
+
+    private SequenceNumber() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java b/mockito-core/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
new file mode 100644
index 0000000000..adb9b99a2e
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.progress;
+
+/**
+ * Provides access to the {@link MockingProgress} of a corresponding {@link Thread}. Every {@link Thread} in Mockito has it s own {@link MockingProgress} to avoid data races while stubbing.
+ */
+public class ThreadSafeMockingProgress {
+
+    private static final ThreadLocal<MockingProgress> MOCKING_PROGRESS_PROVIDER =
+            new ThreadLocal<MockingProgress>() {
+                @Override
+                protected MockingProgress initialValue() {
+                    return new MockingProgressImpl();
+                }
+            };
+
+    private ThreadSafeMockingProgress() {}
+
+    /**
+     * Returns the {@link MockingProgress} for the current Thread.
+     * <p>
+     * <b>IMPORTANT</b>: Never assign and access the returned {@link MockingProgress} to an instance or static field. Thread safety can not be guaranteed in this case, cause the Thread that wrote the field might not be the same that read it. In other words multiple threads will access the same {@link MockingProgress}.
+     *
+     * @return never <code>null</code>
+     */
+    public static final MockingProgress mockingProgress() {
+        return MOCKING_PROGRESS_PROVIDER.get();
+    }
+}
diff --git a/src/main/java/org/mockito/internal/progress/package-info.java b/mockito-core/src/main/java/org/mockito/internal/progress/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/progress/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/progress/package-info.java
diff --git a/src/main/java/org/mockito/internal/reporting/Discrepancy.java b/mockito-core/src/main/java/org/mockito/internal/reporting/Discrepancy.java
similarity index 100%
rename from src/main/java/org/mockito/internal/reporting/Discrepancy.java
rename to mockito-core/src/main/java/org/mockito/internal/reporting/Discrepancy.java
diff --git a/src/main/java/org/mockito/internal/reporting/Pluralizer.java b/mockito-core/src/main/java/org/mockito/internal/reporting/Pluralizer.java
similarity index 78%
rename from src/main/java/org/mockito/internal/reporting/Pluralizer.java
rename to mockito-core/src/main/java/org/mockito/internal/reporting/Pluralizer.java
index 5a9d7425b0..a8b083fb21 100644
--- a/src/main/java/org/mockito/internal/reporting/Pluralizer.java
+++ b/mockito-core/src/main/java/org/mockito/internal/reporting/Pluralizer.java
@@ -4,7 +4,7 @@
  */
 package org.mockito.internal.reporting;
 
-public class Pluralizer {
+public final class Pluralizer {
 
     public static String pluralize(int number) {
         return number == 1 ? "1 time" : number + " times";
@@ -18,7 +18,5 @@ public static String were_exactly_x_interactions(int x) {
         }
     }
 
-    public static String stubbings(int number) {
-        return number == 1 ? "stubbing" : "stubbings";
-    }
+    private Pluralizer() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/reporting/PrintSettings.java b/mockito-core/src/main/java/org/mockito/internal/reporting/PrintSettings.java
new file mode 100644
index 0000000000..41794adcb0
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/reporting/PrintSettings.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.reporting;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.text.MatchersPrinter;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
+
+public class PrintSettings {
+
+    public static final int MAX_LINE_LENGTH = 45;
+    private boolean multiline;
+    private List<Integer> withTypeInfo = new LinkedList<>();
+    private Set<String> withFullyQualifiedName = Collections.emptySet();
+
+    public void setMultiline(boolean multiline) {
+        this.multiline = multiline;
+    }
+
+    public boolean isMultiline() {
+        return multiline;
+    }
+
+    public static PrintSettings verboseMatchers(Integer... indexesOfMatchers) {
+        PrintSettings settings = new PrintSettings();
+        settings.setMatchersToBeDescribedWithExtraTypeInfo(indexesOfMatchers);
+        return settings;
+    }
+
+    public boolean extraTypeInfoFor(int argumentIndex) {
+        return withTypeInfo.contains(argumentIndex);
+    }
+
+    public boolean fullyQualifiedNameFor(String simpleClassName) {
+        return withFullyQualifiedName.contains(simpleClassName);
+    }
+
+    public void setMatchersToBeDescribedWithExtraTypeInfo(Integer[] indexesOfMatchers) {
+        this.withTypeInfo = Arrays.asList(indexesOfMatchers);
+    }
+
+    public void setMatchersToBeDescribedWithFullName(Set<String> indexesOfMatchers) {
+        this.withFullyQualifiedName = indexesOfMatchers;
+    }
+
+    public String print(List<ArgumentMatcher> matchers, Invocation invocation) {
+        MatchersPrinter matchersPrinter = new MatchersPrinter();
+        String qualifiedName =
+                MockUtil.getMockName(invocation.getMock()) + "." + invocation.getMethod().getName();
+        String invocationString = qualifiedName + matchersPrinter.getArgumentsLine(matchers, this);
+        if (isMultiline() || (!matchers.isEmpty() && invocationString.length() > MAX_LINE_LENGTH)) {
+            return qualifiedName + matchersPrinter.getArgumentsBlock(matchers, this);
+        } else {
+            return invocationString;
+        }
+    }
+
+    public String print(Invocation invocation) {
+        return print(invocation.getArgumentsAsMatchers(), invocation);
+    }
+
+    public String print(MatchableInvocation invocation) {
+        return print(invocation.getMatchers(), invocation.getInvocation());
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/reporting/SmartPrinter.java b/mockito-core/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
new file mode 100644
index 0000000000..f4b1f71d40
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.reporting;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
+
+/**
+ * Makes sure both wanted and actual are printed consistently (single line or multiline)
+ * <p>
+ * Makes arguments printed with types if necessary
+ */
+public class SmartPrinter {
+
+    private final String wanted;
+    private final List<String> actuals;
+
+    public SmartPrinter(
+            MatchableInvocation wanted,
+            Invocation actual,
+            Integer... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
+        this(
+                wanted,
+                Collections.singletonList(actual),
+                indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+                Collections.emptySet());
+    }
+
+    public SmartPrinter(
+            MatchableInvocation wanted,
+            List<Invocation> allActualInvocations,
+            Integer[] indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+            Set<String> classNamesToBeDescribedWithFullName) {
+        PrintSettings printSettings = new PrintSettings();
+        printSettings.setMultiline(isMultiLine(wanted, allActualInvocations));
+        printSettings.setMatchersToBeDescribedWithExtraTypeInfo(
+                indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+        printSettings.setMatchersToBeDescribedWithFullName(classNamesToBeDescribedWithFullName);
+
+        this.wanted = printSettings.print(wanted);
+
+        List<String> actuals = new ArrayList<>();
+        for (Invocation actual : allActualInvocations) {
+            actuals.add(printSettings.print(actual));
+        }
+        this.actuals = Collections.unmodifiableList(actuals);
+    }
+
+    public String getWanted() {
+        return wanted;
+    }
+
+    public List<String> getActuals() {
+        return actuals;
+    }
+
+    private static boolean isMultiLine(
+            MatchableInvocation wanted, List<Invocation> allActualInvocations) {
+        boolean isWantedMultiline = wanted.toString().contains("\n");
+        boolean isAnyActualMultiline = false;
+        for (Invocation invocation : allActualInvocations) {
+            isAnyActualMultiline |= invocation.toString().contains("\n");
+        }
+        return isWantedMultiline || isAnyActualMultiline;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/reporting/package-info.java b/mockito-core/src/main/java/org/mockito/internal/reporting/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/reporting/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/reporting/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java b/mockito-core/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
new file mode 100644
index 0000000000..6b69b823f7
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.runners;
+
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.internal.junit.DefaultTestFinishedEvent;
+import org.mockito.internal.junit.MockitoTestListener;
+import org.mockito.internal.util.Supplier;
+
+public class DefaultInternalRunner implements InternalRunner {
+
+    private final BlockJUnit4ClassRunner runner;
+
+    public DefaultInternalRunner(
+            Class<?> testClass, final Supplier<MockitoTestListener> listenerSupplier)
+            throws InitializationError {
+        runner =
+                new BlockJUnit4ClassRunner(testClass) {
+
+                    public Object target;
+                    private MockitoTestListener mockitoTestListener;
+
+                    @Override
+                    protected Statement withBefores(
+                            FrameworkMethod method, final Object target, Statement statement) {
+                        this.target = target;
+                        final Statement base = super.withBefores(method, target, statement);
+                        return new Statement() {
+                            @Override
+                            public void evaluate() throws Throwable {
+                                AutoCloseable closeable;
+                                if (mockitoTestListener == null) {
+                                    // get new test listener and add it to the framework
+                                    mockitoTestListener = listenerSupplier.get();
+                                    Mockito.framework().addListener(mockitoTestListener);
+                                    // init annotated mocks before tests
+                                    closeable = MockitoAnnotations.openMocks(target);
+                                } else {
+                                    closeable = null;
+                                }
+                                try {
+                                    base.evaluate();
+                                } finally {
+                                    if (closeable != null) {
+                                        closeable.close();
+                                    }
+                                }
+                            }
+                        };
+                    }
+
+                    public void run(final RunNotifier notifier) {
+                        RunListener listener =
+                                new RunListener() {
+                                    Throwable failure;
+
+                                    @Override
+                                    public void testFailure(Failure failure) throws Exception {
+                                        this.failure = failure.getException();
+                                    }
+
+                                    @Override
+                                    public void testFinished(Description description)
+                                            throws Exception {
+                                        try {
+                                            if (mockitoTestListener != null) {
+                                                Mockito.framework()
+                                                        .removeListener(mockitoTestListener);
+                                                mockitoTestListener.testFinished(
+                                                        new DefaultTestFinishedEvent(
+                                                                target,
+                                                                description.getMethodName(),
+                                                                failure));
+                                                mockitoTestListener = null;
+                                            }
+                                            Mockito.validateMockitoUsage();
+                                        } catch (Throwable t) {
+                                            // In order to produce clean exception to the user we
+                                            // need to fire test failure with the right description
+                                            // Otherwise JUnit framework will report failure with
+                                            // some generic test name
+                                            notifier.fireTestFailure(new Failure(description, t));
+                                        }
+                                    }
+                                };
+                        notifier.addListener(listener);
+                        super.run(notifier);
+                    }
+                };
+    }
+
+    @Override
+    public void run(final RunNotifier notifier) {
+        runner.run(notifier);
+    }
+
+    @Override
+    public Description getDescription() {
+        return runner.getDescription();
+    }
+
+    @Override
+    public void filter(Filter filter) throws NoTestsRemainException {
+        runner.filter(filter);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/runners/InternalRunner.java b/mockito-core/src/main/java/org/mockito/internal/runners/InternalRunner.java
similarity index 92%
rename from src/main/java/org/mockito/internal/runners/InternalRunner.java
rename to mockito-core/src/main/java/org/mockito/internal/runners/InternalRunner.java
index 85b2f3ccb8..bc8d66cb62 100644
--- a/src/main/java/org/mockito/internal/runners/InternalRunner.java
+++ b/mockito-core/src/main/java/org/mockito/internal/runners/InternalRunner.java
@@ -10,12 +10,11 @@
 
 /**
  * I'm using this surrogate interface to hide internal Runner implementations.
- * Surrogate cannot be used with &#064;RunWith therefore it is less likely clients will use interal runners.
+ * Surrogate cannot be used with &#064;RunWith therefore it is less likely clients will use internal runners.
  */
 public interface InternalRunner extends Filterable {
 
     void run(RunNotifier notifier);
 
     Description getDescription();
-
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/runners/RunnerFactory.java b/mockito-core/src/main/java/org/mockito/internal/runners/RunnerFactory.java
new file mode 100644
index 0000000000..68ef16cd1a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/runners/RunnerFactory.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.runners;
+
+import static org.mockito.internal.runners.util.TestMethodsFinder.hasTestMethods;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.junit.MismatchReportingTestListener;
+import org.mockito.internal.junit.MockitoTestListener;
+import org.mockito.internal.junit.NoOpTestListener;
+import org.mockito.internal.junit.StrictStubsRunnerTestListener;
+import org.mockito.internal.runners.util.RunnerProvider;
+import org.mockito.internal.util.Supplier;
+
+/**
+ * Creates instances of Mockito JUnit Runner in a safe way, e.g. detecting inadequate version of JUnit, etc.
+ */
+public class RunnerFactory {
+
+    /** Creates silent runner implementation */
+    public InternalRunner create(Class<?> klass) throws InvocationTargetException {
+        return create(
+                klass,
+                new Supplier<MockitoTestListener>() {
+                    public MockitoTestListener get() {
+                        return new NoOpTestListener();
+                    }
+                });
+    }
+
+    /**
+     * Creates strict runner implementation
+     */
+    public InternalRunner createStrict(Class<?> klass) throws InvocationTargetException {
+        return create(
+                klass,
+                new Supplier<MockitoTestListener>() {
+                    public MockitoTestListener get() {
+                        return new MismatchReportingTestListener(Plugins.getMockitoLogger());
+                    }
+                });
+    }
+
+    /**
+     * Creates strict stubs runner implementation
+     *
+     * TODO, let's try to apply Brice suggestion and use switch + Strictness
+     */
+    public InternalRunner createStrictStubs(Class<?> klass) throws InvocationTargetException {
+        return create(
+                klass,
+                new Supplier<MockitoTestListener>() {
+                    public MockitoTestListener get() {
+                        return new StrictStubsRunnerTestListener();
+                    }
+                });
+    }
+
+    /**
+     * Creates runner implementation with provided listener supplier
+     */
+    public InternalRunner create(Class<?> klass, Supplier<MockitoTestListener> listenerSupplier)
+            throws InvocationTargetException {
+        try {
+            String runnerClassName = "org.mockito.internal.runners.DefaultInternalRunner";
+            // Warning: I'm using String literal on purpose!
+            // When JUnit is not on classpath, we want the code to throw exception here so that we
+            // can catch it
+            // If we statically link the class, we will get Error when class is loaded
+            return new RunnerProvider().newInstance(runnerClassName, klass, listenerSupplier);
+        } catch (InvocationTargetException e) {
+            if (!hasTestMethods(klass)) {
+                throw new MockitoException(
+                        "\n"
+                                + "\n"
+                                + "No tests found in "
+                                + klass.getSimpleName()
+                                + "\n"
+                                + "Is the method annotated with @Test?\n"
+                                + "Is the method public?\n",
+                        e);
+            }
+            throw e;
+        } catch (Throwable t) {
+            throw new MockitoException(
+                    "\n"
+                            + "\n"
+                            + "MockitoRunner can only be used with JUnit 4.5 or higher.\n"
+                            + "You can upgrade your JUnit version or write your own Runner (please consider contributing your runner to the Mockito community).\n"
+                            + "Bear in mind that you can still enjoy all features of the framework without using runners (they are completely optional).\n"
+                            + "If you get this error despite using JUnit 4.5 or higher, then please open an issue on GitHub.\n",
+                    t);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/runners/StrictRunner.java b/mockito-core/src/main/java/org/mockito/internal/runners/StrictRunner.java
new file mode 100644
index 0000000000..b57b7c0c49
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/runners/StrictRunner.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.runners;
+
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.notification.RunNotifier;
+import org.mockito.Mockito;
+import org.mockito.internal.junit.UnnecessaryStubbingsReporter;
+import org.mockito.internal.runners.util.FailureDetector;
+
+public class StrictRunner implements InternalRunner {
+
+    private final Class<?> testClass;
+    private final InternalRunner runner;
+    private boolean testsSkipped;
+
+    /**
+     * @param runner - the runner to wrap around
+     * @param testClass - for reporting purposes
+     */
+    public StrictRunner(InternalRunner runner, Class<?> testClass) {
+        this.runner = runner;
+        this.testClass = testClass;
+        this.testsSkipped = false;
+    }
+
+    @Override
+    public void run(RunNotifier notifier) {
+        // TODO need to be able to opt in for full stack trace instead of just relying on the stack
+        // trace filter
+        UnnecessaryStubbingsReporter reporter = new UnnecessaryStubbingsReporter();
+        FailureDetector listener = new FailureDetector();
+
+        Mockito.framework().addListener(reporter);
+        try {
+            // add listener that detects test failures
+            notifier.addListener(listener);
+            runner.run(notifier);
+        } finally {
+            Mockito.framework().removeListener(reporter);
+        }
+
+        if (!testsSkipped && listener.isSuccessful()) {
+            // only report when:
+            // 1. if all tests from given test have ran (tests skipped is false)
+            //   Otherwise we would report unnecessary stubs even if the user runs just single test
+            // from the class
+            // 2. tests are successful (we don't want to add an extra failure on top of any existing
+            // failure, to avoid confusion)
+            reporter.validateUnusedStubs(testClass, notifier);
+        }
+    }
+
+    @Override
+    public Description getDescription() {
+        return runner.getDescription();
+    }
+
+    @Override
+    public void filter(Filter filter) throws NoTestsRemainException {
+        Filter recordingFilter = new RecordingFilter(filter);
+        runner.filter(recordingFilter);
+    }
+
+    private class RecordingFilter extends Filter {
+
+        private final Filter delegate;
+
+        public RecordingFilter(Filter delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public void apply(Object child) throws NoTestsRemainException {
+            delegate.apply(child);
+        }
+
+        @Override
+        public Filter intersect(Filter second) {
+            return delegate.intersect(second);
+        }
+
+        @Override
+        public boolean shouldRun(Description description) {
+            boolean result = delegate.shouldRun(description);
+            if (!result) {
+                testsSkipped = true;
+            }
+            return result;
+        }
+
+        @Override
+        public String describe() {
+            return delegate.describe();
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/runners/package-info.java b/mockito-core/src/main/java/org/mockito/internal/runners/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/runners/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/runners/package-info.java
diff --git a/src/main/java/org/mockito/internal/runners/util/FailureDetector.java b/mockito-core/src/main/java/org/mockito/internal/runners/util/FailureDetector.java
similarity index 100%
rename from src/main/java/org/mockito/internal/runners/util/FailureDetector.java
rename to mockito-core/src/main/java/org/mockito/internal/runners/util/FailureDetector.java
diff --git a/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java b/mockito-core/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
similarity index 83%
rename from src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
rename to mockito-core/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
index 3bc36fde8e..30c6c4c8c6 100644
--- a/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
+++ b/mockito-core/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
@@ -11,12 +11,14 @@
 
 public class RunnerProvider {
 
-    public InternalRunner newInstance(String runnerClassName, Object ... constructorArgs) throws Exception {
+    public InternalRunner newInstance(String runnerClassName, Object... constructorArgs)
+            throws Exception {
         Constructor<?> constructor;
         try {
             Class<?> runnerClass = Class.forName(runnerClassName);
             if (runnerClass.getConstructors().length != 1) {
-                throw new IllegalArgumentException("Expected " + runnerClassName + " to have exactly one constructor.");
+                throw new IllegalArgumentException(
+                        "Expected " + runnerClassName + " to have exactly one constructor.");
             }
             constructor = runnerClass.getConstructors()[0];
         } catch (Exception e) {
diff --git a/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java b/mockito-core/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
similarity index 93%
rename from src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
rename to mockito-core/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
index 6d9ea76380..40d71eaa6f 100644
--- a/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
+++ b/mockito-core/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
@@ -14,7 +14,7 @@ private TestMethodsFinder() {}
 
     public static boolean hasTestMethods(Class<?> klass) {
         Method[] methods = klass.getMethods();
-        for(Method m:methods) {
+        for (Method m : methods) {
             if (m.isAnnotationPresent(Test.class)) {
                 return true;
             }
diff --git a/src/main/java/org/mockito/internal/runners/util/package-info.java b/mockito-core/src/main/java/org/mockito/internal/runners/util/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/runners/util/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/runners/util/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java b/mockito-core/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
new file mode 100644
index 0000000000..6fe3dcb620
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.session;
+
+import static java.util.Collections.emptyList;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.MockitoSession;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.framework.DefaultMockitoSession;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockito.session.MockitoSessionBuilder;
+import org.mockito.session.MockitoSessionLogger;
+
+public class DefaultMockitoSessionBuilder implements MockitoSessionBuilder {
+
+    private final List<Object> testClassInstances = new ArrayList<Object>();
+    private String name;
+    private Strictness strictness;
+    private MockitoSessionLogger logger;
+
+    @Override
+    public MockitoSessionBuilder initMocks(Object testClassInstance) {
+        if (testClassInstance != null) {
+            this.testClassInstances.add(testClassInstance);
+        }
+        return this;
+    }
+
+    @Override
+    public MockitoSessionBuilder initMocks(Object... testClassInstances) {
+        if (testClassInstances != null) {
+            for (Object instance : testClassInstances) {
+                initMocks(instance);
+            }
+        }
+        return this;
+    }
+
+    @Override
+    public MockitoSessionBuilder name(String name) {
+        this.name = name;
+        return this;
+    }
+
+    @Override
+    public MockitoSessionBuilder strictness(Strictness strictness) {
+        this.strictness = strictness;
+        return this;
+    }
+
+    @Override
+    public MockitoSessionBuilder logger(MockitoSessionLogger logger) {
+        this.logger = logger;
+        return this;
+    }
+
+    @Override
+    public MockitoSession startMocking() {
+        // Configure default values
+        List<Object> effectiveTestClassInstances;
+        String effectiveName;
+        if (testClassInstances.isEmpty()) {
+            effectiveTestClassInstances = emptyList();
+            effectiveName = this.name == null ? "<Unnamed Session>" : this.name;
+        } else {
+            effectiveTestClassInstances = new ArrayList<>(testClassInstances);
+            Object lastTestClassInstance = testClassInstances.get(testClassInstances.size() - 1);
+            effectiveName =
+                    this.name == null ? lastTestClassInstance.getClass().getName() : this.name;
+        }
+        Strictness effectiveStrictness =
+                this.strictness == null ? Strictness.STRICT_STUBS : this.strictness;
+        MockitoLogger logger =
+                this.logger == null
+                        ? Plugins.getMockitoLogger()
+                        : new MockitoLoggerAdapter(this.logger);
+        return new DefaultMockitoSession(
+                effectiveTestClassInstances, effectiveName, effectiveStrictness, logger);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java b/mockito-core/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
similarity index 100%
rename from src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
rename to mockito-core/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
diff --git a/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java b/mockito-core/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
similarity index 100%
rename from src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
rename to mockito-core/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
diff --git a/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
similarity index 85%
rename from src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
index 73dab853d5..7a59cf1571 100644
--- a/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
@@ -7,18 +7,17 @@
 import static org.mockito.internal.exceptions.Reporter.notAnException;
 import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
 
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.internal.stubbing.answers.CallsRealMethods;
 import org.mockito.internal.stubbing.answers.Returns;
 import org.mockito.internal.stubbing.answers.ThrowsException;
+import org.mockito.internal.stubbing.answers.ThrowsExceptionForClassType;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.OngoingStubbing;
 
 public abstract class BaseStubbing<T> implements OngoingStubbing<T> {
 
-
-    // Keep strong ref to mock preventing premature garbage collection when using 'One-liner stubs'. See #1541.
+    // Keep strong ref to mock preventing premature garbage collection when using 'One-liner stubs'.
+    // See #1541.
     private final Object strongMockRef;
 
     BaseStubbing(Object mock) {
@@ -40,7 +39,8 @@ public OngoingStubbing<T> thenReturn(T value, T... values) {
         OngoingStubbing<T> stubbing = thenReturn(value);
         if (values == null) {
             // 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)
+            // 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) {
@@ -75,12 +75,12 @@ public OngoingStubbing<T> thenThrow(Class<? extends Throwable> throwableType) {
             mockingProgress().reset();
             throw notAnException();
         }
-        Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(null);
-        return thenThrow(instantiator.newInstance(throwableType));
+        return thenAnswer(new ThrowsExceptionForClassType(throwableType));
     }
 
     @Override
-    public OngoingStubbing<T> thenThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+    public OngoingStubbing<T> thenThrow(
+            Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
         if (nextToBeThrown == null) {
             return thenThrow((Class<Throwable>) null);
         }
diff --git a/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
similarity index 98%
rename from src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
index 32ef8eedfd..e7b269f462 100644
--- a/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
@@ -16,9 +16,9 @@ public class ConsecutiveStubbing<T> extends BaseStubbing<T> {
         this.invocationContainer = invocationContainer;
     }
 
+    @Override
     public OngoingStubbing<T> thenAnswer(Answer<?> answer) {
         invocationContainer.addConsecutiveAnswer(answer);
         return this;
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
similarity index 84%
rename from src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
index 0f3fe073a1..6986c20e3e 100644
--- a/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
@@ -13,7 +13,7 @@
 
 public class DefaultLenientStubber implements LenientStubber {
 
-    private final static MockitoCore MOCKITO_CORE = new MockitoCore();
+    private static final MockitoCore MOCKITO_CORE = new MockitoCore();
 
     @Override
     public Stubber doThrow(Throwable... toBeThrown) {
@@ -26,7 +26,8 @@ public Stubber doThrow(Class<? extends Throwable> toBeThrown) {
     }
 
     @Override
-    public Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+    public Stubber doThrow(
+            Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
         return stubber().doThrow(toBeThrown, nextToBeThrown);
     }
 
@@ -57,7 +58,8 @@ public Stubber doCallRealMethod() {
 
     @Override
     public <T> OngoingStubbing<T> when(T methodCall) {
-        OngoingStubbingImpl<T> ongoingStubbing = (OngoingStubbingImpl) MOCKITO_CORE.when(methodCall);
+        OngoingStubbingImpl<T> ongoingStubbing =
+                (OngoingStubbingImpl) MOCKITO_CORE.when(methodCall);
         ongoingStubbing.setStrictness(Strictness.LENIENT);
         return ongoingStubbing;
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
similarity index 89%
rename from src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
index e2ef7aabd5..c15fc025b4 100644
--- a/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
@@ -16,7 +16,7 @@
  */
 class DoAnswerStyleStubbing implements Serializable {
 
-    private final List<Answer<?>> answers = new ArrayList<Answer<?>>();
+    private final List<Answer<?>> answers = new ArrayList<>();
     private Strictness stubbingStrictness;
 
     void setAnswers(List<Answer<?>> answers, Strictness stubbingStrictness) {
@@ -25,7 +25,7 @@ void setAnswers(List<Answer<?>> answers, Strictness stubbingStrictness) {
     }
 
     boolean isSet() {
-        return answers.isEmpty();
+        return answers.size() > 0;
     }
 
     void clear() {
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
new file mode 100644
index 0000000000..56de810dba
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing;
+
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.StubInfoImpl;
+import org.mockito.internal.verification.DefaultRegisteredInvocations;
+import org.mockito.internal.verification.RegisteredInvocations;
+import org.mockito.internal.verification.SingleRegisteredInvocation;
+import org.mockito.invocation.Invocation;
+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;
+
+public class InvocationContainerImpl implements InvocationContainer, Serializable {
+
+    private static final long serialVersionUID = -5334301962749537177L;
+    private final LinkedList<StubbedInvocationMatcher> stubbed = new LinkedList<>();
+    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.getStrictness();
+        this.doAnswerStyleStubbing = new DoAnswerStyleStubbing();
+    }
+
+    public void setInvocationForPotentialStubbing(MatchableInvocation invocation) {
+        registeredInvocations.add(invocation.getInvocation());
+        this.invocationForStubbing = invocation;
+    }
+
+    public void resetInvocationForPotentialStubbing(MatchableInvocation invocationMatcher) {
+        this.invocationForStubbing = invocationMatcher;
+    }
+
+    public void addAnswer(Answer<?> answer, Strictness stubbingStrictness) {
+        registeredInvocations.removeLast();
+        addAnswer(answer, false, stubbingStrictness);
+    }
+
+    /** Adds new stubbed answer and returns the invocation matcher the answer was added to. */
+    public StubbedInvocationMatcher addAnswer(
+            Answer<?> answer, boolean isConsecutive, Strictness stubbingStrictness) {
+        Invocation invocation = invocationForStubbing.getInvocation();
+        mockingProgress().stubbingCompleted();
+        if (answer instanceof ValidableAnswer) {
+            ((ValidableAnswer) answer).validateFor(invocation);
+        }
+
+        synchronized (stubbed) {
+            if (isConsecutive) {
+                stubbed.getFirst().addAnswer(answer);
+            } else {
+                Strictness effectiveStrictness =
+                        stubbingStrictness != null ? stubbingStrictness : this.mockStrictness;
+                stubbed.addFirst(
+                        new StubbedInvocationMatcher(
+                                answer, invocationForStubbing, effectiveStrictness));
+            }
+            return stubbed.getFirst();
+        }
+    }
+
+    public void addConsecutiveAnswer(Answer<?> answer) {
+        addAnswer(answer, true, null);
+    }
+
+    Object answerTo(Invocation invocation) throws Throwable {
+        StubbedInvocationMatcher matcher = findAnswerFor(invocation);
+        if (matcher == null) {
+            throw new MockitoException(
+                    "Unable to find answer for: "
+                            + invocation
+                            + "Did you configure a stubbing for this method?");
+        }
+        return matcher.answer(invocation);
+    }
+
+    public StubbedInvocationMatcher findAnswerFor(Invocation invocation) {
+        synchronized (stubbed) {
+            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;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Sets the answers declared with 'doAnswer' style.
+     */
+    public void setAnswersForStubbing(List<Answer<?>> answers, Strictness strictness) {
+        doAnswerStyleStubbing.setAnswers(answers, strictness);
+    }
+
+    public boolean hasAnswersForStubbing() {
+        return doAnswerStyleStubbing.isSet();
+    }
+
+    public boolean hasInvocationForPotentialStubbing() {
+        return !registeredInvocations.isEmpty();
+    }
+
+    public void setMethodForStubbing(MatchableInvocation invocation) {
+        invocationForStubbing = invocation;
+        assert hasAnswersForStubbing();
+        for (int i = 0; i < doAnswerStyleStubbing.getAnswers().size(); i++) {
+            addAnswer(
+                    doAnswerStyleStubbing.getAnswers().get(i),
+                    i != 0,
+                    doAnswerStyleStubbing.getStubbingStrictness());
+        }
+        doAnswerStyleStubbing.clear();
+    }
+
+    @Override
+    public String toString() {
+        return "invocationForStubbing: " + invocationForStubbing;
+    }
+
+    public List<Invocation> getInvocations() {
+        return registeredInvocations.getAll();
+    }
+
+    public void clearInvocations() {
+        registeredInvocations.clear();
+    }
+
+    /**
+     * Stubbings in ascending order, most recent last
+     */
+    public Collection<Stubbing> getStubbingsAscending() {
+        List<Stubbing> result;
+        synchronized (stubbed) {
+            result = new LinkedList<>(stubbed);
+        }
+        Collections.reverse(result);
+        return result;
+    }
+
+    public Object invokedMock() {
+        return invocationForStubbing.getInvocation().getMock();
+    }
+
+    private RegisteredInvocations createRegisteredInvocations(
+            MockCreationSettings<?> mockSettings) {
+        return mockSettings.isStubOnly()
+                ? new SingleRegisteredInvocation()
+                : new DefaultRegisteredInvocations();
+    }
+
+    public Answer<?> findStubbedAnswer() {
+        synchronized (stubbed) {
+            for (StubbedInvocationMatcher s : stubbed) {
+                if (invocationForStubbing.matches(s.getInvocation())) {
+                    return s;
+                }
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
similarity index 92%
rename from src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
index 3de23b23ff..a5bb0869f0 100644
--- a/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
@@ -25,7 +25,7 @@ public OngoingStubbingImpl(InvocationContainerImpl invocationContainer) {
 
     @Override
     public OngoingStubbing<T> thenAnswer(Answer<?> answer) {
-        if(!invocationContainer.hasInvocationForPotentialStubbing()) {
+        if (!invocationContainer.hasInvocationForPotentialStubbing()) {
             throw incorrectUseOfApi();
         }
 
@@ -34,7 +34,7 @@ public OngoingStubbing<T> thenAnswer(Answer<?> answer) {
     }
 
     public List<Invocation> getRegisteredInvocations() {
-        //TODO interface for tests
+        // TODO interface for tests
         return invocationContainer.getInvocations();
     }
 
diff --git a/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
similarity index 79%
rename from src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
index 6009e9340e..c8e7e44400 100644
--- a/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
@@ -11,7 +11,7 @@
 /**
  * Helps determining the actual strictness given that it can be configured in multiple ways (at mock, at stubbing, in rule)
  */
-public class StrictnessSelector {
+public final class StrictnessSelector {
 
     /**
      * Determines the actual strictness in the following importance order:
@@ -25,15 +25,18 @@ public class StrictnessSelector {
      *
      * @return actual strictness, can be null.
      */
-    public static Strictness determineStrictness(Stubbing stubbing, MockCreationSettings mockSettings, Strictness testLevelStrictness) {
+    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;
+        if (mockSettings.getStrictness() != null) {
+            return mockSettings.getStrictness();
         }
 
         return testLevelStrictness;
     }
+
+    private StrictnessSelector() {}
 }
diff --git a/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
similarity index 78%
rename from src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
index 0b1e4f4ba9..a4ab2fd9a5 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
@@ -20,20 +20,23 @@
 public class StubbedInvocationMatcher extends InvocationMatcher implements Serializable, Stubbing {
 
     private static final long serialVersionUID = 4919105134123672727L;
-    private final Queue<Answer> answers = new ConcurrentLinkedQueue<Answer>();
+    private final Queue<Answer> answers = new ConcurrentLinkedQueue<>();
     private final Strictness strictness;
+    private final Object usedAtLock = new Object[0];
     private DescribedInvocation usedAt;
 
-    public StubbedInvocationMatcher(Answer answer, MatchableInvocation invocation, Strictness strictness) {
+    public StubbedInvocationMatcher(
+            Answer answer, MatchableInvocation invocation, Strictness strictness) {
         super(invocation.getInvocation(), invocation.getMatchers());
         this.strictness = strictness;
         this.answers.add(answer);
     }
 
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
-        //see ThreadsShareGenerouslyStubbedMockTest
+        // see ThreadsShareGenerouslyStubbedMockTest
         Answer a;
-        synchronized(answers) {
+        synchronized (answers) {
             a = answers.size() == 1 ? answers.peek() : answers.poll();
         }
         return a.answer(invocation);
@@ -43,16 +46,17 @@ public void addAnswer(Answer answer) {
         answers.add(answer);
     }
 
-    /**
-     * Marks the stub as used by the passed invocation. Passing null marks the stub as unused.
-     * @param usedAt The invocation which uses this stub
-     */
     public void markStubUsed(DescribedInvocation usedAt) {
-        this.usedAt = usedAt;
+        synchronized (usedAtLock) {
+            this.usedAt = usedAt;
+        }
     }
 
+    @Override
     public boolean wasUsed() {
-        return usedAt != null;
+        synchronized (usedAtLock) {
+            return usedAt != null;
+        }
     }
 
     @Override
diff --git a/src/main/java/org/mockito/internal/stubbing/StubberImpl.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
similarity index 80%
rename from src/main/java/org/mockito/internal/stubbing/StubberImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
index d707cf8b3a..a357de641c 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
@@ -14,10 +14,10 @@
 import java.util.LinkedList;
 import java.util.List;
 
-import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.internal.stubbing.answers.CallsRealMethods;
 import org.mockito.internal.stubbing.answers.Returns;
 import org.mockito.internal.stubbing.answers.ThrowsException;
+import org.mockito.internal.stubbing.answers.ThrowsExceptionForClassType;
 import org.mockito.internal.util.MockUtil;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -31,7 +31,7 @@ public StubberImpl(Strictness strictness) {
         this.strictness = strictness;
     }
 
-    private final List<Answer<?>> answers = new LinkedList<Answer<?>>();
+    private final List<Answer<?>> answers = new LinkedList<>();
 
     @Override
     public <T> T when(T mock) {
@@ -89,22 +89,12 @@ public Stubber doThrow(Class<? extends Throwable> toBeThrown) {
             mockingProgress().reset();
             throw notAnException();
         }
-        Throwable e = null;
-        try {
-            e = Plugins.getInstantiatorProvider().getInstantiator(null).newInstance(toBeThrown);
-        } finally {
-            if (e == null) {
-                //this means that an exception or error was thrown when trying to create new instance
-                //we don't want 'catch' statement here because we want the exception to be thrown to the user
-                //however, we do want to clean up state (e.g. "stubbing started").
-                mockingProgress().reset();
-            }
-        }
-        return doThrow(e);
+        return doAnswer(new ThrowsExceptionForClassType(toBeThrown));
     }
 
     @Override
-    public Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+    public Stubber doThrow(
+            Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
         Stubber stubber = doThrow(toBeThrown);
 
         if (nextToBeThrown == null) {
@@ -116,7 +106,6 @@ public Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Th
             stubber = stubber.doThrow(next);
         }
         return stubber;
-
     }
 
     @Override
diff --git a/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
similarity index 97%
rename from src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
index 1608ccb799..4d8e678c7b 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
@@ -16,6 +16,7 @@ public class StubbingComparator implements Comparator<Stubbing> {
 
     private final InvocationComparator invocationComparator = new InvocationComparator();
 
+    @Override
     public int compare(Stubbing o1, Stubbing o2) {
         return invocationComparator.compare(o1.getInvocation(), o2.getInvocation());
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
similarity index 77%
rename from src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
index 6a96592453..38247a5d86 100644
--- a/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
@@ -7,10 +7,8 @@
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Stubbing;
 
-/**
- * Helps determining if stubbing should be reported as unused
- */
-public class UnusedStubbingReporting {
+/** Helps determining if stubbing should be reported as unused */
+public final class UnusedStubbingReporting {
 
     /**
      * Decides if the stubbing should be reported as unused.
@@ -19,4 +17,6 @@ public class UnusedStubbingReporting {
     public static boolean shouldBeReported(Stubbing stubbing) {
         return !stubbing.wasUsed() && stubbing.getStrictness() != Strictness.LENIENT;
     }
+
+    private UnusedStubbingReporting() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AbstractThrowsException.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AbstractThrowsException.java
new file mode 100644
index 0000000000..6bcca9dc8a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AbstractThrowsException.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
+import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
+
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.ValidableAnswer;
+
+public abstract class AbstractThrowsException implements Answer<Object>, ValidableAnswer {
+
+    private final ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
+
+    protected abstract Throwable getThrowable();
+
+    @Override
+    public Object answer(InvocationOnMock invocation) throws Throwable {
+        Throwable throwable = getThrowable();
+        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);
+        throw t;
+    }
+
+    @Override
+    public void validateFor(InvocationOnMock invocation) {
+        Throwable throwable = getThrowable();
+        if (throwable == null) {
+            throw cannotStubWithNullThrowable();
+        }
+
+        if (throwable instanceof RuntimeException || throwable instanceof Error) {
+            return;
+        }
+
+        if (!new InvocationInfo(invocation).isValidException(throwable)) {
+            throw checkedExceptionInvalid(throwable);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
new file mode 100644
index 0000000000..d9b3271d91
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
@@ -0,0 +1,353 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.Answer1;
+import org.mockito.stubbing.Answer2;
+import org.mockito.stubbing.Answer3;
+import org.mockito.stubbing.Answer4;
+import org.mockito.stubbing.Answer5;
+import org.mockito.stubbing.Answer6;
+import org.mockito.stubbing.VoidAnswer1;
+import org.mockito.stubbing.VoidAnswer2;
+import org.mockito.stubbing.VoidAnswer3;
+import org.mockito.stubbing.VoidAnswer4;
+import org.mockito.stubbing.VoidAnswer5;
+import org.mockito.stubbing.VoidAnswer6;
+
+import java.lang.reflect.Method;
+
+/**
+ * Functional interfaces to make it easy to implement answers in Java 8
+ *
+ * @since 2.1.0
+ */
+public class AnswerFunctionalInterfaces {
+    /**
+     * Hide constructor to avoid instantiation of class with only static methods
+     */
+    private AnswerFunctionalInterfaces() {}
+
+    /**
+     * Construct an answer from a two parameter answer interface
+     * @param answer answer interface
+     * @param <T> return type
+     * @param <A> input parameter 1 type
+     * @return a new answer object
+     */
+    public static <T, A> Answer<T> toAnswer(final Answer1<T, A> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 1);
+        return new Answer<T>() {
+            @Override
+            public T answer(InvocationOnMock invocation) throws Throwable {
+                return answer.answer(lastParameter(invocation, answerMethod, 0));
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a two parameter answer interface
+     * @param answer answer interface
+     * @param <A> input parameter 1 type
+     * @return a new answer object
+     */
+    public static <A> Answer<Void> toAnswer(final VoidAnswer1<A> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 1);
+        return new Answer<Void>() {
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                answer.answer(lastParameter(invocation, answerMethod, 0));
+                return null;
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a two parameter answer interface
+     * @param answer answer interface
+     * @param <T> return type
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @return a new answer object
+     */
+    public static <T, A, B> Answer<T> toAnswer(final Answer2<T, A, B> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 2);
+        return new Answer<T>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public T answer(InvocationOnMock invocation) throws Throwable {
+                return answer.answer(
+                        (A) invocation.getArgument(0), lastParameter(invocation, answerMethod, 1));
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a two parameter answer interface
+     * @param answer answer interface
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @return a new answer object
+     */
+    public static <A, B> Answer<Void> toAnswer(final VoidAnswer2<A, B> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 2);
+        return new Answer<Void>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                answer.answer(
+                        (A) invocation.getArgument(0), lastParameter(invocation, answerMethod, 1));
+                return null;
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a three parameter answer interface
+     * @param answer answer interface
+     * @param <T> return type
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @return a new answer object
+     */
+    public static <T, A, B, C> Answer<T> toAnswer(final Answer3<T, A, B, C> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 3);
+        return new Answer<T>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public T answer(InvocationOnMock invocation) throws Throwable {
+                return answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        lastParameter(invocation, answerMethod, 2));
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a three parameter answer interface
+     * @param answer answer interface
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @return a new answer object
+     */
+    public static <A, B, C> Answer<Void> toAnswer(final VoidAnswer3<A, B, C> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 3);
+        return new Answer<Void>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        lastParameter(invocation, answerMethod, 2));
+                return null;
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a four parameter answer interface
+     * @param answer answer interface
+     * @param <T> return type
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @param <D> input parameter 4 type
+     * @return a new answer object
+     */
+    public static <T, A, B, C, D> Answer<T> toAnswer(final Answer4<T, A, B, C, D> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 4);
+        return new Answer<T>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public T answer(InvocationOnMock invocation) throws Throwable {
+                return answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        (C) invocation.getArgument(2),
+                        lastParameter(invocation, answerMethod, 3));
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a four parameter answer interface
+     * @param answer answer interface
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @param <D> input parameter 4 type
+     * @return a new answer object
+     */
+    public static <A, B, C, D> Answer<Void> toAnswer(final VoidAnswer4<A, B, C, D> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 4);
+        return new Answer<Void>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        (C) invocation.getArgument(2),
+                        lastParameter(invocation, answerMethod, 3));
+                return null;
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a five parameter answer interface
+     * @param answer answer interface
+     * @param <T> return type
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @param <D> input parameter 4 type
+     * @param <E> input parameter 5 type
+     * @return a new answer object
+     */
+    public static <T, A, B, C, D, E> Answer<T> toAnswer(final Answer5<T, A, B, C, D, E> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 5);
+        return new Answer<T>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public T answer(InvocationOnMock invocation) throws Throwable {
+                return answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        (C) invocation.getArgument(2),
+                        (D) invocation.getArgument(3),
+                        lastParameter(invocation, answerMethod, 4));
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a five parameter answer interface
+     * @param answer answer interface
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @param <D> input parameter 4 type
+     * @param <E> input parameter 5 type
+     * @return a new answer object
+     */
+    public static <A, B, C, D, E> Answer<Void> toAnswer(final VoidAnswer5<A, B, C, D, E> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 5);
+        return new Answer<Void>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        (C) invocation.getArgument(2),
+                        (D) invocation.getArgument(3),
+                        lastParameter(invocation, answerMethod, 4));
+                return null;
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a six parameter answer interface
+     *
+     * @param answer answer interface
+     * @param <T> return type
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @param <D> input parameter 4 type
+     * @param <E> input parameter 5 type
+     * @param <F> input parameter 6 type
+     * @return a new answer object
+     */
+    public static <T, A, B, C, D, E, F> Answer<T> toAnswer(
+            final Answer6<T, A, B, C, D, E, F> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 6);
+        return new Answer<T>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public T answer(InvocationOnMock invocation) throws Throwable {
+                return answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        (C) invocation.getArgument(2),
+                        (D) invocation.getArgument(3),
+                        (E) invocation.getArgument(4),
+                        lastParameter(invocation, answerMethod, 5));
+            }
+        };
+    }
+
+    /**
+     * Construct an answer from a five parameter answer interface
+     *
+     * @param answer answer interface
+     * @param <A> input parameter 1 type
+     * @param <B> input parameter 2 type
+     * @param <C> input parameter 3 type
+     * @param <D> input parameter 4 type
+     * @param <E> input parameter 5 type
+     * @param <F> input parameter 6 type
+     * @return a new answer object
+     */
+    public static <A, B, C, D, E, F> Answer<Void> toAnswer(
+            final VoidAnswer6<A, B, C, D, E, F> answer) {
+        final Method answerMethod = findAnswerMethod(answer.getClass(), 6);
+        return new Answer<Void>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                answer.answer(
+                        (A) invocation.getArgument(0),
+                        (B) invocation.getArgument(1),
+                        (C) invocation.getArgument(2),
+                        (D) invocation.getArgument(3),
+                        (E) invocation.getArgument(4),
+                        lastParameter(invocation, answerMethod, 5));
+                return null;
+            }
+        };
+    }
+
+    private static Method findAnswerMethod(final Class<?> type, final int numberOfParameters) {
+        for (final Method m : type.getDeclaredMethods()) {
+            if (!m.isBridge()
+                    && m.getName().equals("answer")
+                    && m.getParameterTypes().length == numberOfParameters) {
+                return m;
+            }
+        }
+        throw new IllegalStateException(
+                "Failed to find answer() method on the supplied class: "
+                        + type.getName()
+                        + ", with the supplied number of parameters: "
+                        + numberOfParameters);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <A> A lastParameter(
+            InvocationOnMock invocation, Method answerMethod, int argumentIndex) {
+        final Method invocationMethod = invocation.getMethod();
+
+        if (invocationMethod.isVarArgs()
+                && invocationMethod.getParameterTypes().length == (argumentIndex + 1)) {
+            final Class<?> invocationRawArgType =
+                    invocationMethod.getParameterTypes()[argumentIndex];
+            final Class<?> answerRawArgType = answerMethod.getParameterTypes()[argumentIndex];
+            if (answerRawArgType.isAssignableFrom(invocationRawArgType)) {
+                return (A) invocation.getRawArguments()[argumentIndex];
+            }
+        }
+
+        return invocation.getArgument(argumentIndex);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
similarity index 93%
rename from src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
index 44f42240a0..f0f23d5c57 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
@@ -4,9 +4,9 @@
  */
 package org.mockito.internal.stubbing.answers;
 
-import java.io.Serializable;
-import java.util.concurrent.TimeUnit;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
+import java.io.Serializable;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.ValidableAnswer;
@@ -33,7 +33,7 @@ public AnswersWithDelay(final long sleepyTime, final Answer<Object> answer) {
 
     @Override
     public Object answer(final InvocationOnMock invocation) throws Throwable {
-        TimeUnit.MILLISECONDS.sleep(sleepyTime);
+        MILLISECONDS.sleep(sleepyTime);
         return answer.answer(invocation);
     }
 
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
similarity index 87%
rename from src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
index b1c9016085..ae16991af8 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
@@ -17,10 +17,10 @@
 /**
  * Optional Answer that adds partial mocking support
  * <p>
- * {@link Answer} can be used to define the return values of unstubbed invocations.
+ * {@link Answer} can be used to define the return values of un-stubbed invocations.
  * <p>
  * This implementation can be helpful when working with legacy code.
- * When this implementation is used, unstubbed methods will delegate to the real implementation.
+ * When this implementation is used, un-stubbed methods will delegate to the real implementation.
  * This is a way to create a partial mock object that calls real methods by default.
  * <p>
  * As usual you are going to read <b>the partial mock warning</b>:
@@ -31,12 +31,13 @@
  * <p>
  * However, there are rare cases when partial mocks come handy:
  * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
- * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+ * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
  * <p>
  */
 public class CallsRealMethods implements Answer<Object>, ValidableAnswer, Serializable {
     private static final long serialVersionUID = 9057165148930624087L;
 
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
         if (Modifier.isAbstract(invocation.getMethod().getModifiers())) {
             return RETURNS_DEFAULTS.answer(invocation);
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
similarity index 81%
rename from src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
index 32c4c04757..0f0c15b91d 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
@@ -13,9 +13,10 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-//TODO this needs documentation and further analysis - what if someone changes the answer?
-//we might think about implementing it straight on MockSettings
+// TODO this needs documentation and further analysis - what if someone changes the answer?
+// we might think about implementing it straight on MockSettings
 public class ClonesArguments implements Answer<Object> {
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
         Object[] arguments = invocation.getArguments();
         for (int i = 0; i < arguments.length; i++) {
@@ -24,12 +25,13 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
                 if (from.getClass().isArray()) {
                     int len = Array.getLength(from);
                     Object newInstance = Array.newInstance(from.getClass().getComponentType(), len);
-                    for (int j=0; j<len; ++j) {
+                    for (int j = 0; j < len; ++j) {
                         Array.set(newInstance, j, Array.get(from, j));
                     }
                     arguments[i] = newInstance;
                 } else {
-                    Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(null);
+                    Instantiator instantiator =
+                            Plugins.getInstantiatorProvider().getInstantiator(null);
                     Object newInstance = instantiator.newInstance(from.getClass());
                     new LenientCopyTool().copyToRealObject(from, newInstance);
                     arguments[i] = newInstance;
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
similarity index 93%
rename from src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
index b3e4aea24c..b6a384ea18 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
@@ -9,7 +9,8 @@
 import org.mockito.invocation.InvocationOnMock;
 
 public abstract class DefaultAnswerValidator {
-    public static void validateReturnValueFor(InvocationOnMock invocation, Object returnedValue) throws Throwable {
+    public static void validateReturnValueFor(InvocationOnMock invocation, Object returnedValue)
+            throws Throwable {
         InvocationInfo invocationInfo = new InvocationInfo(invocation);
         if (returnedValue != null && !invocationInfo.isValidReturnType(returnedValue.getClass())) {
             throw wrongTypeReturnedByDefaultAnswer(
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
similarity index 90%
rename from src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
index 31c3658293..d044e12a68 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
@@ -20,12 +20,12 @@ public class DoesNothing implements Answer<Object>, ValidableAnswer, Serializabl
 
     private DoesNothing() {}
 
-    public static DoesNothing doesNothing(){
+    public static DoesNothing doesNothing() {
         return SINGLETON;
     }
 
     @Override
-    public Object answer(InvocationOnMock invocation){
+    public Object answer(InvocationOnMock invocation) {
         return null;
     }
 
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
new file mode 100644
index 0000000000..c159906af0
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.mockito.internal.invocation.AbstractAwareMethod;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.Primitives;
+import org.mockito.internal.util.reflection.GenericMetadataSupport;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.mock.MockCreationSettings;
+
+public class InvocationInfo implements AbstractAwareMethod {
+
+    private final Method method;
+    private final InvocationOnMock invocation;
+
+    public InvocationInfo(InvocationOnMock theInvocation) {
+        this.method = theInvocation.getMethod();
+        this.invocation = theInvocation;
+    }
+
+    public boolean isValidException(final Throwable throwable) {
+        if (isValidException(method, throwable)) {
+            return true;
+        }
+
+        return isValidExceptionForParents(method.getDeclaringClass(), throwable);
+    }
+
+    private boolean isValidExceptionForParents(final Class<?> parent, final Throwable throwable) {
+        final List<Class<?>> ancestors = new ArrayList<>(Arrays.asList(parent.getInterfaces()));
+
+        if (parent.getSuperclass() != null) {
+            ancestors.add(parent.getSuperclass());
+        }
+
+        final boolean validException =
+                ancestors.stream()
+                        .anyMatch(ancestor -> isValidExceptionForClass(ancestor, throwable));
+
+        if (validException) {
+            return true;
+        }
+
+        return ancestors.stream()
+                .anyMatch(ancestor -> isValidExceptionForParents(ancestor, throwable));
+    }
+
+    private boolean isValidExceptionForClass(final Class<?> parent, final Throwable throwable) {
+        try {
+            final Method parentMethod =
+                    parent.getMethod(this.method.getName(), this.method.getParameterTypes());
+            return isValidException(parentMethod, throwable);
+        } catch (NoSuchMethodException e) {
+            // ignore interfaces that doesn't have such a method
+            return false;
+        }
+    }
+
+    private boolean isValidException(final Method method, final Throwable throwable) {
+        final Class<?>[] exceptions = method.getExceptionTypes();
+        final Class<?> throwableClass = throwable.getClass();
+        for (final Class<?> exception : exceptions) {
+            if (exception.isAssignableFrom(throwableClass)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean isValidReturnType(Class<?> clazz) {
+        if (method.getReturnType().isPrimitive() || clazz.isPrimitive()) {
+            return Primitives.primitiveTypeOf(clazz)
+                    == Primitives.primitiveTypeOf(method.getReturnType());
+        } else {
+            return method.getReturnType().isAssignableFrom(clazz);
+        }
+    }
+
+    /**
+     * Returns {@code true} is the return type is {@link Void} or represents the pseudo-type to the keyword {@code void}.
+     * E.g:  {@code void foo()} or {@code Void bar()}
+     */
+    public boolean isVoid() {
+        final MockCreationSettings mockSettings =
+                MockUtil.getMockHandler(invocation.getMock()).getMockSettings();
+        Class<?> returnType =
+                GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock())
+                        .resolveGenericReturnType(this.method)
+                        .rawType();
+        return returnType == Void.TYPE || returnType == Void.class;
+    }
+
+    public String printMethodReturnType() {
+        return method.getReturnType().getSimpleName();
+    }
+
+    public String getMethodName() {
+        return method.getName();
+    }
+
+    public boolean returnsPrimitive() {
+        return method.getReturnType().isPrimitive();
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+    public boolean isDeclaredOnInterface() {
+        return method.getDeclaringClass().isInterface();
+    }
+
+    @Override
+    public boolean isAbstract() {
+        return (method.getModifiers() & Modifier.ABSTRACT) != 0;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/Returns.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
new file mode 100644
index 0000000000..d4d97cbacd
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.mockito.internal.exceptions.Reporter.cannotStubVoidMethodWithAReturnValue;
+import static org.mockito.internal.exceptions.Reporter.wrongTypeOfReturnValue;
+
+import java.io.Serializable;
+
+import org.mockito.internal.util.KotlinInlineClassUtil;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.ValidableAnswer;
+
+public class Returns implements Answer<Object>, ValidableAnswer, Serializable {
+
+    private static final long serialVersionUID = -6245608253574215396L;
+    private final Object value;
+
+    public Returns(Object value) {
+        this.value = value;
+    }
+
+    @Override
+    public Object answer(InvocationOnMock invocation) throws Throwable {
+        return KotlinInlineClassUtil.unboxUnderlyingValueIfNeeded(invocation, value);
+    }
+
+    @Override
+    public void validateFor(InvocationOnMock invocation) {
+        InvocationInfo invocationInfo = new InvocationInfo(invocation);
+        if (invocationInfo.isVoid()) {
+            throw cannotStubVoidMethodWithAReturnValue(invocationInfo.getMethodName());
+        }
+
+        if (returnsNull() && invocationInfo.returnsPrimitive()) {
+            throw wrongTypeOfReturnValue(
+                    invocationInfo.printMethodReturnType(), "null", invocationInfo.getMethodName());
+        }
+
+        if (!returnsNull()
+                && !invocationInfo.isValidReturnType(returnType())
+                && !KotlinInlineClassUtil.isInlineClassWithAssignableUnderlyingType(
+                        returnType(), invocationInfo.getMethod().getReturnType())) {
+            throw wrongTypeOfReturnValue(
+                    invocationInfo.printMethodReturnType(),
+                    printReturnType(),
+                    invocationInfo.getMethodName());
+        }
+    }
+
+    private String printReturnType() {
+        return value.getClass().getSimpleName();
+    }
+
+    private Class<?> returnType() {
+        return value.getClass();
+    }
+
+    private boolean returnsNull() {
+        return value == null;
+    }
+
+    @Override
+    public String toString() {
+        return "Returns: " + value;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
new file mode 100644
index 0000000000..c3cabc1420
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.mockito.internal.exceptions.Reporter.invalidArgumentPositionRangeAtInvocationTime;
+import static org.mockito.internal.exceptions.Reporter.invalidArgumentRangeAtIdentityAnswerCreationTime;
+import static org.mockito.internal.exceptions.Reporter.wrongTypeOfArgumentToReturn;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.ValidableAnswer;
+
+/**
+ * Returns the passed parameter identity at specified index.
+ * <p>
+ * <p>
+ * The <code>argumentIndex</code> represents the index in the argument array of the invocation.
+ * </p>
+ * <p>
+ * If this number equals -1 then the last argument is returned.
+ * </p>
+ *
+ * @see org.mockito.AdditionalAnswers
+ * @since 1.9.5
+ */
+public class ReturnsArgumentAt implements Answer<Object>, ValidableAnswer, Serializable {
+
+    private static final long serialVersionUID = -589315085166295101L;
+
+    public static final int LAST_ARGUMENT = -1;
+
+    private final int wantedArgumentPosition;
+
+    /**
+     * Build the identity answer to return the argument at the given position in the argument array.
+     *
+     * @param wantedArgumentPosition
+     *            The position of the argument identity to return in the invocation. Using <code>-1</code> indicates the last argument ({@link #LAST_ARGUMENT}).
+     */
+    public ReturnsArgumentAt(int wantedArgumentPosition) {
+        if (wantedArgumentPosition != LAST_ARGUMENT && wantedArgumentPosition < 0) {
+            throw invalidArgumentRangeAtIdentityAnswerCreationTime();
+        }
+        this.wantedArgumentPosition = wantedArgumentPosition;
+    }
+
+    @Override
+    public Object answer(InvocationOnMock invocation) throws Throwable {
+        if (wantedArgIndexIsVarargAndSameTypeAsReturnType(invocation)) {
+            // answer raw vararg array argument
+            return invocation.getRawArguments()[invocation.getRawArguments().length - 1];
+        }
+
+        int argumentPosition = inferWantedArgumentPosition(invocation);
+        validateIndexWithinInvocationRange(invocation, argumentPosition);
+
+        // answer expanded argument at wanted position
+        return invocation.getArgument(argumentPosition);
+    }
+
+    @Override
+    public void validateFor(InvocationOnMock invocationOnMock) {
+        Invocation invocation = (Invocation) invocationOnMock;
+        int argumentPosition = inferWantedArgumentPosition(invocation);
+        validateIndexWithinTheoreticalInvocationRange(invocation, argumentPosition);
+        validateArgumentTypeCompatibility(invocation, argumentPosition);
+    }
+
+    private int inferWantedArgumentPosition(InvocationOnMock invocation) {
+        if (wantedArgumentPosition == LAST_ARGUMENT) {
+            return invocation.getArguments().length - 1;
+        }
+
+        return wantedArgumentPosition;
+    }
+
+    private int inferWantedRawArgumentPosition(InvocationOnMock invocation) {
+        if (wantedArgumentPosition == LAST_ARGUMENT) {
+            return invocation.getRawArguments().length - 1;
+        }
+
+        return wantedArgumentPosition;
+    }
+
+    private void validateIndexWithinInvocationRange(
+            InvocationOnMock invocation, int argumentPosition) {
+
+        if (invocation.getArguments().length <= argumentPosition) {
+            throw invalidArgumentPositionRangeAtInvocationTime(
+                    invocation, wantedArgumentPosition == LAST_ARGUMENT, wantedArgumentPosition);
+        }
+    }
+
+    private void validateIndexWithinTheoreticalInvocationRange(
+            InvocationOnMock invocation, int argumentPosition) {
+        if (!wantedArgumentPositionIsValidForTheoreticalInvocation(invocation, argumentPosition)) {
+            throw invalidArgumentPositionRangeAtInvocationTime(
+                    invocation, wantedArgumentPosition == LAST_ARGUMENT, wantedArgumentPosition);
+        }
+    }
+
+    private void validateArgumentTypeCompatibility(Invocation invocation, int argumentPosition) {
+        InvocationInfo invocationInfo = new InvocationInfo(invocation);
+
+        Class<?> inferredArgumentType = inferArgumentType(invocation, argumentPosition);
+
+        if (!invocationInfo.isValidReturnType(inferredArgumentType)) {
+            throw wrongTypeOfArgumentToReturn(
+                    invocation,
+                    invocationInfo.printMethodReturnType(),
+                    inferredArgumentType,
+                    wantedArgumentPosition);
+        }
+    }
+
+    private boolean wantedArgIndexIsVarargAndSameTypeAsReturnType(InvocationOnMock invocation) {
+        int rawArgumentPosition = inferWantedRawArgumentPosition(invocation);
+        Method method = invocation.getMethod();
+        Class<?>[] parameterTypes = method.getParameterTypes();
+        return method.isVarArgs()
+                && rawArgumentPosition == /* vararg index */ parameterTypes.length - 1
+                && method.getReturnType().isAssignableFrom(parameterTypes[rawArgumentPosition]);
+    }
+
+    private boolean wantedArgumentPositionIsValidForTheoreticalInvocation(
+            InvocationOnMock invocation, int argumentPosition) {
+        if (argumentPosition < 0) {
+            return false;
+        }
+        if (!invocation.getMethod().isVarArgs()) {
+            return invocation.getArguments().length > argumentPosition;
+        }
+        // for all varargs accepts positive ranges
+        return true;
+    }
+
+    private Class<?> inferArgumentType(Invocation invocation, int argumentIndex) {
+        Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
+
+        // Easy when the method is not a vararg
+        if (!invocation.getMethod().isVarArgs()) {
+            Class<?> argumentType = parameterTypes[argumentIndex];
+            Object argumentValue = invocation.getArgument(argumentIndex);
+            // we don't want to return primitive wrapper types
+            if (argumentType.isPrimitive() || argumentValue == null) {
+                return argumentType;
+            }
+
+            return argumentValue.getClass();
+        }
+
+        // Now for varargs
+        int varargIndex = parameterTypes.length - 1; // vararg always last
+
+        if (argumentIndex < varargIndex) {
+            // Same for non vararg arguments
+            return parameterTypes[argumentIndex];
+        }
+        // if wanted argument is vararg
+        if (wantedArgIndexIsVarargAndSameTypeAsReturnType(invocation)) {
+            // return the vararg array if return type is compatible
+            // because the user probably want to return the array itself if the return type is
+            // compatible
+            return parameterTypes[argumentIndex]; // move to MethodInfo ?
+        }
+        // return the type in this vararg array
+        return parameterTypes[varargIndex].getComponentType();
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
similarity index 79%
rename from src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
index 433c7d2f07..cbd8a14247 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
@@ -36,16 +36,17 @@ public class ReturnsElementsOf implements Answer<Object> {
 
     public ReturnsElementsOf(Collection<?> elements) {
         if (elements == null) {
-            throw new MockitoException("ReturnsElementsOf does not accept null as constructor argument.\n" +
-                    "Please pass a collection instance");
+            throw new MockitoException(
+                    "ReturnsElementsOf does not accept null as constructor argument.\n"
+                            + "Please pass a collection instance");
         }
-        this.elements = new LinkedList<Object>(elements);
+        this.elements = new LinkedList<>(elements);
     }
 
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
-        if (elements.size() == 1)
+        if (elements.size() == 1) {
             return elements.get(0);
-        else
-            return elements.poll();
+        } else return elements.poll();
     }
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
new file mode 100644
index 0000000000..a971201bb8
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import java.io.Serializable;
+
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.ValidableAnswer;
+
+/**
+ * An answer that always throws the same throwable.
+ */
+public class ThrowsException extends AbstractThrowsException implements Serializable {
+
+    private static final long serialVersionUID = 1128820328555183980L;
+    private final Throwable throwable;
+
+    /**
+     * 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;
+    }
+
+    @Override
+    protected Throwable getThrowable() {
+        return throwable;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassType.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassType.java
new file mode 100644
index 0000000000..2c3d923956
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassType.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import java.io.Serializable;
+
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.configuration.plugins.Plugins;
+
+public class ThrowsExceptionForClassType extends AbstractThrowsException implements Serializable {
+
+    private final Class<? extends Throwable> throwableClass;
+
+    public ThrowsExceptionForClassType(Class<? extends Throwable> throwableClass) {
+        this.throwableClass = throwableClass;
+    }
+
+    @Override
+    protected Throwable getThrowable() {
+        Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(null);
+        return instantiator.newInstance(throwableClass);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/package-info.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/answers/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/stubbing/answers/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/answers/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
new file mode 100644
index 0000000000..5d12ca03e6
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.mockito.internal.exceptions.Reporter.delegatedMethodDoesNotExistOnDelegate;
+import static org.mockito.internal.exceptions.Reporter.delegatedMethodHasWrongReturnType;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.plugins.MemberAccessor;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Internal answer to forward invocations on a real instance.
+ *
+ * @since 1.9.5
+ */
+public class ForwardsInvocations implements Answer<Object>, Serializable {
+    private static final long serialVersionUID = -8343690268123254910L;
+
+    private Object delegatedObject = null;
+
+    public ForwardsInvocations(Object delegatedObject) {
+        this.delegatedObject = delegatedObject;
+    }
+
+    @Override
+    public Object answer(InvocationOnMock invocation) throws Throwable {
+        Method mockMethod = invocation.getMethod();
+
+        try {
+            Method delegateMethod = getDelegateMethod(mockMethod);
+
+            if (!compatibleReturnTypes(
+                    mockMethod.getReturnType(), delegateMethod.getReturnType())) {
+                throw delegatedMethodHasWrongReturnType(
+                        mockMethod, delegateMethod, invocation.getMock(), delegatedObject);
+            }
+
+            MemberAccessor accessor = Plugins.getMemberAccessor();
+            Object[] rawArguments = invocation.getRawArguments();
+            return accessor.invoke(delegateMethod, delegatedObject, rawArguments);
+        } catch (NoSuchMethodException e) {
+            throw delegatedMethodDoesNotExistOnDelegate(
+                    mockMethod, invocation.getMock(), delegatedObject);
+        } catch (InvocationTargetException e) {
+            // propagate the original exception from the delegate
+            throw e.getCause();
+        }
+    }
+
+    private Method getDelegateMethod(Method mockMethod) throws NoSuchMethodException {
+        if (mockMethod.getDeclaringClass().isAssignableFrom(delegatedObject.getClass())) {
+            // Compatible class. Return original method.
+            return mockMethod;
+        } else {
+            // Return method of delegate object with the same signature as mockMethod.
+            return delegatedObject
+                    .getClass()
+                    .getMethod(mockMethod.getName(), mockMethod.getParameterTypes());
+        }
+    }
+
+    private static boolean compatibleReturnTypes(Class<?> superType, Class<?> subType) {
+        return superType.equals(subType) || superType.isAssignableFrom(subType);
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
similarity index 98%
rename from src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
index a25832fa7a..51a70aa401 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
@@ -20,6 +20,7 @@ public class GloballyConfiguredAnswer implements Answer<Object>, Serializable {
 
     private static final long serialVersionUID = 3585893470101750917L;
 
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
         return new GlobalConfiguration().getDefaultAnswer().answer(invocation);
     }
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
similarity index 78%
rename from src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
index 515ba5d5f9..8b64a16916 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
@@ -8,18 +8,15 @@
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 
-import org.mockito.internal.MockitoCore;
 import org.mockito.internal.util.MockUtil;
 import org.mockito.internal.util.reflection.GenericMetadataSupport;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.mock.MockCreationSettings;
 
-class RetrieveGenericsForDefaultAnswers {
-
-    private static final MockitoCore MOCKITO_CORE = new MockitoCore();
+final class RetrieveGenericsForDefaultAnswers {
 
     static Object returnTypeForMockWithCorrectGenerics(
-        InvocationOnMock invocation, AnswerCallback answerCallback) {
+            InvocationOnMock invocation, AnswerCallback answerCallback) {
         Class<?> type = invocation.getMethod().getReturnType();
 
         final Type returnType = invocation.getMethod().getGenericReturnType();
@@ -38,7 +35,9 @@ static Object returnTypeForMockWithCorrectGenerics(
         }
 
         if (type != null) {
-            if (!MOCKITO_CORE.isTypeMockable(type)) {
+            final MockCreationSettings<?> mockSettings =
+                    MockUtil.getMockSettings(invocation.getMock());
+            if (!MockUtil.typeMockabilityOf(type, mockSettings.getMockMaker()).mockable()) {
                 return null;
             }
 
@@ -51,7 +50,7 @@ static Object returnTypeForMockWithCorrectGenerics(
     /**
      * Try to resolve the result value using {@link ReturnsEmptyValues} and {@link ReturnsMoreEmptyValues}.
      *
-     * This will try to use all parent class (superclass & interfaces) to retrieve the value..
+     * This will try to use all parent class (superclass and interfaces) to retrieve the value..
      *
      * @param type the return type of the method
      * @return a non-null instance if the type has been resolve. Null otherwise.
@@ -88,12 +87,14 @@ private static Object delegateChains(final Class<?> type) {
      * @param returnType the expected return type
      * @return the type or null if not found
      */
-    private static Class<?> findTypeFromGeneric(final InvocationOnMock invocation, final TypeVariable returnType) {
+    private static Class<?> findTypeFromGeneric(
+            final InvocationOnMock invocation, final TypeVariable returnType) {
         // Class level
-        final MockCreationSettings mockSettings = MockUtil.getMockHandler(invocation.getMock()).getMockSettings();
-        final GenericMetadataSupport returnTypeSupport = GenericMetadataSupport
-            .inferFrom(mockSettings.getTypeToMock())
-            .resolveGenericReturnType(invocation.getMethod());
+        final MockCreationSettings mockSettings =
+                MockUtil.getMockHandler(invocation.getMock()).getMockSettings();
+        final GenericMetadataSupport returnTypeSupport =
+                GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock())
+                        .resolveGenericReturnType(invocation.getMethod());
         final Class<?> rawType = returnTypeSupport.rawType();
 
         // Method level
@@ -110,7 +111,8 @@ private static Class<?> findTypeFromGeneric(final InvocationOnMock invocation, f
      * @param returnType the expected return type
      * @return the return type or null if the return type cannot be found
      */
-    private static Class<?> findTypeFromGenericInArguments(final InvocationOnMock invocation, final TypeVariable returnType) {
+    private static Class<?> findTypeFromGenericInArguments(
+            final InvocationOnMock invocation, final TypeVariable returnType) {
         final Type[] parameterTypes = invocation.getMethod().getGenericParameterTypes();
         for (int i = 0; i < parameterTypes.length; i++) {
             Type argType = parameterTypes[i];
@@ -136,4 +138,6 @@ private static Class<?> findTypeFromGenericInArguments(final InvocationOnMock in
     interface AnswerCallback {
         Object apply(Class<?> type);
     }
+
+    private RetrieveGenericsForDefaultAnswers() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
new file mode 100644
index 0000000000..4e03e8b12d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.mockito.Mockito.withSettings;
+import static org.mockito.internal.util.MockUtil.typeMockabilityOf;
+
+import java.io.IOException;
+import java.io.Serializable;
+
+import org.mockito.MockSettings;
+import org.mockito.Mockito;
+import org.mockito.internal.MockitoCore;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockito.internal.stubbing.StubbedInvocationMatcher;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.reflection.GenericMetadataSupport;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Returning deep stub implementation.
+ *
+ * <p>Will return previously created mock if the invocation matches.
+ *
+ * <p>Supports nested generic information, with this answer you can write code like this :
+ *
+ * <pre class="code"><code class="java">
+ *     interface GenericsNest&lt;K extends Comparable&lt;K&gt; &amp; Cloneable&gt; extends Map&lt;K, Set&lt;Number&gt;&gt; {}
+ *
+ *     GenericsNest&lt;?&gt; mock = mock(GenericsNest.class, new ReturnsGenericDeepStubs());
+ *     Number number = mock.entrySet().iterator().next().getValue().iterator().next();
+ * </code></pre>
+ * </p>
+ *
+ * <p>However this answer does not support generics information when the mock has been deserialized.
+ *
+ * @see org.mockito.Mockito#RETURNS_DEEP_STUBS
+ * @see org.mockito.Answers#RETURNS_DEEP_STUBS
+ */
+public class ReturnsDeepStubs implements Answer<Object>, Serializable {
+
+    private static final long serialVersionUID = -7105341425736035847L;
+
+    @Override
+    public Object answer(InvocationOnMock invocation) throws Throwable {
+        GenericMetadataSupport returnTypeGenericMetadata =
+                actualParameterizedType(invocation.getMock())
+                        .resolveGenericReturnType(invocation.getMethod());
+        MockCreationSettings<?> mockSettings = MockUtil.getMockSettings(invocation.getMock());
+
+        Class<?> rawType = returnTypeGenericMetadata.rawType();
+        final var emptyValue = ReturnsEmptyValues.returnCommonEmptyValueFor(rawType);
+        if (emptyValue != null) {
+            return emptyValue;
+        }
+        if (!typeMockabilityOf(rawType, mockSettings.getMockMaker()).mockable()) {
+            if (invocation.getMethod().getReturnType().equals(rawType)) {
+                return delegate().answer(invocation);
+            } else {
+                return delegate().returnValueFor(rawType);
+            }
+        }
+
+        // When dealing with erased generics, we only receive the Object type as rawType. At this
+        // point, there is nothing to salvage for Mockito. Instead of trying to be smart and
+        // generate
+        // a mock that would potentially match the return signature, instead return `null`. This
+        // is valid per the CheckCast JVM instruction and is better than causing a
+        // ClassCastException
+        // on runtime.
+        if (rawType.equals(Object.class) && !returnTypeGenericMetadata.hasRawExtraInterfaces()) {
+            return null;
+        }
+
+        return deepStub(invocation, returnTypeGenericMetadata);
+    }
+
+    private Object deepStub(
+            InvocationOnMock invocation, GenericMetadataSupport returnTypeGenericMetadata)
+            throws Throwable {
+        InvocationContainerImpl container = MockUtil.getInvocationContainer(invocation.getMock());
+
+        Answer existingAnswer = container.findStubbedAnswer();
+        if (existingAnswer != null) {
+            return existingAnswer.answer(invocation);
+        }
+
+        // record deep stub answer
+        StubbedInvocationMatcher stubbing =
+                recordDeepStubAnswer(
+                        newDeepStubMock(returnTypeGenericMetadata, invocation.getMock()),
+                        container);
+
+        // deep stubbing creates a stubbing and immediately uses it
+        // so the stubbing is actually used by the same invocation
+        stubbing.markStubUsed(stubbing.getInvocation());
+
+        return stubbing.answer(invocation);
+    }
+
+    /**
+     * Creates a mock using the Generics Metadata.
+     *
+     * <li>Finally as we want to mock the actual type, but we want to pass along the contextual generics meta-data
+     * that was resolved for the current return type, for this to happen we associate to the mock an new instance of
+     * {@link ReturnsDeepStubs} answer in which we will store the returned type generic metadata.
+     *
+     * @param returnTypeGenericMetadata The metadata to use to create the new mock.
+     * @param parentMock                The parent of the current deep stub mock.
+     * @return The mock
+     */
+    private Object newDeepStubMock(
+            GenericMetadataSupport returnTypeGenericMetadata, Object parentMock) {
+        MockCreationSettings parentMockSettings = MockUtil.getMockSettings(parentMock);
+        return mockitoCore()
+                .mock(
+                        returnTypeGenericMetadata.rawType(),
+                        withSettingsUsing(returnTypeGenericMetadata, parentMockSettings));
+    }
+
+    private MockSettings withSettingsUsing(
+            GenericMetadataSupport returnTypeGenericMetadata,
+            MockCreationSettings<?> parentMockSettings) {
+        MockSettings mockSettings =
+                returnTypeGenericMetadata.hasRawExtraInterfaces()
+                        ? withSettings()
+                                .extraInterfaces(returnTypeGenericMetadata.rawExtraInterfaces())
+                        : withSettings();
+
+        return propagateSerializationSettings(mockSettings, parentMockSettings)
+                .defaultAnswer(returnsDeepStubsAnswerUsing(returnTypeGenericMetadata))
+                .mockMaker(parentMockSettings.getMockMaker());
+    }
+
+    private MockSettings propagateSerializationSettings(
+            MockSettings mockSettings, MockCreationSettings parentMockSettings) {
+        return mockSettings.serializable(parentMockSettings.getSerializableMode());
+    }
+
+    private ReturnsDeepStubs returnsDeepStubsAnswerUsing(
+            final GenericMetadataSupport returnTypeGenericMetadata) {
+        return new ReturnsDeepStubsSerializationFallback(returnTypeGenericMetadata);
+    }
+
+    private StubbedInvocationMatcher recordDeepStubAnswer(
+            final Object mock, InvocationContainerImpl container) {
+        DeeplyStubbedAnswer answer = new DeeplyStubbedAnswer(mock);
+        return container.addAnswer(answer, false, null);
+    }
+
+    protected GenericMetadataSupport actualParameterizedType(Object mock) {
+        CreationSettings mockSettings =
+                (CreationSettings) MockUtil.getMockHandler(mock).getMockSettings();
+        return GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock());
+    }
+
+    private static class ReturnsDeepStubsSerializationFallback extends ReturnsDeepStubs
+            implements Serializable {
+        @SuppressWarnings("serial") // not gonna be serialized
+        private final GenericMetadataSupport returnTypeGenericMetadata;
+
+        public ReturnsDeepStubsSerializationFallback(
+                GenericMetadataSupport returnTypeGenericMetadata) {
+            this.returnTypeGenericMetadata = returnTypeGenericMetadata;
+        }
+
+        @Override
+        protected GenericMetadataSupport actualParameterizedType(Object mock) {
+            return returnTypeGenericMetadata;
+        }
+
+        /**
+         * Generics support and serialization with deep stubs don't work together.
+         * <p>
+         * The issue is that GenericMetadataSupport is not serializable because
+         * the type elements inferred via reflection are not serializable. Supporting
+         * serialization would require to replace all types coming from the Java reflection
+         * with our own and still managing type equality with the JDK ones.
+         */
+        private Object writeReplace() throws IOException {
+            return Mockito.RETURNS_DEEP_STUBS;
+        }
+    }
+
+    private static class DeeplyStubbedAnswer implements Answer<Object>, Serializable {
+        @SuppressWarnings(
+                "serial") // serialization will fail with a nice message if mock not serializable
+        private final Object mock;
+
+        DeeplyStubbedAnswer(Object mock) {
+            this.mock = mock;
+        }
+
+        @Override
+        public Object answer(InvocationOnMock invocation) throws Throwable {
+            return mock;
+        }
+    }
+
+    private static MockitoCore mockitoCore() {
+        return LazyHolder.MOCKITO_CORE;
+    }
+
+    private static ReturnsEmptyValues delegate() {
+        return LazyHolder.DELEGATE;
+    }
+
+    private static class LazyHolder {
+        private static final MockitoCore MOCKITO_CORE = new MockitoCore();
+        private static final ReturnsEmptyValues DELEGATE = new ReturnsEmptyValues();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
new file mode 100644
index 0000000000..c2dd0f7b2b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.mockito.internal.util.ObjectMethodsGuru.isCompareToMethod;
+import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
+
+import java.io.Serializable;
+import java.time.Duration;
+import java.time.Period;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.Primitives;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.mock.MockName;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Default answer of every Mockito mock.
+ * <ul>
+ * <li>
+ * Returns appropriate primitive for primitive-returning methods
+ * </li>
+ * <li>
+ * Returns consistent values for primitive wrapper classes (e.g. int-returning method returns 0 <b>and</b> Integer-returning method returns 0, too)
+ * </li>
+ * <li>
+ * Returns empty collection for collection-returning methods (works for most commonly used collection types)
+ * </li>
+ * <li>
+ * Returns description of mock for toString() method
+ * </li>
+ * <li>
+ * Returns zero if references are equals otherwise non-zero for Comparable#compareTo(T other) method (see issue 184)
+ * </li>
+ * <li>
+ * Returns an {@code java.util.Optional#empty() empty Optional} for Optional. Similarly for primitive optional variants.
+ * </li>
+ * <li>
+ * Returns an {@code java.util.stream.Stream#empty() empty Stream} for Stream. Similarly for primitive stream variants.
+ * </li>
+ * <li>
+ * Returns an {@code java.time.Duration.ZERO zero Duration} for empty Duration and {@code java.time.Period.ZERO zero Period} for empty Period.
+ * </li>
+ * <li>
+ * Returns null for everything else
+ * </li>
+ * </ul>
+ */
+public class ReturnsEmptyValues implements Answer<Object>, Serializable {
+
+    private static final long serialVersionUID = 1998191268711234347L;
+
+    /* (non-Javadoc)
+     * @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
+     */
+    @Override
+    public Object answer(InvocationOnMock invocation) {
+        if (isToStringMethod(invocation.getMethod())) {
+            Object mock = invocation.getMock();
+            MockName name = MockUtil.getMockName(mock);
+            if (name.isDefault()) {
+                return "Mock for "
+                        + MockUtil.getMockSettings(mock).getTypeToMock().getSimpleName()
+                        + ", hashCode: "
+                        + mock.hashCode();
+            } else {
+                return name.toString();
+            }
+        } else if (isCompareToMethod(invocation.getMethod())) {
+            // see issue 184.
+            // mocks by default should return 0 if references are the same, otherwise some other
+            // value because they are not the same. Hence we return 1 (anything but 0 is good).
+            // Only for compareTo() method by the Comparable interface
+            return invocation.getMock() == invocation.getArgument(0) ? 0 : 1;
+        }
+
+        Class<?> returnType = invocation.getMethod().getReturnType();
+        return returnValueFor(returnType);
+    }
+
+    Object returnValueFor(Class<?> type) {
+        if (Primitives.isPrimitiveOrWrapper(type)) {
+            return Primitives.defaultValue(type);
+            // new instances are used instead of Collections.emptyList(), etc.
+            // to avoid UnsupportedOperationException if code under test modifies returned
+            // collection
+        } else if (type == Iterable.class) {
+            return new ArrayList<>(0);
+        } else if (type == Collection.class) {
+            return new LinkedList<>();
+        } else if (type == Set.class) {
+            return new HashSet<>();
+        } else if (type == HashSet.class) {
+            return new HashSet<>();
+        } else if (type == SortedSet.class) {
+            return new TreeSet<>();
+        } else if (type == TreeSet.class) {
+            return new TreeSet<>();
+        } else if (type == LinkedHashSet.class) {
+            return new LinkedHashSet<>();
+        } else if (type == List.class) {
+            return new LinkedList<>();
+        } else if (type == LinkedList.class) {
+            return new LinkedList<>();
+        } else if (type == ArrayList.class) {
+            return new ArrayList<>();
+        } else if (type == Map.class) {
+            return new HashMap<>();
+        } else if (type == HashMap.class) {
+            return new HashMap<>();
+        } else if (type == SortedMap.class) {
+            return new TreeMap<>();
+        } else if (type == TreeMap.class) {
+            return new TreeMap<>();
+        } else if (type == LinkedHashMap.class) {
+            return new LinkedHashMap<>();
+        } else if (type == Stream.class) {
+            return Stream.empty();
+        } else if (type == DoubleStream.class) {
+            return DoubleStream.empty();
+        } else if (type == IntStream.class) {
+            return IntStream.empty();
+        } else if (type == LongStream.class) {
+            return LongStream.empty();
+        } else if (type == Duration.class) {
+            return Duration.ZERO;
+        } else if (type == Period.class) {
+            return Period.ZERO;
+        }
+        // Let's not care about the rest of collections.
+
+        return returnCommonEmptyValueFor(type);
+    }
+
+    /**
+     * Returns empty values for common known types, shared between {@link ReturnsEmptyValues} and {@link ReturnsDeepStubs}.
+     *
+     * @param type the type to check
+     * @return the empty value, or {@code null}
+     */
+    static Object returnCommonEmptyValueFor(Class<?> type) {
+        if (type == Optional.class) {
+            return Optional.empty();
+        } else if (type == OptionalDouble.class) {
+            return OptionalDouble.empty();
+        } else if (type == OptionalInt.class) {
+            return OptionalInt.empty();
+        } else if (type == OptionalLong.class) {
+            return OptionalLong.empty();
+        }
+        return null;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
new file mode 100755
index 0000000000..c155780916
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import java.io.Serializable;
+
+import org.mockito.Mockito;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Answer;
+
+public class ReturnsMocks implements Answer<Object>, Serializable {
+
+    private static final long serialVersionUID = -6755257986994634579L;
+    private final Answer<Object> delegate = new ReturnsMoreEmptyValues();
+
+    @Override
+    public Object answer(final InvocationOnMock invocation) throws Throwable {
+        Object defaultReturnValue = delegate.answer(invocation);
+
+        if (defaultReturnValue != null) {
+            return defaultReturnValue;
+        }
+
+        return RetrieveGenericsForDefaultAnswers.returnTypeForMockWithCorrectGenerics(
+                invocation,
+                new RetrieveGenericsForDefaultAnswers.AnswerCallback() {
+                    @Override
+                    public Object apply(Class<?> type) {
+                        if (type == null) {
+                            return null;
+                        }
+
+                        MockCreationSettings<?> mockSettings =
+                                MockUtil.getMockSettings(invocation.getMock());
+
+                        return Mockito.mock(
+                                type,
+                                new MockSettingsImpl<>()
+                                        .defaultAnswer(ReturnsMocks.this)
+                                        .mockMaker(mockSettings.getMockMaker()));
+                    }
+                });
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
similarity index 96%
rename from src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
index 6188f75931..c39f5359bc 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
@@ -12,7 +12,7 @@
 import org.mockito.stubbing.Answer;
 
 /**
- * It's likely this implementation will be used by default by every Mockito 3.0.0 mock.
+ * It's likely this implementation will be used by default by every Mockito 4.0.0 mock.
  * <p>
  * Currently <b>used only</b> by {@link Mockito#RETURNS_SMART_NULLS}
  * <p>
@@ -52,6 +52,7 @@ public class ReturnsMoreEmptyValues implements Answer<Object>, Serializable {
     /* (non-Javadoc)
      * @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
      */
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
         Object ret = delegate.answer(invocation);
         if (ret != null) {
@@ -65,7 +66,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
     Object returnValueFor(Class<?> type) {
         if (type == String.class) {
             return "";
-        }  else if (type.isArray()) {
+        } else if (type.isArray()) {
             Class<?> componentType = type.getComponentType();
             return Array.newInstance(componentType, 0);
         }
diff --git a/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
new file mode 100644
index 0000000000..c093af2051
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.mockito.internal.exceptions.Reporter.smartNullPointerException;
+import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+import org.mockito.Mockito;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.creation.bytebuddy.access.MockAccess;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.invocation.Location;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Optional Answer that can be used with
+ * {@link Mockito#mock(Class, Answer)}
+ * <p>
+ * This implementation can be helpful when working with legacy code. Un-stubbed
+ * methods often return null. If your code uses the object returned by an
+ * un-stubbed call, you get a NullPointerException. This implementation of
+ * Answer returns SmartNulls instead of nulls.
+ * SmartNull gives nicer exception message than NPE because it points out the
+ * line where un-stubbed method was called. You just click on the stack trace.
+ * <p>
+ * ReturnsSmartNulls first tries to return ordinary return values (see
+ * {@link ReturnsMoreEmptyValues}) then it tries to return SmartNull. If the
+ * return type is not mockable (e.g. final) then ordinary null is returned.
+ * <p>
+ * ReturnsSmartNulls will be probably the default return values strategy in
+ * Mockito 2.1.0
+ */
+public class ReturnsSmartNulls implements Answer<Object>, Serializable {
+
+    private static final long serialVersionUID = 7618312406617949441L;
+
+    private final Answer<Object> delegate = new ReturnsMoreEmptyValues();
+
+    @Override
+    public Object answer(final InvocationOnMock invocation) throws Throwable {
+        Object defaultReturnValue = delegate.answer(invocation);
+
+        if (defaultReturnValue != null) {
+            return defaultReturnValue;
+        }
+
+        return RetrieveGenericsForDefaultAnswers.returnTypeForMockWithCorrectGenerics(
+                invocation,
+                new RetrieveGenericsForDefaultAnswers.AnswerCallback() {
+                    @Override
+                    public Object apply(Class<?> type) {
+                        if (type == null) {
+                            return null;
+                        }
+
+                        MockCreationSettings<?> mockSettings =
+                                MockUtil.getMockSettings(invocation.getMock());
+                        Answer<?> defaultAnswer =
+                                new ThrowsSmartNullPointer(invocation, LocationFactory.create());
+
+                        return Mockito.mock(
+                                type,
+                                new MockSettingsImpl<>()
+                                        .defaultAnswer(defaultAnswer)
+                                        .mockMaker(mockSettings.getMockMaker()));
+                    }
+                });
+    }
+
+    private static class ThrowsSmartNullPointer implements Answer {
+
+        private final InvocationOnMock unstubbedInvocation;
+
+        private final Location location;
+
+        ThrowsSmartNullPointer(InvocationOnMock unstubbedInvocation, Location location) {
+            this.unstubbedInvocation = unstubbedInvocation;
+            this.location = location;
+        }
+
+        @Override
+        public Object answer(InvocationOnMock currentInvocation) throws Throwable {
+            if (isToStringMethod(currentInvocation.getMethod())) {
+                return "SmartNull returned by this un-stubbed method call on a mock:\n"
+                        + unstubbedInvocation;
+            } else if (isMethodOf(
+                    MockAccess.class, currentInvocation.getMock(), currentInvocation.getMethod())) {
+                /* The MockAccess methods should be called directly */
+                return currentInvocation.callRealMethod();
+            }
+
+            throw smartNullPointerException(unstubbedInvocation.toString(), location);
+        }
+
+        private static boolean isMethodOf(Class<?> clazz, Object instance, Method method) {
+            if (!clazz.isInstance(instance)) {
+                return false;
+            }
+
+            for (Method m : clazz.getDeclaredMethods()) {
+                if (m.getName().equalsIgnoreCase(method.getName())
+                        && Arrays.equals(m.getParameterTypes(), method.getParameterTypes())) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
similarity index 88%
rename from src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
index bb2389f9cd..f5643c565b 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
+++ b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
@@ -10,20 +10,20 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-public class TriesToReturnSelf implements Answer<Object>, Serializable{
+public class TriesToReturnSelf implements Answer<Object>, Serializable {
 
     private final ReturnsEmptyValues defaultReturn = new ReturnsEmptyValues();
 
+    @Override
     public Object answer(InvocationOnMock invocation) throws Throwable {
         Class<?> methodReturnType = invocation.getMethod().getReturnType();
         Object mock = invocation.getMock();
         Class<?> mockType = MockUtil.getMockHandler(mock).getMockSettings().getTypeToMock();
 
-        if (methodReturnType.isAssignableFrom(mockType)) {
+        if (methodReturnType.isAssignableFrom(mockType) && methodReturnType != Object.class) {
             return invocation.getMock();
         }
 
         return defaultReturn.returnValueFor(methodReturnType);
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/package-info.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/stubbing/defaultanswers/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/defaultanswers/package-info.java
diff --git a/src/main/java/org/mockito/internal/stubbing/package-info.java b/mockito-core/src/main/java/org/mockito/internal/stubbing/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/stubbing/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/stubbing/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/AndroidPlatform.java b/mockito-core/src/main/java/org/mockito/internal/util/AndroidPlatform.java
new file mode 100644
index 0000000000..5a0ffbcd2a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/AndroidPlatform.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+public class AndroidPlatform {
+
+    private static int getSdkInt() {
+        try {
+            return Class.forName("android.os.Build$VERSION").getField("SDK_INT").getInt(null);
+        } catch (ReflectiveOperationException e) {
+            return 0;
+        }
+    }
+
+    private static int getExtensionVersion(int sdk) {
+        try {
+            return (int)
+                    Class.forName("android.os.ext.SdkExtensions")
+                            .getMethod("getExtensionVersion", int.class)
+                            .invoke(null, sdk);
+        } catch (ReflectiveOperationException e) {
+            return 0;
+        }
+    }
+
+    public static boolean isStackWalkerUsable() {
+        // StackWalker on Android had a bug that is fixed in Android Baklava (36)
+        // or SDK extension train M2025-05 (17) and later. See https://r.android.com/3548340.
+        return getSdkInt() >= 36 || getSdkInt() >= 31 && getExtensionVersion(31) >= 17;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/Checks.java b/mockito-core/src/main/java/org/mockito/internal/util/Checks.java
similarity index 89%
rename from src/main/java/org/mockito/internal/util/Checks.java
rename to mockito-core/src/main/java/org/mockito/internal/util/Checks.java
index 9aa2a00cff..f7ed59dcda 100644
--- a/src/main/java/org/mockito/internal/util/Checks.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/Checks.java
@@ -4,17 +4,15 @@
  */
 package org.mockito.internal.util;
 
-/**
- * Pre-made preconditions
- */
-public class Checks {
+/** Pre-made preconditions */
+public final class Checks {
 
     public static <T> T checkNotNull(T value, String checkedValue) {
         return checkNotNull(value, checkedValue, null);
     }
 
     public static <T> T checkNotNull(T value, String checkedValue, String additionalMessage) {
-        if(value == null) {
+        if (value == null) {
             String message = checkedValue + " should not be null";
             if (additionalMessage != null) {
                 message += ". " + additionalMessage;
@@ -31,4 +29,6 @@ public static <T extends Iterable<?>> T checkItemsNotNull(T iterable, String che
         }
         return iterable;
     }
+
+    private Checks() {}
 }
diff --git a/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java b/mockito-core/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
similarity index 76%
rename from src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
rename to mockito-core/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
index 3eb89396e1..665cf77685 100644
--- a/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
@@ -8,10 +8,13 @@
 
 public class ConsoleMockitoLogger implements MockitoLogger {
 
-    /* (non-Javadoc)
-     * @see org.mockito.internal.util.Logger#print(java.lang.Object)
-     */
+    @Override
     public void log(Object what) {
         System.out.println(what);
     }
+
+    @Override
+    public void warn(Object what) {
+        System.err.println(what);
+    }
 }
diff --git a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java b/mockito-core/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
similarity index 79%
rename from src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
rename to mockito-core/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
index 6d4ded34f0..1ad5a757f8 100644
--- a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
@@ -23,17 +23,17 @@ public class DefaultMockingDetails implements MockingDetails {
 
     private final Object toInspect;
 
-    public DefaultMockingDetails(Object toInspect){
+    public DefaultMockingDetails(Object toInspect) {
         this.toInspect = toInspect;
     }
 
     @Override
-    public boolean isMock(){
+    public boolean isMock() {
         return MockUtil.isMock(toInspect);
     }
 
     @Override
-    public boolean isSpy(){
+    public boolean isSpy() {
         return MockUtil.isSpy(toInspect);
     }
 
@@ -73,16 +73,20 @@ public Object getMock() {
         return toInspect;
     }
 
-    private MockHandler<Object> mockHandler() {
+    private MockHandler<?> mockHandler() {
         assertGoodMock();
         return MockUtil.getMockHandler(toInspect);
     }
 
     private void assertGoodMock() {
         if (toInspect == null) {
-            throw new NotAMockException("Argument passed to Mockito.mockingDetails() should be a mock, but is null!");
+            throw new NotAMockException(
+                    "Argument passed to Mockito.mockingDetails() should be a mock, but is null!");
         } else if (!isMock()) {
-            throw new NotAMockException("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of " + toInspect.getClass() + "!");
+            throw new NotAMockException(
+                    "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of "
+                            + toInspect.getClass()
+                            + "!");
         }
     }
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/KotlinInlineClassUtil.java b/mockito-core/src/main/java/org/mockito/internal/util/KotlinInlineClassUtil.java
new file mode 100644
index 0000000000..890f160a0e
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/KotlinInlineClassUtil.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.stubbing.answers.InvocationInfo;
+import org.mockito.invocation.InvocationOnMock;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class KotlinInlineClassUtil {
+    private static Class<Annotation> jvmInlineAnnotation;
+
+    static {
+        try {
+            jvmInlineAnnotation = (Class<Annotation>) Class.forName("kotlin.jvm.JvmInline");
+        } catch (ClassNotFoundException e) {
+            // Do nothing: kotlin is pre 1.5.0
+        }
+    }
+
+    // When mocking function, returning inline class, its return type is
+    // underlying type.
+    // So, `thenReturn` calls fails, because of non-compatible types.
+    public static boolean isInlineClassWithAssignableUnderlyingType(
+            Class<?> inlineClass, Class<?> underlyingType) {
+        try {
+            // Since 1.5.0 inline classes have @JvmInline annotation
+            if (jvmInlineAnnotation == null
+                    || !inlineClass.isAnnotationPresent(jvmInlineAnnotation)) return false;
+
+            // All inline classes have 'box-impl' method, which accepts
+            // underlying type and returns inline class.
+            // Make sure that the current inline class is also the class that is compatible with the
+            // underlying type.
+            // If we don't make this check, then we would potentially pass a mock of inline type A
+            // into a method
+            // that accepts inline type B.
+            Object ignored = inlineClass.getDeclaredMethod("box-impl", underlyingType);
+            return true;
+        } catch (NoSuchMethodException e) {
+            return false;
+        }
+    }
+
+    private static Object unboxInlineClassIfPossible(Object boxedValue) {
+        Class<?> inlineClass = boxedValue.getClass();
+        try {
+            Method unboxImpl = inlineClass.getDeclaredMethod("unbox-impl");
+            return unboxImpl.invoke(boxedValue);
+        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw Reporter.inlineClassWithoutUnboxImpl(inlineClass, e);
+        }
+    }
+
+    public static Object unboxUnderlyingValueIfNeeded(InvocationOnMock invocation, Object value) {
+        // Short path - Kotlin 1.5+ is not present.
+        if (value == null || jvmInlineAnnotation == null) {
+            return value;
+        }
+
+        Class<?> valueType = value.getClass();
+        InvocationInfo invocationInfo = new InvocationInfo(invocation);
+        Class<?> returnType = invocationInfo.getMethod().getReturnType();
+        if (valueType.isAssignableFrom(returnType)) return value;
+
+        if (isInlineClassWithAssignableUnderlyingType(valueType, returnType)) {
+            return unboxInlineClassIfPossible(value);
+        } else {
+            return value;
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/MockCreationValidator.java b/mockito-core/src/main/java/org/mockito/internal/util/MockCreationValidator.java
similarity index 91%
rename from src/main/java/org/mockito/internal/util/MockCreationValidator.java
rename to mockito-core/src/main/java/org/mockito/internal/util/MockCreationValidator.java
index 5dba3467f1..9db6b36ea3 100644
--- a/src/main/java/org/mockito/internal/util/MockCreationValidator.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/MockCreationValidator.java
@@ -18,14 +18,15 @@
 @SuppressWarnings("unchecked")
 public class MockCreationValidator {
 
-    public void validateType(Class<?> classToMock) {
-        TypeMockability typeMockability = MockUtil.typeMockabilityOf(classToMock);
+    public void validateType(Class<?> classToMock, String mockMaker) {
+        TypeMockability typeMockability = MockUtil.typeMockabilityOf(classToMock, mockMaker);
         if (!typeMockability.mockable()) {
             throw cannotMockClass(classToMock, typeMockability.nonMockableReason());
         }
     }
 
-    public void validateExtraInterfaces(Class<?> classToMock, Collection<Class<?>> extraInterfaces) {
+    public void validateExtraInterfaces(
+            Class<?> classToMock, Collection<Class<?>> extraInterfaces) {
         if (extraInterfaces == null) {
             return;
         }
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/MockNameImpl.java b/mockito-core/src/main/java/org/mockito/internal/util/MockNameImpl.java
new file mode 100644
index 0000000000..41917c657a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/MockNameImpl.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import java.io.Serializable;
+
+import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
+
+public class MockNameImpl implements MockName, Serializable {
+
+    private static final long serialVersionUID = 8014974700844306925L;
+    private final String mockName;
+    private boolean defaultName;
+
+    @SuppressWarnings("unchecked")
+    public MockNameImpl(String mockName, Class<?> type, MockType mockType) {
+        if (mockName == null) {
+            this.mockName = mockType == MockType.STATIC ? toClassName(type) : toInstanceName(type);
+            this.defaultName = true;
+        } else {
+            this.mockName = mockName;
+        }
+    }
+
+    public MockNameImpl(String mockName) {
+        this.mockName = mockName;
+    }
+
+    private static String toInstanceName(Class<?> clazz) {
+        String className = clazz.getSimpleName();
+        if (className.length() == 0) {
+            // it's an anonymous class, let's get name from the parent
+            className = clazz.getSuperclass().getSimpleName();
+        }
+        // lower case first letter
+        return className.substring(0, 1).toLowerCase() + className.substring(1);
+    }
+
+    private static String toClassName(Class<?> clazz) {
+        String className = clazz.getSimpleName();
+        if (className.length() == 0) {
+            // it's an anonymous class, let's get name from the parent
+            className = clazz.getSuperclass().getSimpleName() + "$";
+        }
+        return className + ".class";
+    }
+
+    @Override
+    public boolean isDefault() {
+        return defaultName;
+    }
+
+    @Override
+    public String toString() {
+        return mockName;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/MockUtil.java b/mockito-core/src/main/java/org/mockito/internal/util/MockUtil.java
new file mode 100644
index 0000000000..97b9b49cc1
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/MockUtil.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import org.mockito.MockedConstruction;
+import org.mockito.Mockito;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.internal.configuration.plugins.DefaultMockitoPlugins;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockito.internal.util.reflection.LenientCopyTool;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockName;
+import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockMaker.TypeMockability;
+import org.mockito.plugins.MockResolver;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
+
+@SuppressWarnings("unchecked")
+public class MockUtil {
+
+    private static final MockMaker defaultMockMaker = Plugins.getMockMaker();
+    private static final Map<Class<? extends MockMaker>, MockMaker> mockMakers =
+            new ConcurrentHashMap<>(
+                    Collections.singletonMap(defaultMockMaker.getClass(), defaultMockMaker));
+
+    private MockUtil() {}
+
+    public static MockMaker getMockMaker(String mockMaker) {
+        if (mockMaker == null) {
+            return defaultMockMaker;
+        }
+
+        String typeName;
+        if (DefaultMockitoPlugins.MOCK_MAKER_ALIASES.contains(mockMaker)) {
+            typeName = DefaultMockitoPlugins.getDefaultPluginClass(mockMaker);
+        } else {
+            typeName = mockMaker;
+        }
+
+        Class<? extends MockMaker> type;
+        // Using the context class loader because PluginInitializer.loadImpl is using it as well.
+        // Personally, I am suspicious whether the context class loader is a good choice in either
+        // of these cases.
+        ClassLoader loader = Thread.currentThread().getContextClassLoader();
+        if (loader == null) {
+            loader = ClassLoader.getSystemClassLoader();
+        }
+        try {
+            type = loader.loadClass(typeName).asSubclass(MockMaker.class);
+        } catch (Exception e) {
+            throw new IllegalStateException("Failed to load MockMaker: " + mockMaker, e);
+        }
+
+        return mockMakers.computeIfAbsent(
+                type,
+                t -> {
+                    try {
+                        return t.getDeclaredConstructor().newInstance();
+                    } catch (Exception e) {
+                        throw new IllegalStateException(
+                                "Failed to construct MockMaker: " + t.getName(), e);
+                    }
+                });
+    }
+
+    public static TypeMockability typeMockabilityOf(Class<?> type, String mockMaker) {
+        return getMockMaker(mockMaker).isTypeMockable(type);
+    }
+
+    public static <T> T createMock(MockCreationSettings<T> settings) {
+        MockMaker mockMaker = getMockMaker(settings.getMockMaker());
+        MockHandler mockHandler = createMockHandler(settings);
+
+        Object spiedInstance = settings.getSpiedInstance();
+
+        T mock;
+        if (spiedInstance != null) {
+            mock =
+                    mockMaker
+                            .createSpy(settings, mockHandler, (T) spiedInstance)
+                            .orElseGet(
+                                    () -> {
+                                        T instance = mockMaker.createMock(settings, mockHandler);
+                                        new LenientCopyTool().copyToMock(spiedInstance, instance);
+                                        return instance;
+                                    });
+        } else {
+            mock = mockMaker.createMock(settings, mockHandler);
+        }
+
+        return mock;
+    }
+
+    public static void resetMock(Object mock) {
+        MockHandler oldHandler = getMockHandler(mock);
+        MockCreationSettings settings = oldHandler.getMockSettings();
+        MockHandler newHandler = createMockHandler(settings);
+
+        mock = resolve(mock);
+        getMockMaker(settings.getMockMaker()).resetMock(mock, newHandler, settings);
+    }
+
+    public static MockHandler<?> getMockHandler(Object mock) {
+        MockHandler handler = getMockHandlerOrNull(mock);
+        if (handler != null) {
+            return handler;
+        } else {
+            throw new NotAMockException("Argument should be a mock, but is: " + mock.getClass());
+        }
+    }
+
+    public static InvocationContainerImpl getInvocationContainer(Object mock) {
+        return (InvocationContainerImpl) getMockHandler(mock).getInvocationContainer();
+    }
+
+    public static boolean isSpy(Object mock) {
+        return isMock(mock)
+                && getMockSettings(mock).getDefaultAnswer() == Mockito.CALLS_REAL_METHODS;
+    }
+
+    public static boolean isMock(Object mock) {
+        // TODO SF (perf tweak) in our codebase we call mockMaker.getHandler() multiple times
+        // unnecessarily
+        // This is not ideal because getHandler() can be expensive (reflective calls inside mock
+        // maker)
+        // The frequent pattern in the codebase are separate calls to: 1) isMock(mock) then 2)
+        // getMockHandler(mock)
+        // We could replace it with using mockingDetails().isMock()
+        // Let's refactor the codebase and use new mockingDetails() in all relevant places.
+        // Potentially we could also move other methods to MockitoMock, some other candidates:
+        // getInvocationContainer, isSpy, etc.
+        // This also allows us to reuse our public API MockingDetails
+        if (mock == null) {
+            return false;
+        }
+        return getMockHandlerOrNull(mock) != null;
+    }
+
+    private static MockHandler<?> getMockHandlerOrNull(Object mock) {
+        if (mock == null) {
+            throw new NotAMockException("Argument should be a mock, but is null!");
+        }
+
+        mock = resolve(mock);
+
+        for (MockMaker mockMaker : mockMakers.values()) {
+            MockHandler<?> handler = mockMaker.getHandler(mock);
+            if (handler != null) {
+                assert getMockMaker(handler.getMockSettings().getMockMaker()) == mockMaker;
+                return handler;
+            }
+        }
+        return null;
+    }
+
+    private static Object resolve(Object mock) {
+        if (mock instanceof Class<?>) { // static mocks are resolved by definition
+            return mock;
+        }
+        for (MockResolver mockResolver : Plugins.getMockResolvers()) {
+            mock = mockResolver.resolve(mock);
+        }
+        return mock;
+    }
+
+    public static boolean areSameMocks(Object mockA, Object mockB) {
+        return mockA == mockB || resolve(mockA) == resolve(mockB);
+    }
+
+    public static MockName getMockName(Object mock) {
+        return getMockHandler(mock).getMockSettings().getMockName();
+    }
+
+    public static void maybeRedefineMockName(Object mock, String newName) {
+        MockName mockName = getMockName(mock);
+        // TODO SF hacky...
+        MockCreationSettings mockSettings = getMockHandler(mock).getMockSettings();
+        if (mockName.isDefault() && mockSettings instanceof CreationSettings) {
+            ((CreationSettings) mockSettings).setMockName(new MockNameImpl(newName));
+        }
+    }
+
+    public static MockCreationSettings getMockSettings(Object mock) {
+        return getMockHandler(mock).getMockSettings();
+    }
+
+    public static <T> MockMaker.StaticMockControl<T> createStaticMock(
+            Class<T> type, MockCreationSettings<T> settings) {
+        MockMaker mockMaker = getMockMaker(settings.getMockMaker());
+        MockHandler<T> handler = createMockHandler(settings);
+        return mockMaker.createStaticMock(type, settings, handler);
+    }
+
+    public static <T> MockMaker.ConstructionMockControl<T> createConstructionMock(
+            Class<T> type,
+            Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        Function<MockedConstruction.Context, MockHandler<T>> handlerFactory =
+                context -> createMockHandler(settingsFactory.apply(context));
+        return defaultMockMaker.createConstructionMock(
+                type, settingsFactory, handlerFactory, mockInitializer);
+    }
+
+    public static void clearAllCaches() {
+        for (MockMaker mockMaker : mockMakers.values()) {
+            mockMaker.clearAllCaches();
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java b/mockito-core/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
similarity index 77%
rename from src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
rename to mockito-core/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
index 8fab11e23b..b46f29a090 100644
--- a/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
@@ -9,16 +9,15 @@
 import org.mockito.internal.creation.DelegatingMethod;
 import org.mockito.internal.invocation.MockitoMethod;
 
-public class ObjectMethodsGuru{
+public class ObjectMethodsGuru {
 
-    private ObjectMethodsGuru() {
-    }
+    private ObjectMethodsGuru() {}
 
     public static boolean isToStringMethod(Method method) {
         MockitoMethod m = new DelegatingMethod(method);
-        return m.getReturnType() == String.class &&
-               m.getParameterTypes().length == 0 &&
-               "toString".equals(m.getName());
+        return m.getReturnType() == String.class
+                && m.getParameterTypes().length == 0
+                && "toString".equals(m.getName());
     }
 
     public static boolean isCompareToMethod(Method method) {
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/Platform.java b/mockito-core/src/main/java/org/mockito/internal/util/Platform.java
new file mode 100644
index 0000000000..6ff0378280
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/Platform.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.util.Locale;
+
+public abstract class Platform {
+
+    public static final String JAVA_VERSION = System.getProperty("java.specification.version");
+    public static final String JVM_VERSION = System.getProperty("java.runtime.version");
+    public static final String JVM_VENDOR = System.getProperty("java.vm.vendor");
+    public static final String JVM_VENDOR_VERSION = System.getProperty("java.vm.version");
+    public static final String JVM_NAME = System.getProperty("java.vm.name");
+    public static final String JVM_INFO = System.getProperty("java.vm.info");
+    public static final String OS_NAME = System.getProperty("os.name");
+    public static final String OS_VERSION = System.getProperty("os.version");
+
+    private Platform() {}
+
+    public static boolean isAndroid() {
+        return System.getProperty("java.vendor", "").toLowerCase(Locale.US).contains("android");
+    }
+
+    public static boolean isAndroidMockMakerRequired() {
+        return Boolean.getBoolean("org.mockito.mock.android");
+    }
+
+    public static String describe() {
+        String description =
+                String.format(
+                        "Java               : %s\n"
+                                + "JVM vendor name    : %s\n"
+                                + "JVM vendor version : %s\n"
+                                + "JVM name           : %s\n"
+                                + "JVM version        : %s\n"
+                                + "JVM info           : %s\n"
+                                + "OS name            : %s\n"
+                                + "OS version         : %s\n",
+                        JAVA_VERSION,
+                        JVM_VENDOR,
+                        JVM_VENDOR_VERSION,
+                        JVM_NAME,
+                        JVM_VERSION,
+                        JVM_INFO,
+                        OS_NAME,
+                        OS_VERSION);
+        if (isAndroid()) {
+            description =
+                    join(
+                            "IMPORTANT INFORMATION FOR ANDROID USERS:",
+                            "",
+                            "The regular Byte Buddy mock makers cannot generate code on an Android VM!",
+                            "To resolve this, please use the 'mockito-android' dependency for your application:",
+                            "https://search.maven.org/artifact/org.mockito/mockito-android",
+                            "",
+                            description);
+        }
+        return description;
+    }
+
+    public static String warnForVM(
+            String vmName1, String warnMessage1, String vmName2, String warnMessage2) {
+        return warnForVM(JVM_NAME, vmName1, warnMessage1, vmName2, warnMessage2);
+    }
+
+    static String warnForVM(
+            String current,
+            String vmName1,
+            String warnMessage1,
+            String vmName2,
+            String warnMessage2) {
+        if (vmName1 != null && current.contains(vmName1)) {
+            return warnMessage1;
+        }
+        if (vmName2 != null && current.contains(vmName2)) {
+            return warnMessage2;
+        }
+        return "";
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/Primitives.java b/mockito-core/src/main/java/org/mockito/internal/util/Primitives.java
similarity index 91%
rename from src/main/java/org/mockito/internal/util/Primitives.java
rename to mockito-core/src/main/java/org/mockito/internal/util/Primitives.java
index 80dd0af7d3..ba7e5c7b84 100644
--- a/src/main/java/org/mockito/internal/util/Primitives.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/Primitives.java
@@ -8,11 +8,11 @@
 import java.util.Map;
 
 @SuppressWarnings("unchecked")
-public class Primitives {
-
-    private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPES = new HashMap<Class<?>, Class<?>>();
-    private static final Map<Class<?>, Object> PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES = new HashMap<Class<?>, Object>();
+public final class Primitives {
 
+    private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPES = new HashMap<>();
+    private static final Map<Class<?>, Object> PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES =
+            new HashMap<>();
 
     /**
      * Returns the primitive type of the given class.
@@ -43,8 +43,9 @@ public static boolean isPrimitiveOrWrapper(Class<?> type) {
     }
 
     public static boolean isAssignableFromWrapper(Class<?> valueClass, Class<?> referenceType) {
-        if(isPrimitiveOrWrapper(valueClass) && isPrimitiveOrWrapper(referenceType)) {
-            return Primitives.primitiveTypeOf(valueClass).isAssignableFrom(Primitives.primitiveTypeOf(referenceType));
+        if (isPrimitiveOrWrapper(valueClass) && isPrimitiveOrWrapper(referenceType)) {
+            return Primitives.primitiveTypeOf(valueClass)
+                    .isAssignableFrom(Primitives.primitiveTypeOf(referenceType));
         }
         return false;
     }
@@ -60,7 +61,6 @@ public static <T> T defaultValue(Class<T> primitiveOrWrapperType) {
         return (T) PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.get(primitiveOrWrapperType);
     }
 
-
     static {
         PRIMITIVE_TYPES.put(Boolean.class, Boolean.TYPE);
         PRIMITIVE_TYPES.put(Character.class, Character.TYPE);
@@ -91,4 +91,6 @@ public static <T> T defaultValue(Class<T> primitiveOrWrapperType) {
         PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.put(float.class, 0F);
         PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.put(double.class, 0D);
     }
+
+    private Primitives() {}
 }
diff --git a/src/main/java/org/mockito/internal/util/StringUtil.java b/mockito-core/src/main/java/org/mockito/internal/util/StringUtil.java
similarity index 92%
rename from src/main/java/org/mockito/internal/util/StringUtil.java
rename to mockito-core/src/main/java/org/mockito/internal/util/StringUtil.java
index 3070fe622f..300812d419 100644
--- a/src/main/java/org/mockito/internal/util/StringUtil.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/StringUtil.java
@@ -15,6 +15,7 @@ public class StringUtil {
     private static final Pattern CAPS = Pattern.compile("([A-Z\\d][^A-Z\\d]*)");
 
     private StringUtil() {}
+
     /**
      * @param text
      *            to have the first line removed
@@ -28,7 +29,7 @@ public static String removeFirstLine(String text) {
      * Joins Strings with line break character. It adds line break in front, too.
      * This makes it something like 'format' no really 'join'.
      */
-    public static String join(Object ... linesToBreak) {
+    public static String join(Object... linesToBreak) {
         return join("\n", asList(linesToBreak));
     }
 
@@ -57,10 +58,10 @@ public static String join(String start, String linePrefix, Collection<?> lines)
         for (Object line : lines) {
             out.append(linePrefix).append(line).append("\n");
         }
-        return out.substring(0, out.length() - 1); //lose last EOL
+        return out.substring(0, out.length() - 1); // lose last EOL
     }
 
-    public static String decamelizeMatcher(String className) {
+    public static String decamelizeMatcherName(String className) {
         if (className.length() == 0) {
             return "<custom argument matcher>";
         }
diff --git a/src/main/java/org/mockito/internal/util/Supplier.java b/mockito-core/src/main/java/org/mockito/internal/util/Supplier.java
similarity index 100%
rename from src/main/java/org/mockito/internal/util/Supplier.java
rename to mockito-core/src/main/java/org/mockito/internal/util/Supplier.java
diff --git a/src/main/java/org/mockito/internal/util/Timer.java b/mockito-core/src/main/java/org/mockito/internal/util/Timer.java
similarity index 100%
rename from src/main/java/org/mockito/internal/util/Timer.java
rename to mockito-core/src/main/java/org/mockito/internal/util/Timer.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java b/mockito-core/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
new file mode 100644
index 0000000000..50e194db75
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.collections;
+
+import org.mockito.internal.util.MockUtil;
+
+/**
+ * hashCode and equals safe mock wrapper.
+ *
+ * <p>
+ *     It doesn't use the actual mock {@link Object#hashCode} and {@link Object#equals} method as they might
+ *     throw an NPE if those method cannot be stubbed <em>even internally</em>.
+ * </p>
+ *
+ * <p>
+ *     Instead the strategy is :
+ *     <ul>
+ *         <li>For hashCode : <strong>use {@link System#identityHashCode}</strong></li>
+ *         <li>For equals : <strong>use the object reference equality</strong></li>
+ *     </ul>
+ * </p>
+ *
+ * @see HashCodeAndEqualsSafeSet
+ */
+public class HashCodeAndEqualsMockWrapper {
+
+    private final Object mockInstance;
+
+    public HashCodeAndEqualsMockWrapper(Object mockInstance) {
+        this.mockInstance = mockInstance;
+    }
+
+    public Object get() {
+        return mockInstance;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof HashCodeAndEqualsMockWrapper)) {
+            return false;
+        }
+
+        HashCodeAndEqualsMockWrapper that = (HashCodeAndEqualsMockWrapper) o;
+
+        return mockInstance == that.mockInstance;
+    }
+
+    @Override
+    public int hashCode() {
+        return System.identityHashCode(mockInstance);
+    }
+
+    public static HashCodeAndEqualsMockWrapper of(Object mock) {
+        return new HashCodeAndEqualsMockWrapper(mock);
+    }
+
+    @Override
+    public String toString() {
+        return "HashCodeAndEqualsMockWrapper{"
+                + "mockInstance="
+                + (MockUtil.isMock(mockInstance)
+                        ? MockUtil.getMockName(mockInstance)
+                        : typeInstanceString())
+                + '}';
+    }
+
+    private String typeInstanceString() {
+        return mockInstance.getClass().getSimpleName()
+                + "("
+                + System.identityHashCode(mockInstance)
+                + ")";
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java b/mockito-core/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
similarity index 85%
rename from src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
rename to mockito-core/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
index e35e212ea8..a547067512 100644
--- a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
@@ -31,12 +31,15 @@
  */
 public class HashCodeAndEqualsSafeSet implements Set<Object> {
 
-    private final HashSet<HashCodeAndEqualsMockWrapper> backingHashSet = new HashSet<HashCodeAndEqualsMockWrapper>();
+    private final HashSet<HashCodeAndEqualsMockWrapper> backingHashSet = new HashSet<>();
 
+    @Override
     public Iterator<Object> iterator() {
         return new Iterator<Object>() {
-            private final Iterator<HashCodeAndEqualsMockWrapper> iterator = backingHashSet.iterator();
+            private final Iterator<HashCodeAndEqualsMockWrapper> iterator =
+                    backingHashSet.iterator();
 
+            @Override
             public boolean hasNext() {
                 return iterator.hasNext();
             }
@@ -51,35 +54,43 @@ public void remove() {
         };
     }
 
+    @Override
     public int size() {
         return backingHashSet.size();
     }
 
+    @Override
     public boolean isEmpty() {
         return backingHashSet.isEmpty();
     }
 
+    @Override
     public boolean contains(Object mock) {
         return backingHashSet.contains(HashCodeAndEqualsMockWrapper.of(mock));
     }
 
+    @Override
     public boolean add(Object mock) {
         return backingHashSet.add(HashCodeAndEqualsMockWrapper.of(mock));
     }
 
+    @Override
     public boolean remove(Object mock) {
         return backingHashSet.remove(HashCodeAndEqualsMockWrapper.of(mock));
     }
 
+    @Override
     public void clear() {
         backingHashSet.clear();
     }
 
-    @Override public Object clone() throws CloneNotSupportedException {
+    @Override
+    public Object clone() throws CloneNotSupportedException {
         throw new CloneNotSupportedException();
     }
 
-    @Override public boolean equals(Object o) {
+    @Override
+    public boolean equals(Object o) {
         if (!(o instanceof HashCodeAndEqualsSafeSet)) {
             return false;
         }
@@ -87,7 +98,8 @@ public void clear() {
         return backingHashSet.equals(that.backingHashSet);
     }
 
-    @Override public int hashCode() {
+    @Override
+    public int hashCode() {
         return backingHashSet.hashCode();
     }
 
@@ -95,6 +107,15 @@ public Object[] toArray() {
         return unwrapTo(new Object[size()]);
     }
 
+    @SuppressWarnings("unchecked")
+    public <T> T[] toArray(T[] typedArray) {
+        T[] array =
+                typedArray.length >= size()
+                        ? typedArray
+                        : (T[]) newInstance(typedArray.getClass().getComponentType(), size());
+        return unwrapTo(array);
+    }
+
     @SuppressWarnings("unchecked")
     private <T> T[] unwrapTo(T[] array) {
         Iterator<Object> iterator = iterator();
@@ -106,39 +127,37 @@ private <T> T[] unwrapTo(T[] array) {
         return array;
     }
 
-    @SuppressWarnings("unchecked")
-    public <T> T[] toArray(T[] typedArray) {
-        T[] array = typedArray.length >= size() ? typedArray : (T[]) newInstance(typedArray.getClass().getComponentType(), size());
-        return unwrapTo(array);
-    }
-
     public boolean removeAll(Collection<?> mocks) {
         return backingHashSet.removeAll(asWrappedMocks(mocks));
     }
 
+    @Override
     public boolean containsAll(Collection<?> mocks) {
         return backingHashSet.containsAll(asWrappedMocks(mocks));
     }
 
+    @Override
     public boolean addAll(Collection<?> mocks) {
         return backingHashSet.addAll(asWrappedMocks(mocks));
     }
 
+    @Override
     public boolean retainAll(Collection<?> mocks) {
         return backingHashSet.retainAll(asWrappedMocks(mocks));
     }
 
     private HashSet<HashCodeAndEqualsMockWrapper> asWrappedMocks(Collection<?> mocks) {
         Checks.checkNotNull(mocks, "Passed collection should notify() be null");
-        HashSet<HashCodeAndEqualsMockWrapper> hashSet = new HashSet<HashCodeAndEqualsMockWrapper>();
+        HashSet<HashCodeAndEqualsMockWrapper> hashSet = new HashSet<>();
         for (Object mock : mocks) {
-            assert ! (mock instanceof HashCodeAndEqualsMockWrapper) : "WRONG";
+            assert !(mock instanceof HashCodeAndEqualsMockWrapper) : "WRONG";
             hashSet.add(HashCodeAndEqualsMockWrapper.of(mock));
         }
         return hashSet;
     }
 
-    @Override public String toString() {
+    @Override
+    public String toString() {
         return backingHashSet.toString();
     }
 
diff --git a/src/main/java/org/mockito/internal/util/collections/IdentitySet.java b/mockito-core/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
similarity index 93%
rename from src/main/java/org/mockito/internal/util/collections/IdentitySet.java
rename to mockito-core/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
index 76c6178f45..e0b2359867 100644
--- a/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
@@ -12,7 +12,7 @@ public class IdentitySet {
     private final LinkedList list = new LinkedList();
 
     public boolean contains(Object o) {
-        for(Object existing:list) {
+        for (Object existing : list) {
             if (existing == o) {
                 return true;
             }
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/collections/Iterables.java b/mockito-core/src/main/java/org/mockito/internal/util/collections/Iterables.java
new file mode 100644
index 0000000000..50eb016c06
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/collections/Iterables.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.collections;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+
+/** Utilities for Iterables */
+public final class Iterables {
+
+    /**
+     * Converts enumeration into iterable
+     */
+    public static <T> Iterable<T> toIterable(Enumeration<T> in) {
+        List<T> out = new ArrayList<T>();
+        while (in.hasMoreElements()) {
+            out.add(in.nextElement());
+        }
+        return out;
+    }
+
+    /**
+     * Returns first element of provided iterable or fails fast when iterable is empty.
+     *
+     * @param iterable non-empty iterable
+     * @return first element of supplied iterable
+     * @throws IllegalArgumentException when supplied iterable is empty
+     */
+    public static <T> T firstOf(Iterable<T> iterable) {
+        Iterator<T> iterator = iterable.iterator();
+        if (!iterator.hasNext()) {
+            throw new IllegalArgumentException(
+                    "Cannot provide 1st element from empty iterable: " + iterable);
+        }
+        return iterator.next();
+    }
+
+    private Iterables() {}
+}
diff --git a/src/main/java/org/mockito/internal/util/collections/Sets.java b/mockito-core/src/main/java/org/mockito/internal/util/collections/Sets.java
similarity index 77%
rename from src/main/java/org/mockito/internal/util/collections/Sets.java
rename to mockito-core/src/main/java/org/mockito/internal/util/collections/Sets.java
index 2a71e00ae8..f42f76ac36 100644
--- a/src/main/java/org/mockito/internal/util/collections/Sets.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/collections/Sets.java
@@ -18,9 +18,10 @@ public static Set<Object> newMockSafeHashSet(Object... mocks) {
         return HashCodeAndEqualsSafeSet.of(mocks);
     }
 
-    public static <T> Set<T> newSet(T ... elements) {
+    public static <T> Set<T> newSet(T... elements) {
         if (elements == null) {
-            throw new IllegalArgumentException("Expected an array of elements (or empty array) but received a null.");
+            throw new IllegalArgumentException(
+                    "Expected an array of elements (or empty array) but received a null.");
         }
         return new LinkedHashSet<T>(asList(elements));
     }
diff --git a/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
similarity index 80%
rename from src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
rename to mockito-core/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
index 3768a03d61..9a81403036 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
@@ -19,20 +19,22 @@ public DetachedThreadLocal(Cleaner cleaner) {
         switch (cleaner) {
             case THREAD:
             case MANUAL:
-                map = new WeakConcurrentMap<Thread, T>(cleaner == Cleaner.THREAD) {
-                    @Override
-                    protected T defaultValue(Thread key) {
-                        return DetachedThreadLocal.this.initialValue(key);
-                    }
-                };
+                map =
+                        new WeakConcurrentMap<Thread, T>(cleaner == Cleaner.THREAD) {
+                            @Override
+                            protected T defaultValue(Thread key) {
+                                return DetachedThreadLocal.this.initialValue(key);
+                            }
+                        };
                 break;
             case INLINE:
-                map = new WeakConcurrentMap.WithInlinedExpunction<Thread, T>() {
-                    @Override
-                    protected T defaultValue(Thread key) {
-                        return DetachedThreadLocal.this.initialValue(key);
-                    }
-                };
+                map =
+                        new WeakConcurrentMap.WithInlinedExpunction<Thread, T>() {
+                            @Override
+                            protected T defaultValue(Thread key) {
+                                return DetachedThreadLocal.this.initialValue(key);
+                            }
+                        };
                 break;
             default:
                 throw new AssertionError();
@@ -43,6 +45,14 @@ public T get() {
         return map.get(Thread.currentThread());
     }
 
+    /**
+     * @param thread The thread for which to set a thread-local value.
+     * @return The value associated with this thread.
+     */
+    public T get(Thread thread) {
+        return map.get(thread);
+    }
+
     public void set(T value) {
         map.put(Thread.currentThread(), value);
     }
@@ -84,15 +94,7 @@ public T fetchFrom(Thread thread) {
 
     /**
      * @param thread The thread for which to set a thread-local value.
-     * @return The value associated with this thread.
-     */
-    public T get(Thread thread) {
-        return map.get(thread);
-    }
-
-    /**
-     * @param thread The thread for which to set a thread-local value.
-     * @param value  The value to set.
+     * @param value The value to set.
      */
     public void define(Thread thread, T value) {
         map.put(thread, value);
@@ -133,6 +135,8 @@ public void run() {
      * ({@link Cleaner#MANUAL}).
      */
     public enum Cleaner {
-        THREAD, INLINE, MANUAL
+        THREAD,
+        INLINE,
+        MANUAL
     }
 }
diff --git a/src/main/java/org/mockito/internal/util/concurrent/LICENSE b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/LICENSE
similarity index 100%
rename from src/main/java/org/mockito/internal/util/concurrent/LICENSE
rename to mockito-core/src/main/java/org/mockito/internal/util/concurrent/LICENSE
diff --git a/src/main/java/org/mockito/internal/util/concurrent/README.md b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/README.md
similarity index 100%
rename from src/main/java/org/mockito/internal/util/concurrent/README.md
rename to mockito-core/src/main/java/org/mockito/internal/util/concurrent/README.md
diff --git a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
similarity index 94%
rename from src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
rename to mockito-core/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
index 487d223a8f..e25c41c58f 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
@@ -22,7 +22,8 @@
  * This class does not implement the {@link java.util.Map} interface because this implementation is incompatible
  * with the map contract. While iterating over a map's entries, any key that has not passed iteration is referenced non-weakly.
  */
-public class WeakConcurrentMap<K, V> extends ReferenceQueue<K> implements Runnable, Iterable<Map.Entry<K, V>> {
+public class WeakConcurrentMap<K, V> extends ReferenceQueue<K>
+        implements Runnable, Iterable<Map.Entry<K, V>> {
 
     private static final AtomicLong ID = new AtomicLong();
 
@@ -34,7 +35,7 @@ public class WeakConcurrentMap<K, V> extends ReferenceQueue<K> implements Runnab
      * @param cleanerThread {@code true} if a thread should be started that removes stale entries.
      */
     public WeakConcurrentMap(boolean cleanerThread) {
-        target = new ConcurrentHashMap<WeakKey<K>, V>();
+        target = new ConcurrentHashMap<>();
         if (cleanerThread) {
             thread = new Thread(this);
             thread.setName("weak-ref-cleaner-" + ID.getAndIncrement());
@@ -52,7 +53,9 @@ public WeakConcurrentMap(boolean cleanerThread) {
      */
     @SuppressWarnings("CollectionIncompatibleType")
     public V get(K key) {
-        if (key == null) throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException();
+        }
         V value = target.get(new LatentKey<K>(key));
         if (value == null) {
             value = defaultValue(key);
@@ -72,7 +75,9 @@ public V get(K key) {
      */
     @SuppressWarnings("CollectionIncompatibleType")
     public boolean containsKey(K key) {
-        if (key == null) throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException();
+        }
         return target.containsKey(new LatentKey<K>(key));
     }
 
@@ -82,7 +87,9 @@ public boolean containsKey(K key) {
      * @return The previous entry or {@code null} if it does not exist.
      */
     public V put(K key, V value) {
-        if (key == null || value == null) throw new NullPointerException();
+        if (key == null || value == null) {
+            throw new NullPointerException();
+        }
         return target.put(new WeakKey<K>(key, this), value);
     }
 
@@ -92,7 +99,9 @@ public V put(K key, V value) {
      */
     @SuppressWarnings("CollectionIncompatibleType")
     public V remove(K key) {
-        if (key == null) throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException();
+        }
         return target.remove(new LatentKey<K>(key));
     }
 
@@ -360,7 +369,9 @@ public V getValue() {
 
         @Override
         public V setValue(V value) {
-            if (value == null) throw new NullPointerException();
+            if (value == null) {
+                throw new NullPointerException();
+            }
             return entry.setValue(value);
         }
     }
diff --git a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
similarity index 95%
rename from src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
rename to mockito-core/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
index 0f1cde638d..d18dc3b7c7 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
@@ -21,11 +21,11 @@ public class WeakConcurrentSet<V> implements Runnable, Iterable<V> {
     public WeakConcurrentSet(Cleaner cleaner) {
         switch (cleaner) {
             case INLINE:
-                target = new WeakConcurrentMap.WithInlinedExpunction<V, Boolean>();
+                target = new WeakConcurrentMap.WithInlinedExpunction<>();
                 break;
             case THREAD:
             case MANUAL:
-                target = new WeakConcurrentMap<V, Boolean>(cleaner == Cleaner.THREAD);
+                target = new WeakConcurrentMap<>(cleaner == Cleaner.THREAD);
                 break;
             default:
                 throw new AssertionError();
@@ -53,7 +53,7 @@ public boolean contains(V value) {
      * @return {@code true} if the value is contained in the set.
      */
     public boolean remove(V value) {
-        return target.remove(value);
+        return target.remove(value) != null;
     }
 
     /**
@@ -84,7 +84,9 @@ public void run() {
      * ({@link Cleaner#MANUAL}).
      */
     public enum Cleaner {
-        THREAD, INLINE, MANUAL
+        THREAD,
+        INLINE,
+        MANUAL
     }
 
     /**
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/io/IOUtil.java b/mockito-core/src/main/java/org/mockito/internal/util/io/IOUtil.java
new file mode 100644
index 0000000000..f77dfda1c3
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/io/IOUtil.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.io;
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import org.mockito.exceptions.base.MockitoException;
+
+/**
+ * IO utils. A bit of reinventing the wheel but we don't want extra dependencies at this stage and
+ * we want to be java.
+ */
+public final class IOUtil {
+
+    /**
+     * Writes text to file in UTF-8.
+     */
+    public static void writeText(String text, File output) {
+        OutputStreamWriter pw = null;
+        try {
+            pw = new OutputStreamWriter(new FileOutputStream(output), StandardCharsets.UTF_8);
+            pw.write(text);
+        } catch (Exception e) {
+            throw new MockitoException("Problems writing text to file: " + output, e);
+        } finally {
+            close(pw);
+        }
+    }
+
+    /**
+     * Reads all lines from the given stream. Uses UTF-8.
+     */
+    public static Collection<String> readLines(InputStream is) {
+        List<String> out = new LinkedList<>();
+        BufferedReader r = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
+        String line;
+        try {
+            while ((line = r.readLine()) != null) {
+                out.add(line);
+            }
+        } catch (IOException e) {
+            throw new MockitoException("Problems reading from: " + is, e);
+        }
+        return out;
+    }
+
+    /**
+     * Closes the target. Does nothing when target is null. Is silent.
+     *
+     * @param closeable the target, may be null
+     */
+    public static void closeQuietly(Closeable closeable) {
+        try {
+            close(closeable);
+        } catch (MockitoException ignored) {
+            // ignore, for backwards compatibility
+        }
+    }
+
+    /**
+     * Closes the target. Does nothing when target is null. Is not silent and exceptions are rethrown.
+     *
+     * @param closeable the target, may be null
+     */
+    public static void close(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (IOException e) {
+                throw new MockitoException("Problems closing stream: " + closeable, e);
+            }
+        }
+    }
+
+    private IOUtil() {}
+}
diff --git a/src/main/java/org/mockito/internal/util/package-info.java b/mockito-core/src/main/java/org/mockito/internal/util/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/util/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/util/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
new file mode 100644
index 0000000000..d904f62a5b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Locale;
+
+/**
+ * This utility class will call the setter of the property to inject a new value.
+ */
+public class BeanPropertySetter {
+
+    private static final String SET_PREFIX = "set";
+
+    private final Object target;
+    private final boolean reportNoSetterFound;
+    private final Field field;
+
+    /**
+     * New BeanPropertySetter
+     * @param target The target on which the setter must be invoked
+     * @param propertyField The field that should be accessed with the setter
+     * @param reportNoSetterFound Allow the set method to raise an Exception if the setter cannot be found
+     */
+    public BeanPropertySetter(
+            final Object target, final Field propertyField, boolean reportNoSetterFound) {
+        this.field = propertyField;
+        this.target = target;
+        this.reportNoSetterFound = reportNoSetterFound;
+    }
+
+    /**
+     * New BeanPropertySetter that don't report failure
+     * @param target The target on which the setter must be invoked
+     * @param propertyField The propertyField that must be accessed through a setter
+     */
+    public BeanPropertySetter(final Object target, final Field propertyField) {
+        this(target, propertyField, false);
+    }
+
+    /**
+     * Set the value to the property represented by this {@link BeanPropertySetter}
+     * @param value the new value to pass to the property setter
+     * @return <code>true</code> if the value has been injected, <code>false</code> otherwise
+     * @throws RuntimeException Can be thrown if the setter threw an exception, if the setter is not accessible
+     *          or, if <code>reportNoSetterFound</code> and setter could not be found.
+     */
+    public boolean set(final Object value) {
+
+        MemberAccessor accessor = Plugins.getMemberAccessor();
+        Method writeMethod = null;
+        try {
+            writeMethod = target.getClass().getMethod(setterName(field.getName()), field.getType());
+            accessor.invoke(writeMethod, target, value);
+            return true;
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException(
+                    "Setter '"
+                            + writeMethod
+                            + "' of '"
+                            + target
+                            + "' with value '"
+                            + value
+                            + "' threw exception : '"
+                            + e.getTargetException()
+                            + "'",
+                    e);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(
+                    "Access not authorized on field '"
+                            + field
+                            + "' of object '"
+                            + target
+                            + "' with value: '"
+                            + value
+                            + "'",
+                    e);
+        } catch (NoSuchMethodException e) {
+            reportNoSetterFound();
+        }
+
+        reportNoSetterFound();
+        return false;
+    }
+
+    /**
+     * Retrieve the setter name from the field name.
+     *
+     * <p>Implementation is based on the code of {@link java.beans.Introspector}.</p>
+     *
+     * @param fieldName the Field name
+     * @return Setter name.
+     */
+    private String setterName(String fieldName) {
+        return new StringBuilder(SET_PREFIX)
+                .append(fieldName.substring(0, 1).toUpperCase(Locale.ENGLISH))
+                .append(fieldName, 1, fieldName.length())
+                .toString();
+    }
+
+    private void reportNoSetterFound() {
+        if (reportNoSetterFound) {
+            throw new RuntimeException(
+                    "Problems setting value on object: ["
+                            + target
+                            + "] for property : ["
+                            + field.getName()
+                            + "], setter not found");
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
similarity index 90%
rename from src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
rename to mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
index 957832ee00..13d9c5d7ef 100644
--- a/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
@@ -12,7 +12,10 @@ public class FieldInitializationReport {
     private final boolean wasInitialized;
     private final boolean wasInitializedUsingConstructorArgs;
 
-    public FieldInitializationReport(Object fieldInstance, boolean wasInitialized, boolean wasInitializedUsingConstructorArgs) {
+    public FieldInitializationReport(
+            Object fieldInstance,
+            boolean wasInitialized,
+            boolean wasInitializedUsingConstructorArgs) {
         this.fieldInstance = fieldInstance;
         this.wasInitialized = wasInitialized;
         this.wasInitializedUsingConstructorArgs = wasInitializedUsingConstructorArgs;
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
new file mode 100644
index 0000000000..7d51a6bb1b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import static java.lang.reflect.Modifier.isStatic;
+
+/**
+ * Initialize a field with type instance if a default constructor can be found.
+ *
+ * <p>
+ * If the given field is already initialized, then <strong>the actual instance is returned</strong>.
+ * This initializer doesn't work with inner classes, local classes, interfaces or abstract types.
+ * </p>
+ *
+ */
+public class FieldInitializer {
+
+    private final Object fieldOwner;
+    private final Field field;
+    private final ConstructorInstantiator instantiator;
+
+    /**
+     * Prepare initializer with the given field on the given instance.
+     *
+     * <p>
+     * This constructor fail fast if the field type cannot be handled.
+     * </p>
+     *
+     * @param fieldOwner Instance of the test.
+     * @param field Field to be initialize.
+     */
+    public FieldInitializer(Object fieldOwner, Field field) {
+        this(fieldOwner, field, new NoArgConstructorInstantiator(fieldOwner, field));
+    }
+
+    /**
+     * Prepare initializer with the given field on the given instance.
+     *
+     * <p>
+     * This constructor fail fast if the field type cannot be handled.
+     * </p>
+     *
+     * @param fieldOwner Instance of the test.
+     * @param field Field to be initialize.
+     * @param argResolver Constructor parameters resolver
+     */
+    public FieldInitializer(
+            Object fieldOwner, Field field, ConstructorArgumentResolver argResolver) {
+        this(
+                fieldOwner,
+                field,
+                new ParameterizedConstructorInstantiator(fieldOwner, field, argResolver));
+    }
+
+    private FieldInitializer(Object fieldOwner, Field field, ConstructorInstantiator instantiator) {
+        if (new FieldReader(fieldOwner, field).isNull()) {
+            checkNotLocal(field);
+            checkNotInner(field);
+            checkNotInterface(field);
+            checkNotEnum(field);
+            checkNotAbstract(field);
+        }
+        this.fieldOwner = fieldOwner;
+        this.field = field;
+        this.instantiator = instantiator;
+    }
+
+    /**
+     * Initialize field if not initialized and return the actual instance.
+     *
+     * @return Actual field instance.
+     */
+    public FieldInitializationReport initialize() {
+        try {
+            return acquireFieldInstance();
+        } catch (IllegalAccessException e) {
+            throw new MockitoException(
+                    "Problems initializing field '"
+                            + field.getName()
+                            + "' of type '"
+                            + field.getType().getSimpleName()
+                            + "'",
+                    e);
+        }
+    }
+
+    private void checkNotLocal(Field field) {
+        if (field.getType().isLocalClass()) {
+            throw new MockitoException(
+                    "the type '" + field.getType().getSimpleName() + "' is a local class.");
+        }
+    }
+
+    private void checkNotInner(Field field) {
+        Class<?> type = field.getType();
+        if (type.isMemberClass() && !isStatic(type.getModifiers())) {
+            throw new MockitoException(
+                    "the type '" + type.getSimpleName() + "' is an inner non static class.");
+        }
+    }
+
+    private void checkNotInterface(Field field) {
+        if (field.getType().isInterface()) {
+            throw new MockitoException(
+                    "the type '" + field.getType().getSimpleName() + "' is an interface.");
+        }
+    }
+
+    private void checkNotAbstract(Field field) {
+        if (Modifier.isAbstract(field.getType().getModifiers())) {
+            throw new MockitoException(
+                    "the type '" + field.getType().getSimpleName() + "' is an abstract class.");
+        }
+    }
+
+    private void checkNotEnum(Field field) {
+        if (field.getType().isEnum()) {
+            throw new MockitoException(
+                    "the type '" + field.getType().getSimpleName() + "' is an enum.");
+        }
+    }
+
+    private FieldInitializationReport acquireFieldInstance() throws IllegalAccessException {
+        final MemberAccessor accessor = Plugins.getMemberAccessor();
+        Object fieldInstance = accessor.get(field, fieldOwner);
+        if (fieldInstance != null) {
+            return new FieldInitializationReport(fieldInstance, false, false);
+        }
+
+        return instantiator.instantiate();
+    }
+
+    /**
+     * Represents the strategy used to resolve actual instances
+     * to be given to a constructor given the argument types.
+     */
+    public interface ConstructorArgumentResolver {
+
+        /**
+         * Try to resolve instances from types.
+         *
+         * <p>
+         * Checks on the real argument type or on the correct argument number
+         * will happen during the field initialization {@link FieldInitializer#initialize()}.
+         * I.e the only responsibility of this method, is to provide instances <strong>if possible</strong>.
+         * </p>
+         *
+         * @param argTypes Constructor argument types, should not be null.
+         * @return The argument instances to be given to the constructor, should not be null.
+         */
+        Object[] resolveTypeInstances(Class<?>... argTypes);
+    }
+
+    private interface ConstructorInstantiator {
+        FieldInitializationReport instantiate();
+    }
+
+    /**
+     * Constructor instantiating strategy for no-arg constructor.
+     *
+     * <p>
+     * If a no-arg constructor can be found then the instance is created using
+     * this constructor.
+     * Otherwise a technical MockitoException is thrown.
+     * </p>
+     */
+    static class NoArgConstructorInstantiator implements ConstructorInstantiator {
+        private final Object testClass;
+        private final Field field;
+
+        /**
+         * Internal, checks are done by FieldInitializer.
+         * Fields are assumed to be accessible.
+         */
+        NoArgConstructorInstantiator(Object testClass, Field field) {
+            this.testClass = testClass;
+            this.field = field;
+        }
+
+        @Override
+        public FieldInitializationReport instantiate() {
+            final MemberAccessor invoker = Plugins.getMemberAccessor();
+            try {
+                Constructor<?> constructor = field.getType().getDeclaredConstructor();
+
+                final Object[] noArg = new Object[0];
+                Object newFieldInstance = invoker.newInstance(constructor, noArg);
+                invoker.set(field, testClass, newFieldInstance);
+
+                return new FieldInitializationReport(invoker.get(field, testClass), true, false);
+            } catch (NoSuchMethodException e) {
+                throw new MockitoException(
+                        "the type '"
+                                + field.getType().getSimpleName()
+                                + "' has no default constructor",
+                        e);
+            } catch (InvocationTargetException e) {
+                throw new MockitoException(
+                        "the default constructor of type '"
+                                + field.getType().getSimpleName()
+                                + "' has raised an exception (see the stack trace for cause): "
+                                + e.getTargetException(),
+                        e);
+            } catch (InstantiationException e) {
+                throw new MockitoException(
+                        "InstantiationException (see the stack trace for cause): " + e, e);
+            } catch (IllegalAccessException e) {
+                throw new MockitoException(
+                        "IllegalAccessException (see the stack trace for cause): " + e, e);
+            }
+        }
+    }
+
+    /**
+     * Constructor instantiating strategy for parameterized constructors.
+     *
+     * <p>
+     * Choose the constructor with the highest number of parameters, then
+     * call the ConstructorArgResolver to get actual argument instances.
+     * If the argResolver fail, then a technical MockitoException is thrown is thrown.
+     * Otherwise the instance is created with the resolved arguments.
+     * </p>
+     */
+    static class ParameterizedConstructorInstantiator implements ConstructorInstantiator {
+        private final Object testClass;
+        private final Field field;
+        private final ConstructorArgumentResolver argResolver;
+        private final Comparator<Constructor<?>> byParameterNumber =
+                new Comparator<Constructor<?>>() {
+                    @Override
+                    public int compare(Constructor<?> constructorA, Constructor<?> constructorB) {
+                        int argLengths =
+                                constructorB.getParameterTypes().length
+                                        - constructorA.getParameterTypes().length;
+                        if (argLengths == 0) {
+                            int constructorAMockableParamsSize = countMockableParams(constructorA);
+                            int constructorBMockableParamsSize = countMockableParams(constructorB);
+                            return constructorBMockableParamsSize - constructorAMockableParamsSize;
+                        }
+                        return argLengths;
+                    }
+
+                    private int countMockableParams(Constructor<?> constructor) {
+                        int constructorMockableParamsSize = 0;
+                        for (Class<?> aClass : constructor.getParameterTypes()) {
+                            // The argResolver already knows the concrete types it can provide.
+                            // Instead of checking for mockability, I think it would be better to
+                            // ask the argResolver whether it can resolve this type.
+                            // Anyway, I keep it for now to avoid breaking any existing code.
+                            if (MockUtil.typeMockabilityOf(aClass, null).mockable()) {
+                                constructorMockableParamsSize++;
+                            }
+                        }
+                        return constructorMockableParamsSize;
+                    }
+                };
+
+        /**
+         * Internal, checks are done by FieldInitializer.
+         * Fields are assumed to be accessible.
+         */
+        ParameterizedConstructorInstantiator(
+                Object testClass, Field field, ConstructorArgumentResolver argumentResolver) {
+            this.testClass = testClass;
+            this.field = field;
+            this.argResolver = argumentResolver;
+        }
+
+        @Override
+        public FieldInitializationReport instantiate() {
+            final MemberAccessor accessor = Plugins.getMemberAccessor();
+            Constructor<?> constructor = biggestConstructor(field.getType());
+            final Object[] args = argResolver.resolveTypeInstances(constructor.getParameterTypes());
+            try {
+                Object newFieldInstance = accessor.newInstance(constructor, args);
+                accessor.set(field, testClass, newFieldInstance);
+
+                return new FieldInitializationReport(accessor.get(field, testClass), false, true);
+            } catch (IllegalArgumentException e) {
+                throw new MockitoException(
+                        "internal error : argResolver provided incorrect types for constructor "
+                                + constructor
+                                + " of type "
+                                + field.getType().getSimpleName(),
+                        e);
+            } catch (InvocationTargetException e) {
+                throw new MockitoException(
+                        "the constructor of type '"
+                                + field.getType().getSimpleName()
+                                + "' has raised an exception (see the stack trace for cause): "
+                                + e.getTargetException(),
+                        e);
+            } catch (InstantiationException e) {
+                throw new MockitoException(
+                        "InstantiationException (see the stack trace for cause): " + e, e);
+            } catch (IllegalAccessException e) {
+                throw new MockitoException(
+                        "IllegalAccessException (see the stack trace for cause): " + e, e);
+            }
+        }
+
+        private void checkParameterized(Constructor<?> constructor, Field field) {
+            if (constructor.getParameterTypes().length == 0) {
+                throw new MockitoException(
+                        "the field "
+                                + field.getName()
+                                + " of type "
+                                + field.getType()
+                                + " has no parameterized constructor");
+            }
+        }
+
+        private Constructor<?> biggestConstructor(Class<?> clazz) {
+            final List<? extends Constructor<?>> constructors =
+                    Arrays.asList(clazz.getDeclaredConstructors());
+            Collections.sort(constructors, byParameterNumber);
+
+            Constructor<?> constructor = constructors.get(0);
+            checkParameterized(constructor, field);
+            return constructor;
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldReader.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
new file mode 100644
index 0000000000..6c3c120ee9
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import java.lang.reflect.Field;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
+public class FieldReader {
+
+    final Object target;
+    final Field field;
+    final MemberAccessor accessor = Plugins.getMemberAccessor();
+
+    public FieldReader(Object target, Field field) {
+        this.target = target;
+        this.field = field;
+    }
+
+    public boolean isNull() {
+        return read() == null;
+    }
+
+    public Object read() {
+        try {
+            return accessor.get(field, target);
+        } catch (Exception e) {
+            throw new MockitoException(
+                    "Cannot read state from field: " + field + ", on instance: " + target, e);
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
new file mode 100644
index 0000000000..c5c3581f6d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+public class GenericMaster {
+
+    /**
+     * Finds the generic type (parametrized type) of the field. If the field is not generic it returns Object.class.
+     *
+     * @param field the field to inspect
+     */
+    public Class<?> getGenericType(Field field) {
+        Type generic = field.getGenericType();
+        return getaClass(generic);
+    }
+
+    /**
+     * Resolves the type (parametrized type) of the parameter. If the field is not generic it returns Object.class.
+     *
+     * @param parameter the parameter to inspect
+     */
+    public Class<?> getGenericType(Parameter parameter) {
+        return getaClass(parameter.getParameterizedType());
+    }
+
+    private Class<?> getaClass(Type generic) {
+        if (generic instanceof ParameterizedType) {
+            Type actual = ((ParameterizedType) generic).getActualTypeArguments()[0];
+            if (actual instanceof Class) {
+                return (Class<?>) actual;
+            } else if (actual instanceof ParameterizedType) {
+                // in case of nested generics we don't go deep
+                return (Class<?>) ((ParameterizedType) actual).getRawType();
+            }
+        }
+
+        return Object.class;
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
similarity index 80%
rename from src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
rename to mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
index 4499a4d7d4..d8c53d07c0 100644
--- a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.internal.util.reflection;
 
-
 import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
@@ -22,11 +21,9 @@
 import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
-
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.util.Checks;
 
-
 /**
  * This class can retrieve generic meta-data that the compiler stores on classes
  * and accessible members.
@@ -51,7 +48,7 @@
  * <p>
  * For now this code support the following kind of generic declarations :
  * <pre class="code"><code class="java">
- * interface GenericsNest&lt;K extends Comparable&lt;K&gt; & Cloneable&gt; extends Map&lt;K, Set&lt;Number&gt;&gt; {
+ * interface GenericsNest&lt;K extends Comparable&lt;K&gt; &amp; Cloneable&gt; extends Map&lt;K, Set&lt;Number&gt;&gt; {
  *     Set&lt;Number&gt; remove(Object key); // override with fixed ParameterizedType
  *     List&lt;? super Integer&gt; returning_wildcard_with_class_lower_bound();
  *     List&lt;? super K&gt; returning_wildcard_with_typeVar_lower_bound();
@@ -72,10 +69,8 @@ public abstract class GenericMetadataSupport {
 
     // public static MockitoLogger logger = new ConsoleMockitoLogger();
 
-    /**
-     * Represents actual type variables resolved for current class.
-     */
-    protected Map<TypeVariable<?>, Type> contextualActualTypeParameters = new HashMap<TypeVariable<?>, Type>();
+    /** Represents actual type variables resolved for current class. */
+    protected Map<TypeVariable<?>, Type> contextualActualTypeParameters = new HashMap<>();
 
     /**
      * Registers the type variables for the given type and all of its superclasses and superinterfaces.
@@ -96,7 +91,7 @@ protected void registerAllTypeVariables(Type classType) {
 
             Class<?> rawType = extractRawTypeOf(typeToRegister);
             typesToRegister.add(rawType.getGenericSuperclass());
-            typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces()));
+            Collections.addAll(typesToRegister, rawType.getGenericInterfaces());
         }
     }
 
@@ -126,7 +121,8 @@ protected void registerTypeVariablesOn(Type classType) {
             return;
         }
         ParameterizedType parameterizedType = (ParameterizedType) classType;
-        TypeVariable<?>[] typeParameters = ((Class<?>) parameterizedType.getRawType()).getTypeParameters();
+        TypeVariable<?>[] typeParameters =
+                ((Class<?>) parameterizedType.getRawType()).getTypeParameters();
         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
         for (int i = 0; i < actualTypeArguments.length; i++) {
             TypeVariable<?> typeParameter = typeParameters[i];
@@ -142,19 +138,24 @@ protected void registerTypeVariablesOn(Type classType) {
                  */
                 registerTypeVariableIfNotPresent((TypeVariable<?>) actualTypeArgument);
 
-                // Prevent registration of a cycle of TypeVariables. This can happen when we are processing
-                // type parameters in a Method, while we already processed the type parameters of a class.
+                // Prevent registration of a cycle of TypeVariables. This can happen when we are
+                // processing
+                // type parameters in a Method, while we already processed the type parameters of a
+                // class.
                 if (contextualActualTypeParameters.containsKey(typeParameter)) {
                     continue;
                 }
             }
 
             if (actualTypeArgument instanceof WildcardType) {
-                contextualActualTypeParameters.put(typeParameter, boundsOf((WildcardType) actualTypeArgument));
+                contextualActualTypeParameters.put(
+                        typeParameter, boundsOf((WildcardType) actualTypeArgument));
             } else if (typeParameter != actualTypeArgument) {
                 contextualActualTypeParameters.put(typeParameter, actualTypeArgument);
             }
-            // logger.log("For '" + parameterizedType + "' found type variable : { '" + typeParameter + "(" + System.identityHashCode(typeParameter) + ")" + "' : '" + actualTypeArgument + "(" + System.identityHashCode(typeParameter) + ")" + "' }");
+            // logger.log("For '" + parameterizedType + "' found type variable : { '" +
+            // typeParameter + "(" + System.identityHashCode(typeParameter) + ")" + "' : '" +
+            // actualTypeArgument + "(" + System.identityHashCode(typeParameter) + ")" + "' }");
         }
     }
 
@@ -167,7 +168,9 @@ protected void registerTypeParametersOn(TypeVariable<?>[] typeParameters) {
     private void registerTypeVariableIfNotPresent(TypeVariable<?> typeVariable) {
         if (!contextualActualTypeParameters.containsKey(typeVariable)) {
             contextualActualTypeParameters.put(typeVariable, boundsOf(typeVariable));
-            // logger.log("For '" + typeVariable.getGenericDeclaration() + "' found type variable : { '" + typeVariable + "(" + System.identityHashCode(typeVariable) + ")" + "' : '" + boundsOf(typeVariable) + "' }");
+            // logger.log("For '" + typeVariable.getGenericDeclaration() + "' found type variable :
+            // { '" + typeVariable + "(" + System.identityHashCode(typeVariable) + ")" + "' : '" +
+            // boundsOf(typeVariable) + "' }");
         }
     }
 
@@ -190,7 +193,7 @@ private BoundedType boundsOf(TypeVariable<?> typeParameter) {
      */
     private BoundedType boundsOf(WildcardType wildCard) {
         /*
-         *  According to JLS(http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.5.1):
+         *  According to JLS(https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1):
          *  - Lower and upper can't coexist: (for instance, this is not allowed:
          *    <? extends List<String> & super MyInterface>)
          *  - Multiple concrete type bounds are not supported (for instance, this is not allowed:
@@ -238,14 +241,16 @@ public boolean hasRawExtraInterfaces() {
      */
     public Map<TypeVariable<?>, Type> actualTypeArguments() {
         TypeVariable<?>[] typeParameters = rawType().getTypeParameters();
-        LinkedHashMap<TypeVariable<?>, Type> actualTypeArguments = new LinkedHashMap<TypeVariable<?>, Type>();
+        LinkedHashMap<TypeVariable<?>, Type> actualTypeArguments = new LinkedHashMap<>();
 
         for (TypeVariable<?> typeParameter : typeParameters) {
 
             Type actualType = getActualTypeArgumentFor(typeParameter);
 
             actualTypeArguments.put(typeParameter, actualType);
-            // logger.log("For '" + rawType().getCanonicalName() + "' returning explicit TypeVariable : { '" + typeParameter + "(" + System.identityHashCode(typeParameter) + ")" + "' : '" + actualType +"' }");
+            // logger.log("For '" + rawType().getCanonicalName() + "' returning explicit
+            // TypeVariable : { '" + typeParameter + "(" + System.identityHashCode(typeParameter) +
+            // ")" + "' : '" + actualType +"' }");
         }
 
         return actualTypeArguments;
@@ -269,7 +274,9 @@ protected Type getActualTypeArgumentFor(TypeVariable<?> typeParameter) {
      */
     public GenericMetadataSupport resolveGenericReturnType(Method method) {
         Type genericReturnType = method.getGenericReturnType();
-        // logger.log("Method '" + method.toGenericString() + "' has return type : " + genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " + genericReturnType);
+        // logger.log("Method '" + method.toGenericString() + "' has return type : " +
+        // genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " +
+        // genericReturnType);
 
         int arity = 0;
         while (genericReturnType instanceof GenericArrayType) {
@@ -277,7 +284,8 @@ public GenericMetadataSupport resolveGenericReturnType(Method method) {
             genericReturnType = ((GenericArrayType) genericReturnType).getGenericComponentType();
         }
 
-        GenericMetadataSupport genericMetadataSupport = resolveGenericType(genericReturnType, method);
+        GenericMetadataSupport genericMetadataSupport =
+                resolveGenericType(genericReturnType, method);
         if (arity == 0) {
             return genericMetadataSupport;
         } else {
@@ -291,13 +299,21 @@ private GenericMetadataSupport resolveGenericType(Type type, Method method) {
             return new NotGenericReturnTypeSupport(this, type);
         }
         if (type instanceof ParameterizedType) {
-            return new ParameterizedReturnType(this, method.getTypeParameters(), (ParameterizedType) type);
+            return new ParameterizedReturnType(
+                    this, method.getTypeParameters(), (ParameterizedType) type);
         }
         if (type instanceof TypeVariable) {
-            return new TypeVariableReturnType(this, method.getTypeParameters(), (TypeVariable<?>) type);
+            return new TypeVariableReturnType(
+                    this, method.getTypeParameters(), (TypeVariable<?>) type);
         }
 
-        throw new MockitoException("Ouch, it shouldn't happen, type '" + type.getClass().getCanonicalName() + "' on method : '" + method.toGenericString() + "' is not supported : " + type);
+        throw new MockitoException(
+                "Ouch, it shouldn't happen, type '"
+                        + type.getClass().getCanonicalName()
+                        + "' on method : '"
+                        + method.toGenericString()
+                        + "' is not supported : "
+                        + type);
     }
 
     /**
@@ -321,12 +337,16 @@ public static GenericMetadataSupport inferFrom(Type type) {
             return new FromParameterizedTypeGenericMetadataSupport((ParameterizedType) type);
         }
 
-        throw new MockitoException("Type meta-data for this Type (" + type.getClass().getCanonicalName() + ") is not supported : " + type);
+        throw new MockitoException(
+                "Type meta-data for this Type ("
+                        + type.getClass().getCanonicalName()
+                        + ") is not supported : "
+                        + type);
     }
 
-
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    //// Below are specializations of GenericMetadataSupport that could handle retrieval of possible Types
+    //// Below are specializations of GenericMetadataSupport that could handle retrieval of possible
+    // Types
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
@@ -362,7 +382,8 @@ public Class<?> rawType() {
      * That's what meant the "standalone" word at the beginning of the Javadoc.
      * Instead use {@link ParameterizedReturnType}.
      */
-    private static class FromParameterizedTypeGenericMetadataSupport extends GenericMetadataSupport {
+    private static class FromParameterizedTypeGenericMetadataSupport
+            extends GenericMetadataSupport {
         private final ParameterizedType parameterizedType;
 
         public FromParameterizedTypeGenericMetadataSupport(ParameterizedType parameterizedType) {
@@ -387,7 +408,10 @@ private static class ParameterizedReturnType extends GenericMetadataSupport {
         private final ParameterizedType parameterizedType;
         private final TypeVariable<?>[] typeParameters;
 
-        public ParameterizedReturnType(GenericMetadataSupport source, TypeVariable<?>[] typeParameters, ParameterizedType parameterizedType) {
+        public ParameterizedReturnType(
+                GenericMetadataSupport source,
+                TypeVariable<?>[] typeParameters,
+                ParameterizedType parameterizedType) {
             this.parameterizedType = parameterizedType;
             this.typeParameters = typeParameters;
             this.contextualActualTypeParameters = source.contextualActualTypeParameters;
@@ -408,7 +432,6 @@ private void readTypeVariables() {
         public Class<?> rawType() {
             return (Class<?>) parameterizedType.getRawType();
         }
-
     }
 
     /**
@@ -420,7 +443,10 @@ private static class TypeVariableReturnType extends GenericMetadataSupport {
         private Class<?> rawType;
         private List<Type> extraInterfaces;
 
-        public TypeVariableReturnType(GenericMetadataSupport source, TypeVariable<?>[] typeParameters, TypeVariable<?> typeVariable) {
+        public TypeVariableReturnType(
+                GenericMetadataSupport source,
+                TypeVariable<?>[] typeParameters,
+                TypeVariable<?> typeVariable) {
             this.typeParameters = typeParameters;
             this.typeVariable = typeVariable;
             this.contextualActualTypeParameters = source.contextualActualTypeParameters;
@@ -437,7 +463,7 @@ private void readTypeVariables() {
             for (Type type : typeVariable.getBounds()) {
                 registerTypeVariablesOn(type);
             }
-            registerTypeParametersOn(new TypeVariable[]{typeVariable});
+            registerTypeParametersOn(new TypeVariable[] {typeVariable});
             registerTypeVariablesOn(getActualTypeArgumentFor(typeVariable));
         }
 
@@ -464,19 +490,22 @@ public List<Type> extraInterfaces() {
             if (type instanceof Class) {
                 return extraInterfaces = Collections.emptyList();
             }
-            throw new MockitoException("Cannot extract extra-interfaces from '" + typeVariable + "' : '" + type + "'");
+            throw new MockitoException(
+                    "Cannot extract extra-interfaces from '" + typeVariable + "' : '" + type + "'");
         }
 
         /**
          * @return Returns an array with the extracted raw types of {@link #extraInterfaces()}.
          * @see #extractRawTypeOf(java.lang.reflect.Type)
          */
+        @Override
         public Class<?>[] rawExtraInterfaces() {
             List<Type> extraInterfaces = extraInterfaces();
-            List<Class<?>> rawExtraInterfaces = new ArrayList<Class<?>>();
+            List<Class<?>> rawExtraInterfaces = new ArrayList<>();
             for (Type extraInterface : extraInterfaces) {
                 Class<?> rawInterface = extractRawTypeOf(extraInterface);
-                // avoid interface collision with actual raw type (with typevariables, resolution ca be quite aggressive)
+                // avoid interface collision with actual raw type (with typevariables, resolution ca
+                // be quite aggressive)
                 if (!rawType().equals(rawInterface)) {
                     rawExtraInterfaces.add(rawInterface);
                 }
@@ -493,9 +522,11 @@ on the class definition, such as such as List<E>.
                 return extractActualBoundedTypeOf(contextualActualTypeParameters.get(type));
             }
             if (type instanceof BoundedType) {
-                Type actualFirstBound = extractActualBoundedTypeOf(((BoundedType) type).firstBound());
+                Type actualFirstBound =
+                        extractActualBoundedTypeOf(((BoundedType) type).firstBound());
                 if (!(actualFirstBound instanceof BoundedType)) {
-                    return type; // avoid going one step further, ie avoid : O(TypeVar) -> K(TypeVar) -> Some ParamType
+                    return type; // avoid going one step further, ie avoid : O(TypeVar) ->
+                    // K(TypeVar) -> Some ParamType
                 }
                 return actualFirstBound;
             }
@@ -522,7 +553,14 @@ public Class<?> rawType() {
                 stringBuilder.append("[");
             }
             try {
-                return Class.forName(stringBuilder.append("L").append(rawComponentType.getName()).append(";").toString(), false, rawComponentType.getClassLoader());
+                return Class.forName(
+                        stringBuilder
+                                .append("L")
+                                .append(rawComponentType.getName())
+                                .append(";")
+                                .toString(),
+                        false,
+                        rawComponentType.getClassLoader());
             } catch (ClassNotFoundException e) {
                 throw new IllegalStateException("This was not supposed to happen.", e);
             }
@@ -548,14 +586,13 @@ public Class<?> rawType() {
         }
     }
 
-
     /**
      * Type representing bounds of a type
      *
      * @see TypeVarBoundedType
-     * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4</a>
+     * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4</a>
      * @see WildCardBoundedType
-     * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.5.1">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.5.1</a>
+     * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1</a>
      */
     public interface BoundedType extends Type {
         Type firstBound();
@@ -574,14 +611,14 @@ public interface BoundedType extends Type {
      * <p>
      * i.e. <code>SomeClass</code>.
      * <pre class="code"><code class="java">
-     *     interface UpperBoundedTypeWithClass<E extends Comparable<E> & Cloneable> {
+     *     interface UpperBoundedTypeWithClass&lt;E extends Comparable<E> &amp; Cloneable> {
      *         E get();
      *     }
      *     // will return Comparable type
      * </code></pre>
      * </p>
      *
-     * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4</a>
+     * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4</a>
      */
     public static class TypeVarBoundedType implements BoundedType {
         private final TypeVariable<?> typeVariable;
@@ -593,30 +630,40 @@ public TypeVarBoundedType(TypeVariable<?> typeVariable) {
         /**
          * @return either a class or an interface (parameterized or not), if no bounds declared Object is returned.
          */
+        @Override
         public Type firstBound() {
             return typeVariable.getBounds()[0]; //
         }
 
         /**
-         * On a Type Variable (typeVar extends C_0 & I_1 & I_2 & etc), will return an array
+         * On a Type Variable (typeVar extends C_0 &amp; I_1 &amp; I_2 &amp; etc), will return an array
          * containing I_1 and I_2.
          *
-         * @return other bounds for this type, these bounds can only be only interfaces as the JLS says,
+         * @return other bounds for this type, these bounds can only be interfaces as the JLS says,
          * empty array if no other bound declared.
          */
+        @Override
         public Type[] interfaceBounds() {
             Type[] interfaceBounds = new Type[typeVariable.getBounds().length - 1];
-            System.arraycopy(typeVariable.getBounds(), 1, interfaceBounds, 0, typeVariable.getBounds().length - 1);
+            System.arraycopy(
+                    typeVariable.getBounds(),
+                    1,
+                    interfaceBounds,
+                    0,
+                    typeVariable.getBounds().length - 1);
             return interfaceBounds;
         }
 
         @Override
         public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
 
             return typeVariable.equals(((TypeVarBoundedType) o).typeVariable);
-
         }
 
         @Override
@@ -626,7 +673,11 @@ public int hashCode() {
 
         @Override
         public String toString() {
-            return "{firstBound=" + firstBound() + ", interfaceBounds=" + Arrays.deepToString(interfaceBounds()) + '}';
+            return "{firstBound="
+                    + firstBound()
+                    + ", interfaceBounds="
+                    + Arrays.deepToString(interfaceBounds())
+                    + '}';
         }
 
         public TypeVariable<?> typeVariable() {
@@ -640,19 +691,17 @@ public TypeVariable<?> typeVariable() {
      * <p>The JLS says that lower bound and upper bound are mutually exclusive, and that multiple bounds
      * are not allowed.
      *
-     * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4</a>
+     * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4</a>
      */
     public static class WildCardBoundedType implements BoundedType {
         private final WildcardType wildcard;
 
-
         public WildCardBoundedType(WildcardType wildcard) {
             this.wildcard = wildcard;
         }
 
-        /**
-         * @return The first bound, either a type or a reference to a TypeVariable
-         */
+        /** @return The first bound, either a type or a reference to a TypeVariable */
+        @Override
         public Type firstBound() {
             Type[] lowerBounds = wildcard.getLowerBounds();
             Type[] upperBounds = wildcard.getUpperBounds();
@@ -660,20 +709,22 @@ public Type firstBound() {
             return lowerBounds.length != 0 ? lowerBounds[0] : upperBounds[0];
         }
 
-        /**
-         * @return An empty array as, wildcard don't support multiple bounds.
-         */
+        /** @return An empty array as, wildcard don't support multiple bounds. */
+        @Override
         public Type[] interfaceBounds() {
             return new Type[0];
         }
 
         @Override
         public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
 
             return wildcard.equals(((TypeVarBoundedType) o).typeVariable);
-
         }
 
         @Override
@@ -690,5 +741,4 @@ public WildcardType wildCard() {
             return wildcard;
         }
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
similarity index 85%
rename from src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
rename to mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
index 01fc1de50a..fb56a37f9b 100644
--- a/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
@@ -7,10 +7,8 @@
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 
-/**
- * Attempts to extract generic type of given target base class or target interface
- */
-public class GenericTypeExtractor {
+/** Attempts to extract generic type of given target base class or target interface */
+public final class GenericTypeExtractor {
 
     /**
      * Extract generic type of root class either from the target base class or from target base interface.
@@ -34,20 +32,21 @@ public class GenericTypeExtractor {
      *                            it will be used for generic type extraction
      * @return generic interface if found, Object.class if not found.
      */
-    public static Class<?> genericTypeOf(Class<?> rootClass, Class<?> targetBaseClass, Class<?> targetBaseInterface) {
-        //looking for candidates in the hierarchy of rootClass
+    public static Class<?> genericTypeOf(
+            Class<?> rootClass, Class<?> targetBaseClass, Class<?> targetBaseInterface) {
+        // looking for candidates in the hierarchy of rootClass
         Class<?> match = rootClass;
-        while(match != Object.class) {
-            //check the super class first
+        while (match != Object.class) {
+            // check the super class first
             if (match.getSuperclass() == targetBaseClass) {
                 return extractGeneric(match.getGenericSuperclass());
             }
-            //check the interfaces (recursively)
+            // check the interfaces (recursively)
             Type genericInterface = findGenericInterface(match, targetBaseInterface);
             if (genericInterface != null) {
                 return extractGeneric(genericInterface);
             }
-            //recurse the hierarchy
+            // recurse the hierarchy
             match = match.getSuperclass();
         }
         return Object.class;
@@ -85,4 +84,6 @@ private static Class<?> extractGeneric(Type type) {
         }
         return Object.class;
     }
+
+    private GenericTypeExtractor() {}
 }
diff --git a/src/main/java/org/mockito/internal/util/reflection/InstanceField.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
similarity index 86%
rename from src/main/java/org/mockito/internal/util/reflection/InstanceField.java
rename to mockito-core/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
index 6e4080db75..ffefaec2a5 100644
--- a/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
@@ -4,12 +4,13 @@
  */
 package org.mockito.internal.util.reflection;
 
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
-
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.internal.util.Checks;
+import org.mockito.plugins.MemberAccessor;
 
 /**
  * Represents an accessible instance field.
@@ -47,10 +48,14 @@ public Object read() {
      * Set the given value to the field of this instance.
      *
      * @param value The value that should be written to the field.
-     * @see FieldSetter
      */
     public void set(Object value) {
-        setField(instance, field,value);
+        MemberAccessor accessor = Plugins.getMemberAccessor();
+        try {
+            accessor.set(field, instance, value);
+        } catch (IllegalAccessException e) {
+            throw new MockitoException("Access to " + field + " was denied", e);
+        }
     }
 
     /**
@@ -124,8 +129,12 @@ public String toString() {
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
 
         InstanceField that = (InstanceField) o;
         return field.equals(that.field) && instance.equals(that.instance);
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
new file mode 100644
index 0000000000..e01b1f1280
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
@@ -0,0 +1,454 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.dynamic.loading.ByteArrayClassLoader;
+import net.bytebuddy.dynamic.loading.InjectionClassLoader;
+import net.bytebuddy.implementation.MethodCall;
+import org.mockito.exceptions.base.MockitoInitializationException;
+import org.mockito.internal.PremainAttachAccess;
+import org.mockito.internal.SuppressSignatureCheck;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.instrument.Instrumentation;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static org.mockito.internal.util.StringUtil.join;
+
+@SuppressSignatureCheck
+class InstrumentationMemberAccessor implements MemberAccessor {
+
+    private static final Map<Class<?>, Class<?>> WRAPPERS = new HashMap<>();
+
+    private static final Instrumentation INSTRUMENTATION;
+    private static final Dispatcher DISPATCHER;
+
+    private static final Throwable INITIALIZATION_ERROR;
+
+    static {
+        WRAPPERS.put(boolean.class, Boolean.class);
+        WRAPPERS.put(byte.class, Byte.class);
+        WRAPPERS.put(short.class, Short.class);
+        WRAPPERS.put(char.class, Character.class);
+        WRAPPERS.put(int.class, Integer.class);
+        WRAPPERS.put(long.class, Long.class);
+        WRAPPERS.put(float.class, Float.class);
+        WRAPPERS.put(double.class, Double.class);
+        Instrumentation instrumentation;
+        Dispatcher dispatcher;
+        Throwable throwable;
+        try {
+            instrumentation = PremainAttachAccess.getInstrumentation();
+            // We need to generate a dispatcher instance that is located in a distinguished class
+            // loader to create a unique (unnamed) module to which we can open other packages to.
+            // This way, we assure that classes within Mockito's module (which might be a shared,
+            // unnamed module) do not face escalated privileges where tests might pass that would
+            // otherwise fail without Mockito's opening.
+            InjectionClassLoader classLoader =
+                    new ByteArrayClassLoader(
+                            InstrumentationMemberAccessor.class.getClassLoader(),
+                            false,
+                            Collections.emptyMap());
+            instrumentation.redefineModule(
+                    Dispatcher.class.getModule(),
+                    Collections.emptySet(),
+                    Collections.singletonMap(
+                            Dispatcher.class.getPackageName(),
+                            Collections.singleton(classLoader.getUnnamedModule())),
+                    Collections.emptyMap(),
+                    Collections.emptySet(),
+                    Collections.emptyMap());
+            dispatcher =
+                    new ByteBuddy()
+                            .subclass(Dispatcher.class)
+                            .method(named("getLookup"))
+                            .intercept(MethodCall.invoke(MethodHandles.class.getMethod("lookup")))
+                            .method(named("getModule"))
+                            .intercept(
+                                    MethodCall.invoke(Class.class.getMethod("getModule"))
+                                            .onMethodCall(
+                                                    MethodCall.invoke(
+                                                            Object.class.getMethod("getClass"))))
+                            .method(named("setAccessible"))
+                            .intercept(
+                                    MethodCall.invoke(
+                                                    AccessibleObject.class.getMethod(
+                                                            "setAccessible", boolean.class))
+                                            .onArgument(0)
+                                            .withArgument(1))
+                            .method(named("invokeWithArguments"))
+                            .intercept(
+                                    MethodCall.invoke(
+                                                    MethodHandle.class.getMethod(
+                                                            "invokeWithArguments", Object[].class))
+                                            .onArgument(0)
+                                            .withArgument(1))
+                            .make()
+                            .load(classLoader, InjectionClassLoader.Strategy.INSTANCE)
+                            .getLoaded()
+                            .getConstructor()
+                            .newInstance();
+            classLoader.seal();
+            throwable = null;
+        } catch (Throwable t) {
+            instrumentation = null;
+            dispatcher = null;
+            throwable = t;
+        }
+        INSTRUMENTATION = instrumentation;
+        DISPATCHER = dispatcher;
+        INITIALIZATION_ERROR = throwable;
+    }
+
+    @SuppressWarnings(value = "unused")
+    private final MethodHandle getModule;
+
+    @SuppressWarnings(value = "unused")
+    private final MethodHandle isOpen;
+
+    @SuppressWarnings(value = "unused")
+    private final MethodHandle redefineModule;
+
+    @SuppressWarnings(value = "unused")
+    private final MethodHandle privateLookupIn;
+
+    InstrumentationMemberAccessor() {
+        if (INITIALIZATION_ERROR != null) {
+            throw new MockitoInitializationException(
+                    join(
+                            "Could not initialize the Mockito instrumentation member accessor",
+                            "",
+                            "This is unexpected on JVMs from Java 9 or later - possibly, the instrumentation API could not be resolved"),
+                    INITIALIZATION_ERROR);
+        }
+        try {
+            Class<?> module = Class.forName("java.lang.Module");
+            getModule =
+                    MethodHandles.publicLookup()
+                            .findVirtual(Class.class, "getModule", MethodType.methodType(module));
+            isOpen =
+                    MethodHandles.publicLookup()
+                            .findVirtual(
+                                    module,
+                                    "isOpen",
+                                    MethodType.methodType(boolean.class, String.class));
+            redefineModule =
+                    MethodHandles.publicLookup()
+                            .findVirtual(
+                                    Instrumentation.class,
+                                    "redefineModule",
+                                    MethodType.methodType(
+                                            void.class,
+                                            module,
+                                            Set.class,
+                                            Map.class,
+                                            Map.class,
+                                            Set.class,
+                                            Map.class));
+            privateLookupIn =
+                    MethodHandles.publicLookup()
+                            .findStatic(
+                                    MethodHandles.class,
+                                    "privateLookupIn",
+                                    MethodType.methodType(
+                                            MethodHandles.Lookup.class,
+                                            Class.class,
+                                            MethodHandles.Lookup.class));
+        } catch (Throwable t) {
+            throw new MockitoInitializationException(
+                    "Could not resolve instrumentation invoker", t);
+        }
+    }
+
+    @Override
+    public Object newInstance(Constructor<?> constructor, Object... arguments)
+            throws InstantiationException, InvocationTargetException {
+        return newInstance(constructor, ConstructionDispatcher::newInstance, arguments);
+    }
+
+    @Override
+    public Object newInstance(
+            Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+            throws InstantiationException, InvocationTargetException {
+        if (Modifier.isAbstract(constructor.getDeclaringClass().getModifiers())) {
+            throw new InstantiationException(
+                    "Cannot instantiate abstract " + constructor.getDeclaringClass().getTypeName());
+        }
+        assureArguments(constructor, null, null, arguments, constructor.getParameterTypes());
+        try {
+            Object module =
+                    DISPATCHER.invokeWithArguments(
+                            getModule.bindTo(constructor.getDeclaringClass()));
+            String packageName = constructor.getDeclaringClass().getPackage().getName();
+            assureOpen(module, packageName);
+            MethodHandle handle =
+                    ((MethodHandles.Lookup)
+                                    DISPATCHER.invokeWithArguments(
+                                            privateLookupIn,
+                                            constructor.getDeclaringClass(),
+                                            DISPATCHER.getLookup()))
+                            .unreflectConstructor(constructor);
+            AtomicBoolean thrown = new AtomicBoolean();
+            Object value =
+                    onConstruction.invoke(
+                            () -> {
+                                try {
+                                    // Use handle.asFixedArity() to handle varargs bindings properly
+                                    // (as by default Java will create method handle with
+                                    // asVarargsCollector), fe:
+                                    //
+                                    //   private static class Varargs {
+                                    //     Varargs(String whatever, Observer... observers) {
+                                    //     }
+                                    //   }
+                                    return DISPATCHER.invokeWithArguments(
+                                            handle.asFixedArity(), arguments);
+                                } catch (Throwable throwable) {
+                                    thrown.set(true);
+                                    return throwable;
+                                }
+                            });
+            if (thrown.get()) {
+                throw new InvocationTargetException((Throwable) value);
+            } else {
+                return value;
+            }
+        } catch (InvocationTargetException e) {
+            throw e;
+        } catch (Throwable t) {
+            throw new IllegalStateException(
+                    "Could not construct "
+                            + constructor
+                            + " with arguments "
+                            + Arrays.toString(arguments),
+                    t);
+        }
+    }
+
+    @Override
+    public Object invoke(Method method, Object target, Object... arguments)
+            throws InvocationTargetException {
+        assureArguments(
+                method,
+                Modifier.isStatic(method.getModifiers()) ? null : target,
+                method.getDeclaringClass(),
+                arguments,
+                method.getParameterTypes());
+        try {
+            Object module =
+                    DISPATCHER.invokeWithArguments(getModule.bindTo(method.getDeclaringClass()));
+            String packageName = method.getDeclaringClass().getPackage().getName();
+            assureOpen(module, packageName);
+            MethodHandle handle =
+                    ((MethodHandles.Lookup)
+                                    DISPATCHER.invokeWithArguments(
+                                            privateLookupIn,
+                                            method.getDeclaringClass(),
+                                            DISPATCHER.getLookup()))
+                            .unreflect(method);
+            if (!Modifier.isStatic(method.getModifiers())) {
+                handle = handle.bindTo(target);
+            }
+            if (handle.isVarargsCollector()) {
+                handle = handle.asFixedArity();
+            }
+            try {
+                return DISPATCHER.invokeWithArguments(handle, arguments);
+            } catch (Throwable t) {
+                throw new InvocationTargetException(t);
+            }
+        } catch (InvocationTargetException e) {
+            throw e;
+        } catch (Throwable t) {
+            throw new IllegalStateException(
+                    "Could not invoke "
+                            + method
+                            + " on "
+                            + target
+                            + " with arguments "
+                            + Arrays.toString(arguments),
+                    t);
+        }
+    }
+
+    @Override
+    public Object get(Field field, Object target) {
+        assureArguments(
+                field,
+                Modifier.isStatic(field.getModifiers()) ? null : target,
+                field.getDeclaringClass(),
+                new Object[0],
+                new Class<?>[0]);
+        try {
+            Object module =
+                    DISPATCHER.invokeWithArguments(getModule.bindTo(field.getDeclaringClass()));
+            String packageName = field.getDeclaringClass().getPackage().getName();
+            assureOpen(module, packageName);
+            MethodHandle handle =
+                    ((MethodHandles.Lookup)
+                                    DISPATCHER.invokeWithArguments(
+                                            privateLookupIn,
+                                            field.getDeclaringClass(),
+                                            DISPATCHER.getLookup()))
+                            .unreflectGetter(field);
+            if (!Modifier.isStatic(field.getModifiers())) {
+                handle = handle.bindTo(target);
+            }
+            return DISPATCHER.invokeWithArguments(handle);
+        } catch (Throwable t) {
+            throw new IllegalStateException("Could not read " + field + " on " + target, t);
+        }
+    }
+
+    @Override
+    public void set(Field field, Object target, Object value) throws IllegalAccessException {
+        assureArguments(
+                field,
+                Modifier.isStatic(field.getModifiers()) ? null : target,
+                field.getDeclaringClass(),
+                new Object[] {value},
+                new Class<?>[] {field.getType()});
+        boolean illegalAccess = false;
+        try {
+            Object module =
+                    DISPATCHER.invokeWithArguments(getModule.bindTo(field.getDeclaringClass()));
+            String packageName = field.getDeclaringClass().getPackage().getName();
+            assureOpen(module, packageName);
+            // Method handles do not allow setting final fields where setAccessible(true)
+            // is required before unreflecting.
+            boolean isFinal;
+            if (Modifier.isFinal(field.getModifiers())) {
+                isFinal = true;
+                try {
+                    DISPATCHER.setAccessible(field, true);
+                } catch (Throwable ignored) {
+                    illegalAccess =
+                            true; // To distinguish from propagated illegal access exception.
+                    throw new IllegalAccessException(
+                            "Could not make final field " + field + " accessible");
+                }
+            } else {
+                isFinal = false;
+            }
+            try {
+                MethodHandle handle =
+                        ((MethodHandles.Lookup)
+                                        DISPATCHER.invokeWithArguments(
+                                                privateLookupIn,
+                                                field.getDeclaringClass(),
+                                                DISPATCHER.getLookup()))
+                                .unreflectSetter(field);
+                if (!Modifier.isStatic(field.getModifiers())) {
+                    handle = handle.bindTo(target);
+                }
+                DISPATCHER.invokeWithArguments(handle, value);
+            } finally {
+                if (isFinal) {
+                    DISPATCHER.setAccessible(field, false);
+                }
+            }
+        } catch (Throwable t) {
+            if (illegalAccess) {
+                throw (IllegalAccessException) t;
+            } else {
+                throw new IllegalStateException("Could not read " + field + " on " + target, t);
+            }
+        }
+    }
+
+    private void assureOpen(Object module, String packageName) throws Throwable {
+        // It would be more reliable to check if a module's package already is opened to
+        // the dispatcher module from before. Unfortunately, there is no reliable check
+        // for doing so since the isOpen(String, Module) method always returns true
+        // if the second argument is an unnamed module. Therefore, for now, we need
+        // to reopen packages even if they are already opened to the dispatcher module.
+        if (!(Boolean) DISPATCHER.invokeWithArguments(isOpen, module, packageName)) {
+            DISPATCHER.invokeWithArguments(
+                    redefineModule.bindTo(INSTRUMENTATION),
+                    module,
+                    Collections.emptySet(),
+                    Collections.emptyMap(),
+                    Collections.singletonMap(
+                            packageName, Collections.singleton(DISPATCHER.getModule())),
+                    Collections.emptySet(),
+                    Collections.emptyMap());
+        }
+    }
+
+    private static void assureArguments(
+            AccessibleObject target,
+            Object owner,
+            Class<?> type,
+            Object[] values,
+            Class<?>[] types) {
+        if (owner != null) {
+            if (!type.isAssignableFrom(owner.getClass())) {
+                throw new IllegalArgumentException("Cannot access " + target + " on " + owner);
+            }
+        }
+
+        Object[] args = values;
+        if (args == null) {
+            args = new Object[0];
+        }
+
+        if (types.length != args.length) {
+            throw new IllegalArgumentException(
+                    "Incorrect number of arguments for "
+                            + target
+                            + ": expected "
+                            + types.length
+                            + " but recevied "
+                            + args.length);
+        }
+        for (int index = 0; index < args.length; index++) {
+            if (args[index] == null) {
+                if (types[index].isPrimitive()) {
+                    throw new IllegalArgumentException(
+                            "Cannot assign null to primitive type "
+                                    + types[index].getTypeName()
+                                    + " for "
+                                    + index
+                                    + " parameter of "
+                                    + target);
+                }
+            } else {
+                Class<?> resolved = WRAPPERS.getOrDefault(types[index], types[index]);
+                if (!resolved.isAssignableFrom(args[index].getClass())) {
+                    throw new IllegalArgumentException(
+                            "Cannot assign value of type "
+                                    + args[index].getClass()
+                                    + " to "
+                                    + resolved
+                                    + " for "
+                                    + index
+                                    + " parameter of "
+                                    + target);
+                }
+            }
+        }
+    }
+
+    public interface Dispatcher {
+
+        MethodHandles.Lookup getLookup();
+
+        Object getModule();
+
+        void setAccessible(AccessibleObject target, boolean value);
+
+        // Used to avoid invoke/invokeExact being exposed to Android where this class should
+        // never be loaded. Since the invocation happens from the generated code, the Android
+        // build pipeline does not fail.
+        Object invokeWithArguments(MethodHandle handle, Object... arguments) throws Throwable;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
new file mode 100644
index 0000000000..95b30198db
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+public class LenientCopyTool {
+
+    MemberAccessor accessor = Plugins.getMemberAccessor();
+
+    public <T> void copyToMock(T from, T mock) {
+        copy(from, mock, from.getClass());
+    }
+
+    public <T> void copyToRealObject(T from, T to) {
+        copy(from, to, from.getClass());
+    }
+
+    private <T> void copy(T from, T to, Class<?> fromClazz) {
+        while (fromClazz != Object.class) {
+            copyValues(from, to, fromClazz);
+            fromClazz = fromClazz.getSuperclass();
+        }
+    }
+
+    private <T> void copyValues(T from, T mock, Class<?> classFrom) {
+        Field[] fields = classFrom.getDeclaredFields();
+
+        for (Field field : fields) {
+            // ignore static fields
+            if (Modifier.isStatic(field.getModifiers())) {
+                continue;
+            }
+            try {
+                Object value = accessor.get(field, from);
+                accessor.set(field, mock, value);
+            } catch (Throwable t) {
+                // Ignore - be lenient - if some field cannot be copied then let's be it
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java
new file mode 100644
index 0000000000..08e55a5db6
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import net.bytebuddy.ClassFileVersion;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ModuleMemberAccessor implements MemberAccessor {
+
+    private final MemberAccessor delegate;
+
+    public ModuleMemberAccessor() {
+        MemberAccessor delegate;
+        try {
+            delegate = delegate();
+        } catch (Throwable ignored) {
+            // Fallback in case Byte Buddy is not used as a mock maker and not available on the
+            // class loader.
+            delegate = new ReflectionMemberAccessor();
+        }
+        this.delegate = delegate;
+    }
+
+    private static MemberAccessor delegate() {
+        if (ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V9)) {
+            return new InstrumentationMemberAccessor();
+        } else {
+            return new ReflectionMemberAccessor();
+        }
+    }
+
+    @Override
+    public Object newInstance(Constructor<?> constructor, Object... arguments)
+            throws InstantiationException, InvocationTargetException, IllegalAccessException {
+        return delegate.newInstance(constructor, arguments);
+    }
+
+    @Override
+    public Object newInstance(
+            Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+            throws InstantiationException, InvocationTargetException, IllegalAccessException {
+        return delegate.newInstance(constructor, onConstruction, arguments);
+    }
+
+    @Override
+    public Object invoke(Method method, Object target, Object... arguments)
+            throws InvocationTargetException, IllegalAccessException {
+        return delegate.invoke(method, target, arguments);
+    }
+
+    @Override
+    public Object get(Field field, Object target) throws IllegalAccessException {
+        return delegate.get(field, target);
+    }
+
+    @Override
+    public void set(Field field, Object target, Object value) throws IllegalAccessException {
+        delegate.set(field, target, value);
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/ReflectionMemberAccessor.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/ReflectionMemberAccessor.java
new file mode 100644
index 0000000000..deb884dd8b
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/ReflectionMemberAccessor.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import org.mockito.plugins.MemberAccessor;
+
+public class ReflectionMemberAccessor implements MemberAccessor {
+
+    @Override
+    public Object newInstance(Constructor<?> constructor, Object... arguments)
+            throws InstantiationException, InvocationTargetException, IllegalAccessException {
+        return newInstance(constructor, ConstructionDispatcher::newInstance, arguments);
+    }
+
+    @Override
+    public Object newInstance(
+            Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+            throws InstantiationException, InvocationTargetException, IllegalAccessException {
+        silentSetAccessible(constructor, true);
+        try {
+            return onConstruction.invoke(() -> constructor.newInstance(arguments));
+        } catch (InvocationTargetException
+                | IllegalAccessException
+                | InstantiationException
+                | IllegalArgumentException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            throw new IllegalStateException(
+                    "Failed to invoke " + constructor + " with " + Arrays.toString(arguments), e);
+        } finally {
+            silentSetAccessible(constructor, false);
+        }
+    }
+
+    @Override
+    public Object invoke(Method method, Object target, Object... arguments)
+            throws InvocationTargetException, IllegalAccessException {
+        silentSetAccessible(method, true);
+        try {
+            return method.invoke(target, arguments);
+        } catch (InvocationTargetException | IllegalAccessException | IllegalArgumentException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            throw new IllegalStateException("Could not invoke " + method + " on " + target, e);
+        } finally {
+            silentSetAccessible(method, false);
+        }
+    }
+
+    @Override
+    public Object get(Field field, Object target) throws IllegalAccessException {
+        silentSetAccessible(field, true);
+        try {
+            return field.get(target);
+        } catch (IllegalAccessException | IllegalArgumentException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            throw new IllegalStateException("Could not read " + field + " from " + target, e);
+        } finally {
+            silentSetAccessible(field, false);
+        }
+    }
+
+    @Override
+    public void set(Field field, Object target, Object value) throws IllegalAccessException {
+        silentSetAccessible(field, true);
+        try {
+            field.set(target, value);
+        } catch (IllegalAccessException | IllegalArgumentException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            throw new IllegalStateException("Could not write " + field + " to " + target, e);
+        } finally {
+            silentSetAccessible(field, false);
+        }
+    }
+
+    private static void silentSetAccessible(AccessibleObject object, boolean value) {
+        try {
+            object.setAccessible(value);
+        } catch (RuntimeException ignored) {
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
similarity index 83%
rename from src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
rename to mockito-core/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
index 86127f14a1..32ed9744d4 100644
--- a/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
@@ -17,15 +17,14 @@
  */
 public class SuperTypesLastSorter {
 
-    private SuperTypesLastSorter() {
-    }
+    private SuperTypesLastSorter() {}
 
     /**
      * Return a new collection with the fields sorted first by name,
      * then with any fields moved after their supertypes.
      */
     public static List<Field> sortSuperTypesLast(Collection<? extends Field> unsortedFields) {
-        List<Field> fields = new ArrayList<Field>(unsortedFields);
+        List<Field> fields = new ArrayList<>(unsortedFields);
 
         Collections.sort(fields, compareFieldsByName);
 
@@ -54,11 +53,8 @@ public static List<Field> sortSuperTypesLast(Collection<? extends Field> unsorte
         return fields;
     }
 
-
-    private static final Comparator<Field> compareFieldsByName = new Comparator<Field>() {
-        @Override
-        public int compare(Field o1, Field o2) {
-            return o1.getName().compareTo(o2.getName());
-        }
-    };
+    private static final Comparator<Field> compareFieldsByName =
+            (Field o1, Field o2) -> {
+                return o1.getName().compareTo(o2.getName());
+            };
 }
diff --git a/src/main/java/org/mockito/internal/util/reflection/package-info.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/util/reflection/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/util/reflection/package-info.java
diff --git a/src/main/java/org/mockito/internal/verification/AtLeast.java b/mockito-core/src/main/java/org/mockito/internal/verification/AtLeast.java
similarity index 81%
rename from src/main/java/org/mockito/internal/verification/AtLeast.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/AtLeast.java
index 4599e4e778..5f70649106 100644
--- a/src/main/java/org/mockito/internal/verification/AtLeast.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/AtLeast.java
@@ -27,7 +27,7 @@ public AtLeast(int wantedNumberOfInvocations) {
     @Override
     public void verify(VerificationData data) {
         if (wantedCount == 1) {
-             checkMissingInvocation(data.getAllInvocations(), data.getTarget());
+            checkMissingInvocation(data.getAllInvocations(), data.getTarget());
         }
         checkAtLeastNumberOfInvocations(data.getAllInvocations(), data.getTarget(), wantedCount);
     }
@@ -35,14 +35,15 @@ public void verify(VerificationData data) {
     @Override
     public void verifyInOrder(VerificationDataInOrder data) {
         if (wantedCount == 1) {
-             checkMissingInvocation(data.getAllInvocations(), data.getWanted(),  data.getOrderingContext());
+            checkMissingInvocation(
+                    data.getAllInvocations(), data.getWanted(), data.getOrderingContext());
         }
-        checkAtLeastNumberOfInvocations(data.getAllInvocations(), data.getWanted(), wantedCount, data.getOrderingContext());
+        checkAtLeastNumberOfInvocations(
+                data.getAllInvocations(), data.getWanted(), wantedCount, data.getOrderingContext());
     }
 
     @Override
     public String toString() {
         return "Wanted invocations count: at least " + wantedCount;
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/verification/AtMost.java b/mockito-core/src/main/java/org/mockito/internal/verification/AtMost.java
similarity index 92%
rename from src/main/java/org/mockito/internal/verification/AtMost.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/AtMost.java
index b4e4081dc4..72c0d00275 100644
--- a/src/main/java/org/mockito/internal/verification/AtMost.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/AtMost.java
@@ -28,6 +28,7 @@ public AtMost(int maxNumberOfInvocations) {
         this.maxNumberOfInvocations = maxNumberOfInvocations;
     }
 
+    @Override
     public void verify(VerificationData data) {
         List<Invocation> invocations = data.getAllInvocations();
         MatchableInvocation wanted = data.getTarget();
@@ -50,4 +51,9 @@ private void removeAlreadyVerified(List<Invocation> invocations) {
             }
         }
     }
+
+    @Override
+    public String toString() {
+        return "Wanted invocations count: at most " + maxNumberOfInvocations;
+    }
 }
diff --git a/src/main/java/org/mockito/internal/verification/Calls.java b/mockito-core/src/main/java/org/mockito/internal/verification/Calls.java
similarity index 77%
rename from src/main/java/org/mockito/internal/verification/Calls.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/Calls.java
index 38e7316447..f52fd66971 100644
--- a/src/main/java/org/mockito/internal/verification/Calls.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/Calls.java
@@ -22,15 +22,15 @@ public class Calls implements VerificationMode, VerificationInOrderMode {
     final int wantedCount;
 
     public Calls(int wantedNumberOfInvocations) {
-        if( wantedNumberOfInvocations <= 0 ) {
-            throw new MockitoException( "Negative and zero values are not allowed here" );
+        if (wantedNumberOfInvocations <= 0) {
+            throw new MockitoException("Negative and zero values are not allowed here");
         }
         this.wantedCount = wantedNumberOfInvocations;
     }
 
     @Override
     public void verify(VerificationData data) {
-        throw new MockitoException( "calls is only intended to work with InOrder" );
+        throw new MockitoException("calls is only intended to work with InOrder");
     }
 
     @Override
@@ -38,13 +38,13 @@ public void verifyInOrder(VerificationDataInOrder data) {
         List<Invocation> allInvocations = data.getAllInvocations();
         MatchableInvocation wanted = data.getWanted();
 
-        checkMissingInvocation(allInvocations, wanted,  data.getOrderingContext());
-        checkNumberOfInvocationsNonGreedy(allInvocations, wanted, wantedCount, data.getOrderingContext());
+        checkMissingInvocation(allInvocations, wanted, data.getOrderingContext());
+        checkNumberOfInvocationsNonGreedy(
+                allInvocations, wanted, wantedCount, data.getOrderingContext());
     }
 
     @Override
     public String toString() {
         return "Wanted invocations count (non-greedy): " + wantedCount;
     }
-
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java b/mockito-core/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
new file mode 100644
index 0000000000..b32a5a458d
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
+
+import java.io.Serializable;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.mockito.invocation.Invocation;
+
+public class DefaultRegisteredInvocations implements RegisteredInvocations, Serializable {
+
+    private static final long serialVersionUID = -2674402327380736290L;
+    private final LinkedList<Invocation> invocations = new LinkedList<>();
+
+    @Override
+    public void add(Invocation invocation) {
+        synchronized (invocations) {
+            invocations.add(invocation);
+        }
+    }
+
+    @Override
+    public void removeLast() {
+        // TODO: add specific test for synchronization of this block (it is tested by
+        // InvocationContainerImplTest at the moment)
+        synchronized (invocations) {
+            if (!invocations.isEmpty()) {
+                invocations.removeLast();
+            }
+        }
+    }
+
+    @Override
+    public List<Invocation> getAll() {
+        List<Invocation> copiedList;
+        synchronized (invocations) {
+            copiedList = new LinkedList<>(invocations);
+        }
+
+        return copiedList.stream()
+                .filter(invocation -> !isToStringMethod(invocation.getMethod()))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void clear() {
+        synchronized (invocations) {
+            invocations.clear();
+        }
+    }
+
+    @Override
+    public boolean isEmpty() {
+        synchronized (invocations) {
+            return invocations.isEmpty();
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/verification/Description.java b/mockito-core/src/main/java/org/mockito/internal/verification/Description.java
similarity index 97%
rename from src/main/java/org/mockito/internal/verification/Description.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/Description.java
index d9c133e03d..10651e2a0b 100644
--- a/src/main/java/org/mockito/internal/verification/Description.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/Description.java
@@ -39,7 +39,7 @@ public void verify(VerificationData data) {
         try {
             verification.verify(data);
 
-        } catch (MockitoAssertionError e) {
+        } catch (AssertionError e) {
             throw new MockitoAssertionError(e, description);
         }
     }
diff --git a/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java b/mockito-core/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
similarity index 95%
rename from src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
index b7a7a96443..46a0177589 100644
--- a/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
@@ -12,10 +12,12 @@ public class InOrderContextImpl implements InOrderContext {
 
     final IdentitySet verified = new IdentitySet();
 
+    @Override
     public boolean isVerified(Invocation invocation) {
         return verified.contains(invocation);
     }
 
+    @Override
     public void markVerified(Invocation i) {
         verified.add(i);
     }
diff --git a/src/main/java/org/mockito/internal/verification/InOrderWrapper.java b/mockito-core/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
similarity index 77%
rename from src/main/java/org/mockito/internal/verification/InOrderWrapper.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
index 9cb82afc5b..b829195383 100644
--- a/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
@@ -24,9 +24,12 @@ public InOrderWrapper(VerificationInOrderMode mode, InOrderImpl inOrder) {
         this.inOrder = inOrder;
     }
 
+    @Override
     public void verify(VerificationData data) {
-        List<Invocation> invocations = VerifiableInvocationsFinder.find(inOrder.getMocksToBeVerifiedInOrder());
-        VerificationDataInOrderImpl dataInOrder = new VerificationDataInOrderImpl(inOrder, invocations, data.getTarget());
+        List<Invocation> invocations =
+                VerifiableInvocationsFinder.find(inOrder.getMocksToBeVerifiedInOrder());
+        VerificationDataInOrderImpl dataInOrder =
+                new VerificationDataInOrderImpl(inOrder, invocations, data.getTarget());
         mode.verifyInOrder(dataInOrder);
     }
 }
diff --git a/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java b/mockito-core/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
similarity index 81%
rename from src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
index 2a3ff2c571..490f9179e1 100644
--- a/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
@@ -17,26 +17,24 @@ public class MockAwareVerificationMode implements VerificationMode {
     private final VerificationMode mode;
     private final Set<VerificationListener> listeners;
 
-    public MockAwareVerificationMode(Object mock, VerificationMode mode, Set<VerificationListener> listeners) {
+    public MockAwareVerificationMode(
+            Object mock, VerificationMode mode, Set<VerificationListener> listeners) {
         this.mock = mock;
         this.mode = mode;
         this.listeners = listeners;
     }
 
+    @Override
     public void verify(VerificationData data) {
         try {
             mode.verify(data);
             notifyListeners(new VerificationEventImpl(mock, mode, data, null));
-        } catch (RuntimeException e) {
-            notifyListeners(new VerificationEventImpl(mock, mode, data, e));
-            throw e;
-        } catch (Error e) {
+        } catch (RuntimeException | Error e) {
             notifyListeners(new VerificationEventImpl(mock, mode, data, e));
             throw e;
         }
     }
 
-
     private void notifyListeners(VerificationEvent event) {
         for (VerificationListener listener : listeners) {
             listener.onVerification(event);
@@ -46,5 +44,4 @@ private void notifyListeners(VerificationEvent event) {
     public Object getMock() {
         return mock;
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/verification/NoInteractions.java b/mockito-core/src/main/java/org/mockito/internal/verification/NoInteractions.java
similarity index 98%
rename from src/main/java/org/mockito/internal/verification/NoInteractions.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/NoInteractions.java
index 6c22793f9e..c307abd68c 100644
--- a/src/main/java/org/mockito/internal/verification/NoInteractions.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/NoInteractions.java
@@ -14,6 +14,7 @@
 
 public class NoInteractions implements VerificationMode {
 
+    @Override
     @SuppressWarnings("unchecked")
     public void verify(VerificationData data) {
         List<Invocation> invocations = data.getAllInvocations();
@@ -21,5 +22,4 @@ public void verify(VerificationData data) {
             throw noInteractionsWanted(invocations.get(0).getMock(), (List) invocations);
         }
     }
-
 }
diff --git a/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java b/mockito-core/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
similarity index 98%
rename from src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
index 60a3e11c41..ad8018f4f2 100644
--- a/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
@@ -19,6 +19,7 @@
 
 public class NoMoreInteractions implements VerificationMode, VerificationInOrderMode {
 
+    @Override
     @SuppressWarnings("unchecked")
     public void verify(VerificationData data) {
         Invocation unverified = findFirstUnverified(data.getAllInvocations());
@@ -27,6 +28,7 @@ public void verify(VerificationData data) {
         }
     }
 
+    @Override
     public void verifyInOrder(VerificationDataInOrder data) {
         List<Invocation> invocations = data.getAllInvocations();
         Invocation unverified = findFirstUnverifiedInOrder(data.getOrderingContext(), invocations);
diff --git a/src/main/java/org/mockito/internal/verification/Only.java b/mockito-core/src/main/java/org/mockito/internal/verification/Only.java
similarity index 75%
rename from src/main/java/org/mockito/internal/verification/Only.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/Only.java
index feb92dc7f8..65ff76b139 100644
--- a/src/main/java/org/mockito/internal/verification/Only.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/Only.java
@@ -19,18 +19,28 @@
 
 public class Only implements VerificationMode {
 
+    @Override
     @SuppressWarnings("unchecked")
     public void verify(VerificationData data) {
         MatchableInvocation target = data.getTarget();
         List<Invocation> invocations = data.getAllInvocations();
-        List<Invocation> chunk = findInvocations(invocations,target);
+        List<Invocation> chunk = findInvocations(invocations, target);
+        if (!chunk.isEmpty()) {
+            markVerified(chunk.get(0), target);
+        }
         if (invocations.size() != 1 && !chunk.isEmpty()) {
             Invocation unverified = findFirstUnverified(invocations);
-            throw noMoreInteractionsWanted(unverified, (List) invocations);
+            if (unverified != null) {
+                throw noMoreInteractionsWanted(unverified, (List) invocations);
+            }
         }
         if (invocations.size() != 1 || chunk.isEmpty()) {
             throw wantedButNotInvoked(target);
         }
-        markVerified(chunk.get(0), target);
+    }
+
+    @Override
+    public String toString() {
+        return "Wanted invocations count: 1 and no other method invoked";
     }
 }
diff --git a/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java b/mockito-core/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
similarity index 99%
rename from src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
index 51ea7ad9fc..8aa088efb9 100644
--- a/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
@@ -8,7 +8,6 @@
 
 import org.mockito.invocation.Invocation;
 
-
 public interface RegisteredInvocations {
 
     void add(Invocation invocation);
@@ -20,5 +19,4 @@ public interface RegisteredInvocations {
     void clear();
 
     boolean isEmpty();
-
 }
diff --git a/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java b/mockito-core/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
similarity index 91%
rename from src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
index 61006427db..78ef0066ff 100644
--- a/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
@@ -14,22 +14,27 @@ public class SingleRegisteredInvocation implements RegisteredInvocations, Serial
 
     private Invocation invocation;
 
+    @Override
     public void add(Invocation invocation) {
         this.invocation = invocation;
     }
 
+    @Override
     public void removeLast() {
         invocation = null;
     }
 
+    @Override
     public List<Invocation> getAll() {
         return Collections.emptyList();
     }
 
+    @Override
     public void clear() {
         invocation = null;
     }
 
+    @Override
     public boolean isEmpty() {
         return invocation == null;
     }
diff --git a/src/main/java/org/mockito/internal/verification/Times.java b/mockito-core/src/main/java/org/mockito/internal/verification/Times.java
similarity index 96%
rename from src/main/java/org/mockito/internal/verification/Times.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/Times.java
index 0d4ec53c9e..122ba64f6b 100644
--- a/src/main/java/org/mockito/internal/verification/Times.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/Times.java
@@ -34,10 +34,11 @@ public void verify(VerificationData data) {
         MatchableInvocation wanted = data.getTarget();
 
         if (wantedCount > 0) {
-             checkMissingInvocation(data.getAllInvocations(), data.getTarget());
+            checkMissingInvocation(data.getAllInvocations(), data.getTarget());
         }
         checkNumberOfInvocations(invocations, wanted, wantedCount);
     }
+
     @Override
     public void verifyInOrder(VerificationDataInOrder data) {
         List<Invocation> allInvocations = data.getAllInvocations();
diff --git a/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
similarity index 94%
rename from src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
index 4746130abb..a566ab5eaa 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
@@ -36,11 +36,6 @@ public MatchableInvocation getTarget() {
         return wanted;
     }
 
-    @Override
-    public InvocationMatcher getWanted() {
-        return wanted;
-    }
-
     private void assertWantedIsVerifiable() {
         if (wanted == null) {
             return;
diff --git a/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
similarity index 83%
rename from src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
index bf85055e73..56fabce1fe 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
@@ -14,26 +14,30 @@ public class VerificationEventImpl implements VerificationEvent {
     private final VerificationData data;
     private final Throwable cause;
 
-
-    public VerificationEventImpl(Object mock, VerificationMode mode, VerificationData data, Throwable cause) {
+    public VerificationEventImpl(
+            Object mock, VerificationMode mode, VerificationData data, Throwable cause) {
         this.mock = mock;
         this.mode = mode;
         this.data = data;
         this.cause = cause;
     }
 
+    @Override
     public Object getMock() {
         return mock;
     }
 
+    @Override
     public VerificationMode getMode() {
         return mode;
     }
 
+    @Override
     public VerificationData getData() {
         return data;
     }
 
+    @Override
     public Throwable getVerificationError() {
         return cause;
     }
diff --git a/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
similarity index 88%
rename from src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
index 6af6332399..b3ba446d86 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
@@ -6,7 +6,7 @@
 
 import org.mockito.verification.VerificationMode;
 
-public class VerificationModeFactory {
+public final class VerificationModeFactory {
 
     public static VerificationMode atLeastOnce() {
         return atLeast(1);
@@ -17,7 +17,7 @@ public static VerificationMode atLeast(int minNumberOfInvocations) {
     }
 
     public static VerificationMode only() {
-        return new Only(); //TODO make exception message nicer
+        return new Only(); // TODO make exception message nicer
     }
 
     public static Times times(int wantedNumberOfInvocations) {
@@ -25,7 +25,7 @@ public static Times times(int wantedNumberOfInvocations) {
     }
 
     public static Calls calls(int wantedNumberOfInvocations) {
-        return new Calls( wantedNumberOfInvocations );
+        return new Calls(wantedNumberOfInvocations);
     }
 
     public static NoMoreInteractions noMoreInteractions() {
@@ -54,4 +54,6 @@ public static VerificationMode atMost(int maxNumberOfInvocations) {
     public static VerificationMode description(VerificationMode mode, String description) {
         return new Description(mode, description);
     }
+
+    private VerificationModeFactory() {}
 }
diff --git a/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
similarity index 88%
rename from src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
index 24ec61a90d..2e7b8e7784 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
@@ -32,7 +32,11 @@ public class VerificationOverTimeImpl implements VerificationMode {
      *                        the delegate is satisfied and the full duration has passed (as in
      *                        {@link org.mockito.verification.VerificationAfterDelay}).
      */
-    public VerificationOverTimeImpl(long pollingPeriodMillis, long durationMillis, VerificationMode delegate, boolean returnOnSuccess) {
+    public VerificationOverTimeImpl(
+            long pollingPeriodMillis,
+            long durationMillis,
+            VerificationMode delegate,
+            boolean returnOnSuccess) {
         this(pollingPeriodMillis, delegate, returnOnSuccess, new Timer(durationMillis));
     }
 
@@ -47,7 +51,11 @@ public VerificationOverTimeImpl(long pollingPeriodMillis, long durationMillis, V
      *                        {@link org.mockito.verification.VerificationAfterDelay}).
      * @param timer Checker of whether the duration of the verification is still acceptable
      */
-    public VerificationOverTimeImpl(long pollingPeriodMillis, VerificationMode delegate, boolean returnOnSuccess, Timer timer) {
+    public VerificationOverTimeImpl(
+            long pollingPeriodMillis,
+            VerificationMode delegate,
+            boolean returnOnSuccess,
+            Timer timer) {
         this.pollingPeriodMillis = pollingPeriodMillis;
         this.delegate = delegate;
         this.returnOnSuccess = returnOnSuccess;
@@ -69,6 +77,7 @@ public VerificationOverTimeImpl(long pollingPeriodMillis, VerificationMode deleg
      *
      * @throws MockitoAssertionError if the delegate verification mode does not succeed before the timeout
      */
+    @Override
     public void verify(VerificationData data) {
         AssertionError error = null;
 
@@ -82,10 +91,7 @@ public void verify(VerificationData data) {
                 } else {
                     error = null;
                 }
-            } catch (MockitoAssertionError e) {
-                error = handleVerifyException(e);
-            }
-            catch (AssertionError e) {
+            } catch (AssertionError e) {
                 error = handleVerifyException(e);
             }
         }
@@ -105,11 +111,13 @@ private AssertionError handleVerifyException(AssertionError e) {
     }
 
     protected boolean canRecoverFromFailure(VerificationMode verificationMode) {
-        return !(verificationMode instanceof AtMost || verificationMode instanceof NoMoreInteractions);
+        return !(verificationMode instanceof AtMost
+                || verificationMode instanceof NoMoreInteractions);
     }
 
     public VerificationOverTimeImpl copyWithVerificationMode(VerificationMode verificationMode) {
-        return new VerificationOverTimeImpl(pollingPeriodMillis, timer.duration(), verificationMode, returnOnSuccess);
+        return new VerificationOverTimeImpl(
+                pollingPeriodMillis, timer.duration(), verificationMode, returnOnSuccess);
     }
 
     private void sleep(long sleep) {
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/VerificationWrapper.java b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
new file mode 100644
index 0000000000..6bc592aa7a
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.verification.VerificationMode;
+
+public abstract class VerificationWrapper<WrapperT extends VerificationMode>
+        implements VerificationMode {
+
+    protected final WrapperT wrappedVerification;
+
+    public VerificationWrapper(WrapperT wrappedVerification) {
+        this.wrappedVerification = wrappedVerification;
+    }
+
+    @Override
+    public void verify(VerificationData data) {
+        wrappedVerification.verify(data);
+    }
+
+    protected abstract VerificationMode copySelfWithNewVerificationMode(
+            VerificationMode verificationMode);
+
+    public VerificationMode times(int wantedNumberOfInvocations) {
+        return copySelfWithNewVerificationMode(
+                VerificationModeFactory.times(wantedNumberOfInvocations));
+    }
+
+    public VerificationMode never() {
+        return copySelfWithNewVerificationMode(VerificationModeFactory.atMost(0));
+    }
+
+    public VerificationMode atLeastOnce() {
+        return copySelfWithNewVerificationMode(VerificationModeFactory.atLeastOnce());
+    }
+
+    public VerificationMode atLeast(int minNumberOfInvocations) {
+        return copySelfWithNewVerificationMode(
+                VerificationModeFactory.atLeast(minNumberOfInvocations));
+    }
+
+    public VerificationMode atMostOnce() {
+        return copySelfWithNewVerificationMode(VerificationModeFactory.atMostOnce());
+    }
+
+    public VerificationMode atMost(int maxNumberOfInvocations) {
+        return copySelfWithNewVerificationMode(
+                VerificationModeFactory.atMost(maxNumberOfInvocations));
+    }
+
+    public VerificationMode only() {
+        return copySelfWithNewVerificationMode(VerificationModeFactory.only());
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
new file mode 100644
index 0000000000..16b8c3d3bb
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.InOrderImpl;
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.internal.verification.api.VerificationInOrderMode;
+import org.mockito.verification.VerificationMode;
+
+public class VerificationWrapperInOrderWrapper implements VerificationMode {
+    private final VerificationMode delegate;
+
+    public VerificationWrapperInOrderWrapper(
+            VerificationWrapper<?> verificationWrapper, InOrderImpl inOrder) {
+        VerificationMode verificationMode = verificationWrapper.wrappedVerification;
+
+        VerificationMode inOrderWrappedVerificationMode =
+                wrapInOrder(verificationWrapper, verificationMode, inOrder);
+
+        delegate =
+                verificationWrapper.copySelfWithNewVerificationMode(inOrderWrappedVerificationMode);
+    }
+
+    @Override
+    public void verify(VerificationData data) {
+        delegate.verify(data);
+    }
+
+    private VerificationMode wrapInOrder(
+            VerificationWrapper<?> verificationWrapper,
+            VerificationMode verificationMode,
+            InOrderImpl inOrder) {
+        if (verificationMode instanceof VerificationInOrderMode) {
+            final VerificationInOrderMode verificationInOrderMode =
+                    (VerificationInOrderMode) verificationMode;
+            return new InOrderWrapper(verificationInOrderMode, inOrder);
+        }
+
+        if (verificationMode instanceof VerificationOverTimeImpl) {
+            final VerificationOverTimeImpl verificationOverTime =
+                    (VerificationOverTimeImpl) verificationMode;
+            if (verificationOverTime.isReturnOnSuccess()) {
+                return new VerificationOverTimeImpl(
+                        verificationOverTime.getPollingPeriodMillis(),
+                        verificationOverTime.getTimer().duration(),
+                        wrapInOrder(
+                                verificationWrapper, verificationOverTime.getDelegate(), inOrder),
+                        verificationOverTime.isReturnOnSuccess());
+            }
+        }
+
+        // TODO ugly exception message!!!
+        throw new MockitoException(
+                verificationMode.getClass().getSimpleName()
+                        + " is not implemented to work with InOrder wrapped inside a "
+                        + verificationWrapper.getClass().getSimpleName());
+    }
+}
diff --git a/src/main/java/org/mockito/internal/verification/api/InOrderContext.java b/mockito-core/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
similarity index 99%
rename from src/main/java/org/mockito/internal/verification/api/InOrderContext.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
index c6953bebc0..9672d7eb81 100644
--- a/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
@@ -11,5 +11,4 @@ public interface InOrderContext {
     boolean isVerified(Invocation invocation);
 
     void markVerified(Invocation i);
-
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationData.java b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationData.java
new file mode 100644
index 0000000000..6d579b8698
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationData.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.api;
+
+import java.util.List;
+
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
+
+/**
+ * Data needed to perform verification of interactions.
+ * This interface is considered public even though it lives in private package.
+ * In the next major version of Mockito, this class will be moved to public space.
+ */
+public interface VerificationData {
+
+    /**
+     * All invocations recorded on the mock object that is being verified.
+     * Does not include invocations recorded on other mock objects.
+     */
+    List<Invocation> getAllInvocations();
+
+    /**
+     * The target or wanted invocation.
+     * Below example illustrates what is the 'target' invocation:
+     * <pre class="code"><code class="java">
+     *   mock.foo();   // &lt;- invocation 1
+     *   mock.bar();   // &lt;- invocation 2
+     *
+     *   verify(mock).bar();  // &lt;- target invocation
+     * </code></pre>
+     *
+     * Target invocation can contain argument matchers therefore the returned type is {@link MatchableInvocation}
+     * and not {@link Invocation}.
+     *
+     * @since 2.2.12
+     */
+    MatchableInvocation getTarget();
+}
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
similarity index 99%
rename from src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
index 0f46063fd4..6103f5716e 100644
--- a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
@@ -16,5 +16,4 @@ public interface VerificationDataInOrder {
     MatchableInvocation getWanted();
 
     InOrderContext getOrderingContext();
-
 }
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
similarity index 82%
rename from src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
index 4013b07d6a..838ce5b018 100644
--- a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
@@ -15,20 +15,24 @@ public class VerificationDataInOrderImpl implements VerificationDataInOrder {
     private final List<Invocation> allInvocations;
     private final MatchableInvocation wanted;
 
-    public VerificationDataInOrderImpl(InOrderContext inOrder, List<Invocation> allInvocations, MatchableInvocation wanted) {
+    public VerificationDataInOrderImpl(
+            InOrderContext inOrder, List<Invocation> allInvocations, MatchableInvocation wanted) {
         this.inOrder = inOrder;
         this.allInvocations = allInvocations;
         this.wanted = wanted;
     }
 
+    @Override
     public List<Invocation> getAllInvocations() {
         return allInvocations;
     }
 
+    @Override
     public InOrderContext getOrderingContext() {
         return inOrder;
     }
 
+    @Override
     public MatchableInvocation getWanted() {
         return wanted;
     }
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationInOrderMode.java b/mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationInOrderMode.java
similarity index 100%
rename from src/main/java/org/mockito/internal/verification/api/VerificationInOrderMode.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/api/VerificationInOrderMode.java
diff --git a/src/main/java/org/mockito/internal/verification/api/package-info.java b/mockito-core/src/main/java/org/mockito/internal/verification/api/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/verification/api/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/api/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java b/mockito-core/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java
new file mode 100644
index 0000000000..a34539c06c
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.argumentmatching;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.ContainsExtraTypeInfo;
+
+@SuppressWarnings("rawtypes")
+public class ArgumentMatchingTool {
+
+    private ArgumentMatchingTool() {}
+
+    /**
+     * Suspiciously not matching arguments are those that don't match, the toString() representation is the same but types are different.
+     */
+    public static Integer[] getSuspiciouslyNotMatchingArgsIndexes(
+            List<ArgumentMatcher> matchers, Object[] arguments) {
+        if (matchers.size() != arguments.length) {
+            return new Integer[0];
+        }
+
+        List<Integer> suspicious = new LinkedList<>();
+        int i = 0;
+        for (ArgumentMatcher m : matchers) {
+            if (m instanceof ContainsExtraTypeInfo
+                    && !safelyMatches(m, arguments[i])
+                    && toStringEquals(m, arguments[i])
+                    && !((ContainsExtraTypeInfo) m).typeMatches(arguments[i])) {
+                suspicious.add(i);
+            }
+            i++;
+        }
+        return suspicious.toArray(new Integer[0]);
+    }
+
+    /**
+     * Returns indexes of arguments not matching the provided matchers.
+     */
+    public static List<Integer> getNotMatchingArgsIndexes(
+            List<ArgumentMatcher> matchers, Object[] arguments) {
+        if (matchers.size() != arguments.length) {
+            return Collections.emptyList();
+        }
+
+        List<Integer> nonMatching = new ArrayList<>();
+        int i = 0;
+        for (ArgumentMatcher m : matchers) {
+            if (!safelyMatches(m, arguments[i])) {
+                nonMatching.add(i);
+            }
+
+            i++;
+        }
+
+        return nonMatching;
+    }
+
+    private static boolean safelyMatches(ArgumentMatcher m, Object arg) {
+        try {
+            return m.matches(arg);
+        } catch (Throwable t) {
+            return false;
+        }
+    }
+
+    private static boolean toStringEquals(ArgumentMatcher m, Object arg) {
+        return m.toString().equals(String.valueOf(arg));
+    }
+
+    /**
+     * Suspiciously not matching arguments are those that don't match, and the classes have same simple name.
+     */
+    public static Set<String> getNotMatchingArgsWithSameName(
+            List<ArgumentMatcher> matchers, Object[] arguments) {
+        Map<String, Set<String>> classesHavingSameName = new HashMap<>();
+        for (ArgumentMatcher m : matchers) {
+            if (m instanceof ContainsExtraTypeInfo) {
+                Object wanted = ((ContainsExtraTypeInfo) m).getWanted();
+                if (wanted == null) {
+                    continue;
+                }
+                Class wantedClass = wanted.getClass();
+                classesHavingSameName
+                        .computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>())
+                        .add(wantedClass.getCanonicalName());
+            }
+        }
+        for (Object argument : arguments) {
+            if (argument == null) {
+                continue;
+            }
+            Class wantedClass = argument.getClass();
+            classesHavingSameName
+                    .computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>())
+                    .add(wantedClass.getCanonicalName());
+        }
+        return classesHavingSameName.entrySet().stream()
+                .filter(classEntry -> classEntry.getValue().size() > 1)
+                .map(classEntry -> classEntry.getKey())
+                .collect(Collectors.toSet());
+    }
+}
diff --git a/src/main/java/org/mockito/internal/verification/argumentmatching/package-info.java b/mockito-core/src/main/java/org/mockito/internal/verification/argumentmatching/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/verification/argumentmatching/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/argumentmatching/package-info.java
diff --git a/src/main/java/org/mockito/internal/verification/checkers/AtLeastDiscrepancy.java b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/AtLeastDiscrepancy.java
similarity index 100%
rename from src/main/java/org/mockito/internal/verification/checkers/AtLeastDiscrepancy.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/checkers/AtLeastDiscrepancy.java
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
new file mode 100644
index 0000000000..68a1af1487
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.checkers;
+
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocations;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocationsInOrder;
+import static org.mockito.internal.invocation.InvocationMarker.markVerified;
+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.getAllLocations;
+
+import java.util.List;
+
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+
+public final class AtLeastXNumberOfInvocationsChecker {
+
+    public static void checkAtLeastNumberOfInvocations(
+            List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
+        List<Invocation> actualInvocations = findInvocations(invocations, wanted);
+
+        int actualCount = actualInvocations.size();
+        if (wantedCount > actualCount) {
+            List<Location> allLocations = getAllLocations(actualInvocations);
+            throw tooFewActualInvocations(
+                    new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
+        }
+
+        markVerified(actualInvocations, wanted);
+    }
+
+    public static void checkAtLeastNumberOfInvocations(
+            List<Invocation> invocations,
+            MatchableInvocation wanted,
+            int wantedCount,
+            InOrderContext orderingContext) {
+        List<Invocation> chunk =
+                findAllMatchingUnverifiedChunks(invocations, wanted, orderingContext);
+
+        int actualCount = chunk.size();
+
+        if (wantedCount > actualCount) {
+            List<Location> allLocations = getAllLocations(chunk);
+            throw tooFewActualInvocationsInOrder(
+                    new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
+        }
+
+        markVerifiedInOrder(chunk, wanted, orderingContext);
+    }
+
+    private AtLeastXNumberOfInvocationsChecker() {}
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java
new file mode 100644
index 0000000000..03c3d8b462
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.checkers;
+
+import static org.mockito.internal.exceptions.Reporter.argumentsAreDifferent;
+import static org.mockito.internal.exceptions.Reporter.wantedButNotInvoked;
+import static org.mockito.internal.exceptions.Reporter.wantedButNotInvokedInOrder;
+import static org.mockito.internal.invocation.InvocationsFinder.findAllMatchingUnverifiedChunks;
+import static org.mockito.internal.invocation.InvocationsFinder.findInvocations;
+import static org.mockito.internal.invocation.InvocationsFinder.findPreviousVerifiedInOrder;
+import static org.mockito.internal.invocation.InvocationsFinder.findSimilarInvocation;
+import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getNotMatchingArgsWithSameName;
+import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.mockito.internal.reporting.SmartPrinter;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+
+public class MissingInvocationChecker {
+
+    private MissingInvocationChecker() {}
+
+    public static void checkMissingInvocation(
+            List<Invocation> invocations, MatchableInvocation wanted) {
+        List<Invocation> actualInvocations = findInvocations(invocations, wanted);
+
+        if (!actualInvocations.isEmpty()) {
+            return;
+        }
+
+        Invocation similar = findSimilarInvocation(invocations, wanted);
+        if (similar == null) {
+            throw wantedButNotInvoked(wanted, invocations);
+        }
+
+        Integer[] indexesOfSuspiciousArgs =
+                getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments());
+        Set<String> classesWithSameSimpleName =
+                getNotMatchingArgsWithSameName(wanted.getMatchers(), similar.getArguments());
+        SmartPrinter smartPrinter =
+                new SmartPrinter(
+                        wanted, invocations, indexesOfSuspiciousArgs, classesWithSameSimpleName);
+        List<Location> actualLocations =
+                invocations.stream().map(Invocation::getLocation).collect(Collectors.toList());
+
+        throw argumentsAreDifferent(
+                similar,
+                wanted,
+                smartPrinter.getWanted(),
+                smartPrinter.getActuals(),
+                actualLocations);
+    }
+
+    public static void checkMissingInvocation(
+            List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context) {
+        List<Invocation> chunk = findAllMatchingUnverifiedChunks(invocations, wanted, context);
+
+        if (!chunk.isEmpty()) {
+            return;
+        }
+
+        Invocation previousInOrder = findPreviousVerifiedInOrder(invocations, context);
+        if (previousInOrder != null) {
+            throw wantedButNotInvokedInOrder(wanted, previousInOrder);
+        }
+
+        checkMissingInvocation(invocations, wanted);
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
new file mode 100644
index 0000000000..78a276ef20
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.checkers;
+
+import static org.mockito.internal.exceptions.Reporter.neverWantedButInvoked;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocations;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocationsInOrder;
+import static org.mockito.internal.exceptions.Reporter.tooManyActualInvocations;
+import static org.mockito.internal.exceptions.Reporter.tooManyActualInvocationsInOrder;
+import static org.mockito.internal.invocation.InvocationMarker.markVerified;
+import static org.mockito.internal.invocation.InvocationMarker.markVerifiedInOrder;
+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.getAllLocations;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.mockito.internal.reporting.Discrepancy;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+
+public class NumberOfInvocationsChecker {
+
+    private NumberOfInvocationsChecker() {}
+
+    public static void checkNumberOfInvocations(
+            List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
+        List<Invocation> actualInvocations = findInvocations(invocations, wanted);
+
+        int actualCount = actualInvocations.size();
+        if (wantedCount > actualCount) {
+            List<Location> allLocations = getAllLocations(actualInvocations);
+            throw tooFewActualInvocations(
+                    new Discrepancy(wantedCount, actualCount), wanted, allLocations);
+        }
+        if (wantedCount == 0 && actualCount > 0) {
+            throw neverWantedButInvoked(wanted, actualInvocations);
+        }
+        if (wantedCount < actualCount) {
+            throw tooManyActualInvocations(
+                    wantedCount, actualCount, wanted, getAllLocations(actualInvocations));
+        }
+
+        markVerified(actualInvocations, wanted);
+    }
+
+    public static void checkNumberOfInvocations(
+            List<Invocation> invocations,
+            MatchableInvocation wanted,
+            int wantedCount,
+            InOrderContext context) {
+        List<Invocation> chunk = findMatchingChunk(invocations, wanted, wantedCount, context);
+
+        int actualCount = chunk.size();
+
+        if (wantedCount > actualCount) {
+            List<Location> allLocations = getAllLocations(chunk);
+            throw tooFewActualInvocationsInOrder(
+                    new Discrepancy(wantedCount, actualCount), wanted, allLocations);
+        }
+        if (wantedCount < actualCount) {
+            throw tooManyActualInvocationsInOrder(
+                    wantedCount, actualCount, wanted, getAllLocations(chunk));
+        }
+
+        markVerifiedInOrder(chunk, wanted, context);
+    }
+
+    public static void checkNumberOfInvocationsNonGreedy(
+            List<Invocation> invocations,
+            MatchableInvocation wanted,
+            int wantedCount,
+            InOrderContext context) {
+        int actualCount = 0;
+        Location lastLocation = null;
+        while (actualCount < wantedCount) {
+            Invocation next = findFirstMatchingUnverifiedInvocation(invocations, wanted, context);
+            if (next == null) {
+                throw tooFewActualInvocationsInOrder(
+                        new Discrepancy(wantedCount, actualCount),
+                        wanted,
+                        Arrays.asList(lastLocation));
+            }
+            markVerified(next, wanted);
+            context.markVerified(next);
+            lastLocation = next.getLocation();
+            actualCount++;
+        }
+    }
+}
diff --git a/src/main/java/org/mockito/internal/verification/checkers/package-info.java b/mockito-core/src/main/java/org/mockito/internal/verification/checkers/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/verification/checkers/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/checkers/package-info.java
diff --git a/src/main/java/org/mockito/internal/verification/package-info.java b/mockito-core/src/main/java/org/mockito/internal/verification/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/internal/verification/package-info.java
rename to mockito-core/src/main/java/org/mockito/internal/verification/package-info.java
diff --git a/src/main/java/org/mockito/invocation/DescribedInvocation.java b/mockito-core/src/main/java/org/mockito/invocation/DescribedInvocation.java
similarity index 97%
rename from src/main/java/org/mockito/invocation/DescribedInvocation.java
rename to mockito-core/src/main/java/org/mockito/invocation/DescribedInvocation.java
index fc975aba44..1c54201247 100644
--- a/src/main/java/org/mockito/invocation/DescribedInvocation.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/DescribedInvocation.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.invocation;
 
-
 /**
  * Provides information about the invocation, specifically a human readable description and the location.
  */
@@ -15,6 +14,7 @@ public interface DescribedInvocation {
      *
      * @return the description of this invocation.
      */
+    @Override
     String toString();
 
     /**
diff --git a/src/main/java/org/mockito/invocation/Invocation.java b/mockito-core/src/main/java/org/mockito/invocation/Invocation.java
similarity index 87%
rename from src/main/java/org/mockito/invocation/Invocation.java
rename to mockito-core/src/main/java/org/mockito/invocation/Invocation.java
index ed25fd4c69..4742b34150 100644
--- a/src/main/java/org/mockito/invocation/Invocation.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/Invocation.java
@@ -37,19 +37,10 @@ public interface Invocation extends InvocationOnMock, DescribedInvocation {
      */
     int getSequenceNumber();
 
-    /**
-     * @return the location in code of this invocation.
-     */
+    /** @return the location in code of this invocation. */
+    @Override
     Location getLocation();
 
-    /**
-     * Returns unprocessed arguments whereas {@link #getArguments()} returns
-     * arguments already processed (e.g. varargs expended, etc.).
-     *
-     * @return unprocessed arguments, exactly as provided to this invocation.
-     */
-    Object[] getRawArguments();
-
     /**
      * Wraps each argument using {@link org.mockito.ArgumentMatchers#eq(Object)} or
      * {@link org.mockito.AdditionalMatchers#aryEq(Object[])}
@@ -65,6 +56,7 @@ public interface Invocation extends InvocationOnMock, DescribedInvocation {
      * arguments already processed (e.g. varargs expended, etc.).
      *
      * @return unprocessed arguments, exactly as provided to this invocation.
+     * @since 4.7.0
      */
     Class<?> getRawReturnType();
 
@@ -81,8 +73,7 @@ public interface Invocation extends InvocationOnMock, DescribedInvocation {
     StubInfo stubInfo();
 
     /**
-     * Marks this invocation as stubbed. Passing null resets the invocation state back to not
-     * stubbed.
+     * Marks this invocation as stubbed.
      *
      * @param stubInfo the information about stubbing.
      */
diff --git a/src/main/java/org/mockito/invocation/InvocationContainer.java b/mockito-core/src/main/java/org/mockito/invocation/InvocationContainer.java
similarity index 93%
rename from src/main/java/org/mockito/invocation/InvocationContainer.java
rename to mockito-core/src/main/java/org/mockito/invocation/InvocationContainer.java
index 9f0e82a2ee..d12df44e53 100644
--- a/src/main/java/org/mockito/invocation/InvocationContainer.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/InvocationContainer.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.invocation;
 
-import org.mockito.Incubating;
 import org.mockito.NotExtensible;
 
 /**
@@ -17,5 +16,4 @@
  * @since 2.10.0
  */
 @NotExtensible
-@Incubating
 public interface InvocationContainer {}
diff --git a/mockito-core/src/main/java/org/mockito/invocation/InvocationFactory.java b/mockito-core/src/main/java/org/mockito/invocation/InvocationFactory.java
new file mode 100644
index 0000000000..c28ef716b4
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/invocation/InvocationFactory.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.invocation;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import org.mockito.MockitoFramework;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Available via {@link MockitoFramework#getInvocationFactory()}.
+ * Provides means to create instances of {@link Invocation} objects.
+ * Useful for framework integrations that need to programmatically simulate method calls on mock objects.
+ * To simulate a method call on mock, one needs an instance of {@link Invocation}.
+ * <p>
+ * Please don't provide your own implementation of {@link Invocation} type.
+ * Mockito team needs flexibility to add new methods to this interface if we need to.
+ * If you integrate Mockito framework and you need an instance of {@link Invocation}, use {@link #createInvocation(Object, MockCreationSettings, Method, RealMethodBehavior, Object...)}.
+ *
+ * @since 2.10.0
+ */
+public interface InvocationFactory {
+
+    /**
+     * Behavior of the real method.
+     *
+     * @since 2.14.0
+     */
+    interface RealMethodBehavior<R> extends Serializable {
+        R call() throws Throwable;
+    }
+
+    /**
+     * Creates instance of an {@link Invocation} object.
+     * This method is useful for framework integrators to programmatically simulate method calls on mocks using {@link MockHandler}.
+     * It enables advanced framework integrations.
+     *
+     * @param target the mock object the method is invoked on.
+     * @param settings creation settings of the mock object.
+     * @param method java method invoked on mock.
+     * @param realMethod real method behavior. Needed for spying / invoking real behavior on mock objects.
+     * @param args the java method arguments
+     *
+     * @return invocation instance
+     * @since 2.14.0
+     */
+    Invocation createInvocation(
+            Object target,
+            MockCreationSettings settings,
+            Method method,
+            RealMethodBehavior realMethod,
+            Object... args);
+}
diff --git a/src/main/java/org/mockito/invocation/InvocationOnMock.java b/mockito-core/src/main/java/org/mockito/invocation/InvocationOnMock.java
similarity index 90%
rename from src/main/java/org/mockito/invocation/InvocationOnMock.java
rename to mockito-core/src/main/java/org/mockito/invocation/InvocationOnMock.java
index 269926ea6b..126c2b5999 100644
--- a/src/main/java/org/mockito/invocation/InvocationOnMock.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/InvocationOnMock.java
@@ -32,6 +32,15 @@ public interface InvocationOnMock extends Serializable {
      */
     Method getMethod();
 
+    /**
+     * Returns unprocessed arguments whereas {@link #getArguments()} returns
+     * arguments already processed (e.g. varargs expended, etc.).
+     *
+     * @return unprocessed arguments, exactly as provided to this invocation.
+     * @since 4.7.0
+     */
+    Object[] getRawArguments();
+
     /**
      * Returns arguments passed to the method.
      *
diff --git a/src/main/java/org/mockito/invocation/Location.java b/mockito-core/src/main/java/org/mockito/invocation/Location.java
similarity index 97%
rename from src/main/java/org/mockito/invocation/Location.java
rename to mockito-core/src/main/java/org/mockito/invocation/Location.java
index 43b48324d8..ea3c274bc5 100644
--- a/src/main/java/org/mockito/invocation/Location.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/Location.java
@@ -17,6 +17,7 @@ public interface Location {
      *
      * @return location
      */
+    @Override
     String toString();
 
     /**
diff --git a/src/main/java/org/mockito/invocation/MatchableInvocation.java b/mockito-core/src/main/java/org/mockito/invocation/MatchableInvocation.java
similarity index 95%
rename from src/main/java/org/mockito/invocation/MatchableInvocation.java
rename to mockito-core/src/main/java/org/mockito/invocation/MatchableInvocation.java
index 96ddf9ea99..af642e517f 100644
--- a/src/main/java/org/mockito/invocation/MatchableInvocation.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/MatchableInvocation.java
@@ -14,8 +14,8 @@
  * It is used during verification process:
  *
  * <pre class="code"><code class="java">
- *   mock.foo();   // <- invocation
- *   verify(mock).bar();  // <- matchable invocation
+ *   mock.foo();   // &lt;- invocation
+ *   verify(mock).bar();  // &lt;- matchable invocation
  * </code></pre>
  *
  * @since 2.2.12
diff --git a/src/main/java/org/mockito/invocation/MockHandler.java b/mockito-core/src/main/java/org/mockito/invocation/MockHandler.java
similarity index 97%
rename from src/main/java/org/mockito/invocation/MockHandler.java
rename to mockito-core/src/main/java/org/mockito/invocation/MockHandler.java
index d20b76b2e6..56a0004ad4 100644
--- a/src/main/java/org/mockito/invocation/MockHandler.java
+++ b/mockito-core/src/main/java/org/mockito/invocation/MockHandler.java
@@ -6,7 +6,6 @@
 
 import java.io.Serializable;
 
-import org.mockito.Incubating;
 import org.mockito.MockSettings;
 import org.mockito.mock.MockCreationSettings;
 
@@ -44,7 +43,6 @@ public interface MockHandler<T> extends Serializable {
      * @return read-only settings of the mock
      * @since 2.10.0
      */
-    @Incubating
     MockCreationSettings<T> getMockSettings();
 
     /**
@@ -60,6 +58,5 @@ public interface MockHandler<T> extends Serializable {
      *          The container is not part of the public API, please do not cast it or provide custom implementations.
      * @since 2.10.0
      */
-    @Incubating
     InvocationContainer getInvocationContainer();
 }
diff --git a/src/main/java/org/mockito/invocation/StubInfo.java b/mockito-core/src/main/java/org/mockito/invocation/StubInfo.java
similarity index 100%
rename from src/main/java/org/mockito/invocation/StubInfo.java
rename to mockito-core/src/main/java/org/mockito/invocation/StubInfo.java
diff --git a/src/main/java/org/mockito/invocation/package-info.java b/mockito-core/src/main/java/org/mockito/invocation/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/invocation/package-info.java
rename to mockito-core/src/main/java/org/mockito/invocation/package-info.java
diff --git a/src/main/java/org/mockito/junit/MockitoJUnit.java b/mockito-core/src/main/java/org/mockito/junit/MockitoJUnit.java
similarity index 87%
rename from src/main/java/org/mockito/junit/MockitoJUnit.java
rename to mockito-core/src/main/java/org/mockito/junit/MockitoJUnit.java
index 244389a5f4..c925995829 100644
--- a/src/main/java/org/mockito/junit/MockitoJUnit.java
+++ b/mockito-core/src/main/java/org/mockito/junit/MockitoJUnit.java
@@ -5,7 +5,6 @@
 package org.mockito.junit;
 
 import org.junit.rules.TestRule;
-import org.mockito.Incubating;
 import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.internal.junit.JUnitRule;
 import org.mockito.internal.junit.JUnitTestRule;
@@ -17,12 +16,12 @@
  * <li>
  *     <ul>JUnit Rules - see {@link MockitoRule}</ul>
  *     <ul>JUnit runners - see {@link MockitoJUnitRunner}</ul>
- *     <ul><a href="http://javadoc.io/doc/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">JUnit Jupiter extension</a></ul>
+ *     <ul><a href="https://javadoc.io/doc/org.mockito/mockito-junit-jupiter/latest/org.mockito.junit.jupiter/org/mockito/junit/jupiter/MockitoExtension.html">JUnit Jupiter extension</a></ul>
  * </li>
  *
  * @since 1.10.17
  */
-public class MockitoJUnit {
+public final class MockitoJUnit {
 
     /**
      * Creates rule instance that initiates &#064;Mocks
@@ -56,8 +55,9 @@ public static MockitoTestRule testRule(Object testInstance) {
      * @return the rule instance
      * @since 2.1.0
      */
-    @Incubating
     public static VerificationCollector collector() {
         return new VerificationCollectorImpl();
     }
+
+    private MockitoJUnit() {}
 }
diff --git a/mockito-core/src/main/java/org/mockito/junit/MockitoJUnitRunner.java b/mockito-core/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
new file mode 100644
index 0000000000..bfc938e2dc
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.notification.RunNotifier;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.MockitoSession;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.internal.runners.InternalRunner;
+import org.mockito.internal.runners.RunnerFactory;
+import org.mockito.internal.runners.StrictRunner;
+import org.mockito.quality.MockitoHint;
+import org.mockito.quality.Strictness;
+
+/**
+ * Mockito JUnit Runner keeps tests clean and improves debugging experience.
+ * Make sure to try out {@link MockitoJUnitRunner.StrictStubs} which automatically
+ * detects <strong>stubbing argument mismatches</strong> and is planned to be the default in Mockito v3.
+ * Runner is compatible with JUnit 4.4 and higher and adds following behavior:
+ * <ul>
+ *   <li>
+ *       (new since Mockito 2.1.0) Detects unused stubs in the test code.
+ *       See {@link UnnecessaryStubbingException}.
+ *       Similar to JUnit rules, the runner also reports stubbing argument mismatches as console warnings
+ *       (see {@link MockitoHint}).
+ *       To opt-out from this feature, use {@code @RunWith(MockitoJUnitRunner.Silent.class)}
+ *   <li>
+ *      Initializes mocks annotated with {@link Mock},
+ *      so that explicit usage of {@link MockitoAnnotations#openMocks(Object)} is not necessary.
+ *      Mocks are initialized before each test method.
+ *   <li>
+ *      Validates framework usage after each test method. See javadoc for {@link Mockito#validateMockitoUsage()}.
+ *   <li>
+ *      It is highly recommended to use {@link MockitoJUnitRunner.StrictStubs} variant of the runner.
+ *      It drives cleaner tests and improves debugging experience.
+ *      The only reason this feature is not turned on by default
+ *      is because it would have been an incompatible change
+ *      and Mockito strictly follows <a href="https://semver.org">semantic versioning</a>.
+ * </ul>
+ *
+ * Runner is completely optional - there are other ways you can get &#064;Mock working, for example by writing a base class.
+ * Explicitly validating framework usage is also optional because it is triggered automatically by Mockito every time you use the framework.
+ * See javadoc for {@link Mockito#validateMockitoUsage()}.
+ * <p>
+ * Read more about &#064;Mock annotation in javadoc for {@link MockitoAnnotations}
+ * <pre class="code"><code class="java">
+ * <b>&#064;RunWith(MockitoJUnitRunner.StrictStubs.class)</b>
+ * public class ExampleTest {
+ *
+ *     &#064;Mock
+ *     private List list;
+ *
+ *     &#064;Test
+ *     public void shouldDoSomething() {
+ *         list.add(100);
+ *     }
+ * }
+ * </code></pre>
+ *
+ * If you would like to take advantage of Mockito JUnit runner features,
+ * but you cannot use the runner there is a solution!
+ * {@link MockitoSession} API is intended to offer cleaner tests and improved debuggability
+ * to users that cannot use Mockito's built-in JUnit support (runner or the rule).
+ */
+public class MockitoJUnitRunner extends Runner implements Filterable {
+
+    /**
+     * This Mockito JUnit Runner implementation *ignores*
+     * stubbing argument mismatches ({@link MockitoJUnitRunner.StrictStubs})
+     * and *does not detect* unused stubbings.
+     * The runner remains 'silent' even if incorrect stubbing is present.
+     * It is an equivalent of {@link Strictness#LENIENT}.
+     * This was the behavior of Mockito JUnit runner in versions 1.x.
+     * Using this implementation of the runner is not recommended.
+     * Engineers should care for removing unused stubbings because they are dead code,
+     * they add unnecessary details, potentially making the test code harder to comprehend.
+     * If you have good reasons to use the silent runner, let us know at the mailing list
+     * or raise an issue in our issue tracker.
+     * The purpose of silent implementation is to satisfy edge/unanticipated use cases,
+     * and to offer users an opt-out.
+     * Mockito framework is opinionated to drive clean tests but it is not dogmatic.
+     * <p>
+     * See also {@link UnnecessaryStubbingException}.
+     * <p>
+     * Usage:
+     * <pre class="code"><code class="java">
+     * <b>&#064;RunWith(MockitoJUnitRunner.Silent.class)</b>
+     * public class ExampleTest {
+     *   // ...
+     * }
+     * </code></pre>
+     *
+     * @since 2.1.0
+     */
+    public static class Silent extends MockitoJUnitRunner {
+        public Silent(Class<?> klass) throws InvocationTargetException {
+            super(new RunnerFactory().create(klass));
+        }
+    }
+
+    /**
+     * Detects unused stubs and reports them as failures. Default behavior in Mockito 2.x.
+     * To improve productivity and quality of tests please consider newer API, the {@link StrictStubs}.
+     * <p>
+     * For more information on detecting unused stubs, see {@link UnnecessaryStubbingException}.
+     * For more information on stubbing argument mismatch warnings see {@link MockitoHint}.
+     *
+     * @since 2.1.0
+     */
+    public static class Strict extends MockitoJUnitRunner {
+        public Strict(Class<?> klass) throws InvocationTargetException {
+            super(new StrictRunner(new RunnerFactory().createStrict(klass), klass));
+        }
+    }
+
+    /**
+     * Improves debugging tests, helps keeping the tests clean.
+     * Highly recommended to improve productivity and quality of tests.
+     * Planned default behavior for Mockito v3.
+     * Adds behavior equivalent to {@link Strictness#STRICT_STUBS}.
+     * <p>
+     * Usage:
+     * <pre class="code"><code class="java">
+     * <b>&#064;RunWith(MockitoJUnitRunner.StrictStubs.class)</b>
+     * public class ExampleTest {
+     *   // ...
+     * }
+     * </code></pre>
+     *
+     * @since 2.5.1
+     */
+    public static class StrictStubs extends MockitoJUnitRunner {
+        public StrictStubs(Class<?> klass) throws InvocationTargetException {
+            super(new StrictRunner(new RunnerFactory().createStrictStubs(klass), klass));
+        }
+    }
+
+    private final InternalRunner runner;
+
+    public MockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
+        // by default, StrictRunner is used. We can change that potentially based on feedback from
+        // users
+        this(new StrictRunner(new RunnerFactory().createStrict(klass), klass));
+    }
+
+    MockitoJUnitRunner(InternalRunner runner) {
+        this.runner = runner;
+    }
+
+    @Override
+    public void run(final RunNotifier notifier) {
+        runner.run(notifier);
+    }
+
+    @Override
+    public Description getDescription() {
+        return runner.getDescription();
+    }
+
+    @Override
+    public void filter(Filter filter) throws NoTestsRemainException {
+        // filter is required because without it UnrootedTests show up in Eclipse
+        runner.filter(filter);
+    }
+}
diff --git a/src/main/java/org/mockito/junit/MockitoRule.java b/mockito-core/src/main/java/org/mockito/junit/MockitoRule.java
similarity index 95%
rename from src/main/java/org/mockito/junit/MockitoRule.java
rename to mockito-core/src/main/java/org/mockito/junit/MockitoRule.java
index 98de12ed10..10a2735e92 100644
--- a/src/main/java/org/mockito/junit/MockitoRule.java
+++ b/mockito-core/src/main/java/org/mockito/junit/MockitoRule.java
@@ -5,7 +5,6 @@
 package org.mockito.junit;
 
 import org.junit.rules.MethodRule;
-import org.mockito.Incubating;
 import org.mockito.MockSettings;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
@@ -37,7 +36,7 @@
  *      See also {@link MockitoHint}.
  *   <li>
  *      Initializes mocks annotated with {@link org.mockito.Mock},
- *      so that explicit usage of {@link MockitoAnnotations#initMocks(Object)} is not necessary.
+ *      so that explicit usage of {@link MockitoAnnotations#openMocks(Object)} is not necessary.
  *      Mocks are initialized before each test method.
  *   <li>
  *      Validates framework usage after each test method. See javadoc for {@link org.mockito.Mockito#validateMockitoUsage()}.
@@ -46,7 +45,7 @@
  *      It drives cleaner tests and improves debugging experience.
  *      The only reason this feature is not turned on by default
  *      is because it would have been an incompatible change
- *      and Mockito strictly follows <a href="http://semver.org">semantic versioning</a>.
+ *      and Mockito strictly follows <a href="https://semver.org">semantic versioning</a>.
  *
  * </ul>
  * Example use:
@@ -67,7 +66,7 @@
  * </code></pre>
  *
  * If you would like to take advantage of Mockito JUnit rule features
- * but you cannot use the rule because, for example, you use TestNG, there is a solution!
+ * but you cannot use the rule there is a solution!
  * {@link MockitoSession} API is intended to offer cleaner tests and improved debuggability
  * to users that cannot use Mockito's built-in JUnit support (runner or the rule).
  *
@@ -146,6 +145,5 @@ public interface MockitoRule extends MethodRule {
      *
      * @since 2.3.0
      */
-    @Incubating
     MockitoRule strictness(Strictness strictness);
 }
diff --git a/src/main/java/org/mockito/junit/MockitoTestRule.java b/mockito-core/src/main/java/org/mockito/junit/MockitoTestRule.java
similarity index 94%
rename from src/main/java/org/mockito/junit/MockitoTestRule.java
rename to mockito-core/src/main/java/org/mockito/junit/MockitoTestRule.java
index d5332a1c66..5efc690a76 100644
--- a/src/main/java/org/mockito/junit/MockitoTestRule.java
+++ b/mockito-core/src/main/java/org/mockito/junit/MockitoTestRule.java
@@ -5,7 +5,6 @@
 package org.mockito.junit;
 
 import org.junit.rules.TestRule;
-import org.mockito.Incubating;
 import org.mockito.quality.Strictness;
 
 /**
@@ -28,7 +27,5 @@ public interface MockitoTestRule extends TestRule {
      *
      * @since 3.3.0
      */
-    @Incubating
     MockitoTestRule strictness(Strictness strictness);
-
 }
diff --git a/src/main/java/org/mockito/junit/VerificationCollector.java b/mockito-core/src/main/java/org/mockito/junit/VerificationCollector.java
similarity index 97%
rename from src/main/java/org/mockito/junit/VerificationCollector.java
rename to mockito-core/src/main/java/org/mockito/junit/VerificationCollector.java
index 08962b58f3..c214b5dd22 100644
--- a/src/main/java/org/mockito/junit/VerificationCollector.java
+++ b/mockito-core/src/main/java/org/mockito/junit/VerificationCollector.java
@@ -5,7 +5,6 @@
 package org.mockito.junit;
 
 import org.junit.rules.TestRule;
-import org.mockito.Incubating;
 import org.mockito.exceptions.base.MockitoAssertionError;
 
 /**
@@ -37,7 +36,6 @@
  * @see org.mockito.Mockito#verify(Object, org.mockito.verification.VerificationMode)
  * @since 2.1.0
  */
-@Incubating
 public interface VerificationCollector extends TestRule {
 
     /**
@@ -70,7 +68,6 @@ public interface VerificationCollector extends TestRule {
      * @throws MockitoAssertionError If there were failed verifications
      * @since 2.1.0
      */
-    @Incubating
     void collectAndReport() throws MockitoAssertionError;
 
     /**
@@ -96,6 +93,5 @@ public interface VerificationCollector extends TestRule {
      * @return this
      * @since 2.1.0
      */
-    @Incubating
     VerificationCollector assertLazily();
 }
diff --git a/src/main/java/org/mockito/junit/package-info.java b/mockito-core/src/main/java/org/mockito/junit/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/junit/package-info.java
rename to mockito-core/src/main/java/org/mockito/junit/package-info.java
diff --git a/src/main/java/org/mockito/listeners/InvocationListener.java b/mockito-core/src/main/java/org/mockito/listeners/InvocationListener.java
similarity index 100%
rename from src/main/java/org/mockito/listeners/InvocationListener.java
rename to mockito-core/src/main/java/org/mockito/listeners/InvocationListener.java
diff --git a/src/main/java/org/mockito/listeners/MethodInvocationReport.java b/mockito-core/src/main/java/org/mockito/listeners/MethodInvocationReport.java
similarity index 100%
rename from src/main/java/org/mockito/listeners/MethodInvocationReport.java
rename to mockito-core/src/main/java/org/mockito/listeners/MethodInvocationReport.java
diff --git a/mockito-core/src/main/java/org/mockito/listeners/MockCreationListener.java b/mockito-core/src/main/java/org/mockito/listeners/MockCreationListener.java
new file mode 100644
index 0000000000..7ab15f8236
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/listeners/MockCreationListener.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.listeners;
+
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Notified when mock object is created.
+ * For more information on listeners see {@link org.mockito.MockitoFramework#addListener(MockitoListener)}.
+ */
+public interface MockCreationListener extends MockitoListener {
+
+    /**
+     * Mock object was just created.
+     *
+     * @param mock created mock object
+     * @param settings the settings used for creation
+     */
+    void onMockCreated(Object mock, MockCreationSettings settings);
+
+    /**
+     * Static mock object was just created.
+     *
+     * @param mock the type being mocked
+     * @param settings the settings used for creation
+     */
+    default void onStaticMockCreated(Class<?> mock, MockCreationSettings settings) {}
+}
diff --git a/src/main/java/org/mockito/listeners/MockitoListener.java b/mockito-core/src/main/java/org/mockito/listeners/MockitoListener.java
similarity index 89%
rename from src/main/java/org/mockito/listeners/MockitoListener.java
rename to mockito-core/src/main/java/org/mockito/listeners/MockitoListener.java
index ea8dcb6db2..b5a4e5e883 100644
--- a/src/main/java/org/mockito/listeners/MockitoListener.java
+++ b/mockito-core/src/main/java/org/mockito/listeners/MockitoListener.java
@@ -8,5 +8,4 @@
  * Marker interface for all types of Mockito listeners.
  * For more information, see {@link org.mockito.MockitoFramework#addListener(MockitoListener)}.
  */
-public interface MockitoListener {
-}
+public interface MockitoListener {}
diff --git a/src/main/java/org/mockito/listeners/StubbingLookupEvent.java b/mockito-core/src/main/java/org/mockito/listeners/StubbingLookupEvent.java
similarity index 100%
rename from src/main/java/org/mockito/listeners/StubbingLookupEvent.java
rename to mockito-core/src/main/java/org/mockito/listeners/StubbingLookupEvent.java
diff --git a/src/main/java/org/mockito/listeners/StubbingLookupListener.java b/mockito-core/src/main/java/org/mockito/listeners/StubbingLookupListener.java
similarity index 100%
rename from src/main/java/org/mockito/listeners/StubbingLookupListener.java
rename to mockito-core/src/main/java/org/mockito/listeners/StubbingLookupListener.java
diff --git a/src/main/java/org/mockito/listeners/VerificationListener.java b/mockito-core/src/main/java/org/mockito/listeners/VerificationListener.java
similarity index 94%
rename from src/main/java/org/mockito/listeners/VerificationListener.java
rename to mockito-core/src/main/java/org/mockito/listeners/VerificationListener.java
index c42be31752..9f3aaae548 100644
--- a/src/main/java/org/mockito/listeners/VerificationListener.java
+++ b/mockito-core/src/main/java/org/mockito/listeners/VerificationListener.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.listeners;
 
-import org.mockito.Incubating;
 import org.mockito.verification.VerificationEvent;
 
 /**
@@ -12,7 +11,6 @@
  * <p>
  * For this to happen, it must be registered using {@link org.mockito.internal.progress.MockingProgress#addListener(MockitoListener)}.
  */
-@Incubating
 public interface VerificationListener extends MockitoListener {
     /**
      * Called after a verification happened.
diff --git a/src/main/java/org/mockito/listeners/VerificationStartedEvent.java b/mockito-core/src/main/java/org/mockito/listeners/VerificationStartedEvent.java
similarity index 94%
rename from src/main/java/org/mockito/listeners/VerificationStartedEvent.java
rename to mockito-core/src/main/java/org/mockito/listeners/VerificationStartedEvent.java
index b2f4a00dd8..0eb72ce410 100644
--- a/src/main/java/org/mockito/listeners/VerificationStartedEvent.java
+++ b/mockito-core/src/main/java/org/mockito/listeners/VerificationStartedEvent.java
@@ -4,15 +4,12 @@
  */
 package org.mockito.listeners;
 
-import org.mockito.Incubating;
-
 /**
  * The instance of this class is passed to {@link VerificationStartedListener}.
  * For all the details, including how and why to use this API, see {@link VerificationStartedListener}.
  *
  * @since 2.11.0
  */
-@Incubating
 public interface VerificationStartedEvent {
 
     /**
@@ -27,7 +24,6 @@ public interface VerificationStartedEvent {
      * @param mock to be used for verification.
      * @since 2.11.0
      */
-    @Incubating
     void setMock(Object mock);
 
     /**
@@ -37,6 +33,5 @@ public interface VerificationStartedEvent {
      *
      * @since 2.11.0
      */
-    @Incubating
     Object getMock();
 }
diff --git a/src/main/java/org/mockito/listeners/VerificationStartedListener.java b/mockito-core/src/main/java/org/mockito/listeners/VerificationStartedListener.java
similarity index 98%
rename from src/main/java/org/mockito/listeners/VerificationStartedListener.java
rename to mockito-core/src/main/java/org/mockito/listeners/VerificationStartedListener.java
index f555125557..d942a1cc3c 100644
--- a/src/main/java/org/mockito/listeners/VerificationStartedListener.java
+++ b/mockito-core/src/main/java/org/mockito/listeners/VerificationStartedListener.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.listeners;
 
-import org.mockito.Incubating;
-
 /**
  * This listener gets notified when the user starts verification.
  * It allows to replace the mock object for verification.
@@ -54,7 +52,6 @@
  *
  * @since 2.11.0
  */
-@Incubating
 public interface VerificationStartedListener {
 
     /**
@@ -64,6 +61,5 @@ public interface VerificationStartedListener {
      * @param event object that allows to identify and replace mock for verification.
      * @since 2.11.0
      */
-    @Incubating
     void onVerificationStarted(VerificationStartedEvent event);
 }
diff --git a/src/main/java/org/mockito/listeners/package-info.java b/mockito-core/src/main/java/org/mockito/listeners/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/listeners/package-info.java
rename to mockito-core/src/main/java/org/mockito/listeners/package-info.java
diff --git a/src/main/java/org/mockito/mock/MockCreationSettings.java b/mockito-core/src/main/java/org/mockito/mock/MockCreationSettings.java
similarity index 80%
rename from src/main/java/org/mockito/mock/MockCreationSettings.java
rename to mockito-core/src/main/java/org/mockito/mock/MockCreationSettings.java
index 726428660b..8d5631535d 100644
--- a/src/main/java/org/mockito/mock/MockCreationSettings.java
+++ b/mockito-core/src/main/java/org/mockito/mock/MockCreationSettings.java
@@ -4,15 +4,16 @@
  */
 package org.mockito.mock;
 
+import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Set;
 
-import org.mockito.Incubating;
 import org.mockito.MockSettings;
 import org.mockito.NotExtensible;
 import org.mockito.listeners.InvocationListener;
 import org.mockito.listeners.StubbingLookupListener;
 import org.mockito.listeners.VerificationStartedListener;
+import org.mockito.plugins.MockMaker;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
 
@@ -27,6 +28,11 @@ public interface MockCreationSettings<T> {
      */
     Class<T> getTypeToMock();
 
+    /**
+     * The generic type of the mock, if any.
+     */
+    Type getGenericTypeToMock();
+
     /**
      * the extra interfaces the mock object should implement.
      */
@@ -90,7 +96,6 @@ public interface MockCreationSettings<T> {
      *
      * @since 2.11.0
      */
-    @Incubating
     List<VerificationStartedListener> getVerificationStartedListeners();
 
     /**
@@ -98,7 +103,6 @@ public interface MockCreationSettings<T> {
      *
      * @since 1.10.12
      */
-    @Incubating
     boolean isUsingConstructor();
 
     /**
@@ -110,7 +114,6 @@ public interface MockCreationSettings<T> {
      *
      * @since 2.7.14
      */
-    @Incubating
     Object[] getConstructorArgs();
 
     /**
@@ -119,15 +122,41 @@ public interface MockCreationSettings<T> {
      * @return the outer class instance used for creation of the mock object via the constructor.
      * @since 1.10.12
      */
-    @Incubating
     Object getOuterClassInstance();
 
     /**
+     *  @deprecated Use {@link MockCreationSettings#getStrictness()} instead.
+     *
      * 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
+    @Deprecated
     boolean isLenient();
+
+    /**
+     * Sets strictness level for the mock, e.g. having {@link Strictness#STRICT_STUBS} characteristic.
+     * For more information about using mocks with custom strictness, see {@link MockSettings#strictness(Strictness)}.
+     *
+     * @since 4.6.0
+     */
+    Strictness getStrictness();
+
+    /**
+     * Returns the {@link MockMaker} which shall be used to create the mock.
+     * When the return value is {@code null}, the default shall be used.
+     *
+     * @see MockSettings#mockMaker(String)
+     * @since 4.8.0
+     */
+    String getMockMaker();
+
+    /**
+     * Returns the {@link MockType} for the mock being created.
+     *
+     * @see MockType
+     * @since 5.9.0
+     */
+    MockType getMockType();
 }
diff --git a/src/main/java/org/mockito/mock/MockName.java b/mockito-core/src/main/java/org/mockito/mock/MockName.java
similarity index 92%
rename from src/main/java/org/mockito/mock/MockName.java
rename to mockito-core/src/main/java/org/mockito/mock/MockName.java
index d3f6e7dd51..64ce8f7982 100644
--- a/src/main/java/org/mockito/mock/MockName.java
+++ b/mockito-core/src/main/java/org/mockito/mock/MockName.java
@@ -9,9 +9,8 @@
  */
 public interface MockName {
 
-    /**
-     * the name
-     */
+    /** the name */
+    @Override
     String toString();
 
     /**
diff --git a/mockito-core/src/main/java/org/mockito/mock/MockType.java b/mockito-core/src/main/java/org/mockito/mock/MockType.java
new file mode 100644
index 0000000000..e2a7b4fd92
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/mock/MockType.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.mock;
+
+/**
+ * The type of mock being created
+ */
+public enum MockType {
+
+    /**
+     * Mock created as an instance of the mocked type
+     */
+    INSTANCE,
+
+    /**
+     * Mock replaces the mocked type through static mocking
+     */
+    STATIC,
+}
diff --git a/src/main/java/org/mockito/mock/SerializableMode.java b/mockito-core/src/main/java/org/mockito/mock/SerializableMode.java
similarity index 89%
rename from src/main/java/org/mockito/mock/SerializableMode.java
rename to mockito-core/src/main/java/org/mockito/mock/SerializableMode.java
index 790fc04f1d..41a5f36796 100644
--- a/src/main/java/org/mockito/mock/SerializableMode.java
+++ b/mockito-core/src/main/java/org/mockito/mock/SerializableMode.java
@@ -4,12 +4,9 @@
  */
 package org.mockito.mock;
 
-import org.mockito.Incubating;
-
 /**
  * Mock serializable style.
  */
-@Incubating
 public enum SerializableMode {
 
     /**
@@ -25,6 +22,5 @@ public enum SerializableMode {
     /**
      * Useful if the mock is deserialized in a different classloader / vm.
      */
-    @Incubating
     ACROSS_CLASSLOADERS
 }
diff --git a/src/main/java/org/mockito/mock/package-info.java b/mockito-core/src/main/java/org/mockito/mock/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/mock/package-info.java
rename to mockito-core/src/main/java/org/mockito/mock/package-info.java
diff --git a/src/main/java/org/mockito/package-info.java b/mockito-core/src/main/java/org/mockito/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/package-info.java
rename to mockito-core/src/main/java/org/mockito/package-info.java
diff --git a/mockito-core/src/main/java/org/mockito/plugins/AnnotationEngine.java b/mockito-core/src/main/java/org/mockito/plugins/AnnotationEngine.java
new file mode 100644
index 0000000000..c6365e9f18
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/AnnotationEngine.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+/**
+ * Configures test via annotations.
+ *
+ * <p>Mockito default engine handles the logic behind &#064;Mock, &#064;Captor, &#064;Spy and &#064;InjectMocks annotations.
+ *
+ * <p>This interface is an extension point that make possible to use a different annotation engine allowing to extend
+ * or replace mockito default engine.
+ *
+ * <p>
+ * If you are interested then see implementations or source code of {@link org.mockito.MockitoAnnotations#openMocks(Object)}
+ *
+ * <p>This plugin mechanism supersedes the {@link org.mockito.configuration.IMockitoConfiguration}
+ * in regard of switching mockito components.
+ */
+public interface AnnotationEngine {
+    /**
+     * Processes the test instance to configure annotated members.
+     *
+     * @param clazz Class where to extract field information, check implementation for details
+     * @param testInstance Test instance
+     */
+    AutoCloseable process(Class<?> clazz, Object testInstance);
+
+    class NoAction implements AutoCloseable {
+
+        @Override
+        public void close() {}
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java b/mockito-core/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java
new file mode 100644
index 0000000000..bc3c77a014
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.NotExtensible;
+import org.mockito.mock.MockCreationSettings;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Enforcer that is applied to every type in the type hierarchy of the class-to-be-mocked.
+ */
+public interface DoNotMockEnforcer extends DoNotMockEnforcerWithType {
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     * <p>
+     * Note that traversal of the type hierarchy is performed externally to this method.
+     * Implementations of it should therefore not perform type traversal themselves.
+     *
+     * @param type The type to check
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     * @see #checkTypeForDoNotMockViolation(MockCreationSettings)
+     */
+    String checkTypeForDoNotMockViolation(Class<?> type);
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     * <p>
+     * The default implementation traverses the class hierarchy of the type to be mocked and
+     * checks it against {@link #checkTypeForDoNotMockViolation(Class)}. If any types fails
+     * the validation, the traversal is interrupted and the error message is returned.
+     *
+     * @param creationSettings The mock creation settings
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     * @since 5.9.0
+     */
+    @Override
+    default String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings) {
+        String warning = recursiveCheckDoNotMockAnnotationForType(creationSettings.getTypeToMock());
+        if (warning != null) {
+            return warning;
+        }
+
+        for (Class<?> aClass : creationSettings.getExtraInterfaces()) {
+            warning = recursiveCheckDoNotMockAnnotationForType(aClass);
+            if (warning != null) {
+                return warning;
+            }
+        }
+
+        return null;
+    }
+
+    private String recursiveCheckDoNotMockAnnotationForType(Class<?> type) {
+        // Object and interfaces do not have a super class
+        if (type == null) {
+            return null;
+        }
+
+        if (Cache.MOCKABLE_TYPES.contains(type)) {
+            return null;
+        }
+
+        String warning = checkTypeForDoNotMockViolation(type);
+        if (warning != null) {
+            return warning;
+        }
+
+        warning = recursiveCheckDoNotMockAnnotationForType(type.getSuperclass());
+        if (warning != null) {
+            return warning;
+        }
+
+        for (Class<?> aClass : type.getInterfaces()) {
+            warning = recursiveCheckDoNotMockAnnotationForType(aClass);
+            if (warning != null) {
+                return warning;
+            }
+        }
+
+        Cache.MOCKABLE_TYPES.add(type);
+        return null;
+    }
+
+    /**
+     * Static cache for types that are known to be mockable and
+     * thus may be skipped while traversing the class hierarchy.
+     */
+    @NotExtensible
+    class Cache {
+        private static final Set<Class<?>> MOCKABLE_TYPES = ConcurrentHashMap.newKeySet();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java b/mockito-core/src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java
new file mode 100644
index 0000000000..5bbff900c7
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Enforcer that checks if a mock can be created given its type and other settings used in its creation.
+ *
+ * @since 5.9.0
+ */
+public interface DoNotMockEnforcerWithType {
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     *
+     * @param creationSettings The mock creation settings
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     */
+    String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings);
+}
diff --git a/src/main/java/org/mockito/plugins/InlineMockMaker.java b/mockito-core/src/main/java/org/mockito/plugins/InlineMockMaker.java
similarity index 88%
rename from src/main/java/org/mockito/plugins/InlineMockMaker.java
rename to mockito-core/src/main/java/org/mockito/plugins/InlineMockMaker.java
index 7acaf19b7b..6c3703c09e 100644
--- a/src/main/java/org/mockito/plugins/InlineMockMaker.java
+++ b/mockito-core/src/main/java/org/mockito/plugins/InlineMockMaker.java
@@ -4,8 +4,8 @@
  */
 package org.mockito.plugins;
 
-import org.mockito.Incubating;
 import org.mockito.MockitoFramework;
+import org.mockito.exceptions.misusing.DisabledMockException;
 
 /**
  * Extension to {@link MockMaker} for mock makers that changes inline method implementations
@@ -26,7 +26,6 @@
  *
  * @since 2.25.0
  */
-@Incubating
 public interface InlineMockMaker extends MockMaker {
 
     /**
@@ -36,16 +35,13 @@ public interface InlineMockMaker extends MockMaker {
      * @param mock the mock instance whose internal state is to be cleaned.
      * @since 2.25.0
      */
-    @Incubating
     void clearMock(Object mock);
 
     /**
-     * Cleans up internal state for all existing mocks. You may assume there won't be any interaction to mocks created
-     * previously after this is called.
+     * Cleans up internal state for all existing mocks. Attempts to interact with mocks after this
+     * is called will throw {@link DisabledMockException}
      *
      * @since 2.25.0
      */
-    @Incubating
     void clearAllMocks();
-
 }
diff --git a/src/main/java/org/mockito/plugins/InstantiatorProvider2.java b/mockito-core/src/main/java/org/mockito/plugins/InstantiatorProvider2.java
similarity index 100%
rename from src/main/java/org/mockito/plugins/InstantiatorProvider2.java
rename to mockito-core/src/main/java/org/mockito/plugins/InstantiatorProvider2.java
diff --git a/mockito-core/src/main/java/org/mockito/plugins/MemberAccessor.java b/mockito-core/src/main/java/org/mockito/plugins/MemberAccessor.java
new file mode 100644
index 0000000000..6a39d6c93f
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/MemberAccessor.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * A member accessor is responsible for invoking methods, constructors and for setting
+ * and reading field values.
+ */
+public interface MemberAccessor {
+
+    Object newInstance(Constructor<?> constructor, Object... arguments)
+            throws InstantiationException, InvocationTargetException, IllegalAccessException;
+
+    default Object newInstance(
+            Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+            throws InstantiationException, InvocationTargetException, IllegalAccessException {
+        return onConstruction.invoke(() -> newInstance(constructor, arguments));
+    }
+
+    Object invoke(Method method, Object target, Object... arguments)
+            throws InvocationTargetException, IllegalAccessException;
+
+    Object get(Field field, Object target) throws IllegalAccessException;
+
+    void set(Field field, Object target, Object value) throws IllegalAccessException;
+
+    interface OnConstruction {
+
+        Object invoke(ConstructionDispatcher dispatcher)
+                throws InstantiationException, InvocationTargetException, IllegalAccessException;
+    }
+
+    interface ConstructionDispatcher {
+
+        Object newInstance()
+                throws InstantiationException, InvocationTargetException, IllegalAccessException;
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/plugins/MockMaker.java b/mockito-core/src/main/java/org/mockito/plugins/MockMaker.java
new file mode 100644
index 0000000000..106350aa85
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/MockMaker.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.MockSettings;
+import org.mockito.MockedConstruction;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+/**
+ * The facility to create mocks.
+ *
+ * <p>By default, an internal byte-buddy/asm/objenesis based implementation is used.</p>
+ *
+ * <p>{@code MockMaker} is an extension point that makes it possible to use custom dynamic proxies
+ * and avoid using the default byte-buddy/asm/objenesis implementation.
+ * For example, the android users can use a MockMaker that can work with Dalvik virtual machine
+ * and hence bring Mockito to android apps developers.</p>
+ *
+ * <h3>Using the extension point</h3>
+ *
+ * <p>Suppose you wrote an extension to create mocks with some <em>Awesome</em> library, in order to tell
+ * Mockito to use it you need to put in your <strong>classpath</strong>:
+ * <ol style="list-style-type: lower-alpha">
+ *     <li>
+ *         The implementation itself, for example <code>org.awesome.mockito.AwesomeMockMaker</code> that
+ *         extends the <code>MockMaker</code>.
+ *     </li>
+ *     <li>
+ *         A file "<code>mockito-extensions/org.mockito.plugins.MockMaker</code>". The content of this file is
+ *         exactly a <strong>one</strong> line with the qualified name:
+ *         <code>org.awesome.mockito.AwesomeMockMaker</code>.
+ *      </li>
+ * </ol>
+ * </p>
+ *
+ * <p>Note that if several <code>mockito-extensions/org.mockito.plugins.MockMaker</code> files exists in the classpath
+ * Mockito will only use the first returned by the standard {@link ClassLoader#getResource} mechanism.
+ *
+ * <h3>Using the MockSettings of individual mocks</h3>
+ *
+ * <p>If you want to use a {@code MockMaker} only for a specific mock,
+ * you can specify it using {@link MockSettings#mockMaker(String)}.</p>
+ * <pre>
+ *     // Use a built-in mock maker
+ *     Object mock = Mockito.mock(Object.class, Mockito.withSettings()
+ *             .mockMaker(MockMakers.INLINE));
+ *     // Or load a mock maker using a fully qualified class name
+ *     Object mock = Mockito.mock(Object.class, Mockito.withSettings()
+ *             .mockMaker("org.awesome.mockito.AwesomeMockMaker"));
+ * </pre>
+ *
+ * @see org.mockito.mock.MockCreationSettings
+ * @see org.mockito.invocation.MockHandler
+ * @since 1.9.5
+ */
+public interface MockMaker {
+
+    /**
+     * If you want to provide your own implementation of {@code MockMaker} this method should:
+     * <ul>
+     *     <li>Create a proxy object that implements {@code settings.typeToMock} and potentially also {@code settings.extraInterfaces}.</li>
+     *     <li>You may use the information from {@code settings} to create/configure your proxy object.</li>
+     *     <li>Your proxy object should carry the {@code handler} with it. For example, if you generate byte code
+     *     to create the proxy you could generate an extra field to keep the {@code handler} with the generated object.
+     *     Your implementation of {@code MockMaker} is required to provide this instance of {@code handler} when
+     *     {@link #getHandler(Object)} is called.
+     *     </li>
+     * </ul>
+     *
+     * @param settings Mock creation settings like type to mock, extra interfaces and so on.
+     * @param handler See {@link org.mockito.invocation.MockHandler}.
+     *                <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+     *                {@link #getHandler(Object)} will return this instance.
+     * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+     * @return The mock instance.
+     * @since 1.9.5
+     */
+    <T> T createMock(MockCreationSettings<T> settings, MockHandler handler);
+
+    /**
+     * By implementing this method, a mock maker can optionally support the creation of spies where all fields
+     * are set within a constructor. This avoids problems when creating spies of classes that declare
+     * effectively final instance fields where setting field values from outside the constructor is prohibited.
+     *
+     * @param settings Mock creation settings like type to mock, extra interfaces and so on.
+     * @param handler See {@link org.mockito.invocation.MockHandler}.
+     *                <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+     *                {@link #getHandler(Object)} will return this instance.
+     * @param instance  The object to spy upon.
+     * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+     * @return The spy instance, if this mock maker supports direct spy creation.
+     * @since 3.5.0
+     */
+    default <T> Optional<T> createSpy(
+            MockCreationSettings<T> settings, MockHandler handler, T instance) {
+        return Optional.empty();
+    }
+
+    /**
+     * Returns the handler for the {@code mock}. <b>Do not</b> provide your own implementations at this time
+     * because the work on the {@link MockHandler} api is not completed.
+     * Use the instance provided to you by Mockito at {@link #createMock} or {@link #resetMock}.
+     *
+     * @param mock The mock instance.
+     * @return The mock handler, but may return null - it means that there is no handler attached to provided object.
+     *   This means the passed object is not really a Mockito mock.
+     * @since 1.9.5
+     */
+    MockHandler getHandler(Object mock);
+
+    /**
+     * Replaces the existing handler on {@code mock} with {@code newHandler}.
+     *
+     * <p>The invocation handler actually store invocations to achieve
+     * stubbing and verification. In order to reset the mock, we pass
+     * a new instance of the invocation handler.</p>
+     *
+     * <p>Your implementation should make sure the {@code newHandler} is correctly associated to passed {@code mock}</p>
+     *
+     * @param mock The mock instance whose invocation handler is to be replaced.
+     * @param newHandler The new invocation handler instance.
+     * @param settings The mock settings - should you need to access some of the mock creation details.
+     * @since 1.9.5
+     */
+    void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings);
+
+    /**
+     * Indicates if the given type can be mocked by this mockmaker.
+     *
+     * <p>Mockmaker may have different capabilities in term of mocking, typically
+     * Mockito 1.x's internal mockmaker cannot mock final types. Other implementations, may
+     * have different limitations.</p>
+     *
+     * @param type The type inspected for mockability.
+     * @return object that carries the information about mockability of given type.
+     * @since 2.1.0
+     */
+    TypeMockability isTypeMockable(Class<?> type);
+
+    /**
+     * If you want to provide your own implementation of {@code MockMaker} this method should:
+     * <ul>
+     *     <li>Alter the supplied class to only change its behavior in the current thread.</li>
+     *     <li>Only alters the static method's behavior after being enabled.</li>
+     *     <li>Stops the altered behavior when disabled.</li>
+     * </ul>
+     *
+     * @param settings Mock creation settings like type to mock, extra interfaces and so on.
+     * @param handler See {@link org.mockito.invocation.MockHandler}.
+     *                <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+     *                {@link #getHandler(Object)} will return this instance.
+     * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+     * @return A control for the static mock.
+     * @since 3.4.0
+     */
+    default <T> StaticMockControl<T> createStaticMock(
+            Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+        throw new MockitoException(
+                join(
+                        "The used MockMaker "
+                                + getClass().getSimpleName()
+                                + " does not support the creation of static mocks",
+                        "",
+                        "Ensure your MockMaker implementation supports this feature.",
+                        "Note that static mocks maker is not supported on Android."));
+    }
+
+    /**
+     * If you want to provide your own implementation of {@code MockMaker} this method should:
+     * <ul>
+     *     <li>Intercept all constructions of the specified type in the current thread</li>
+     *     <li>Only intercept the construction after being enabled.</li>
+     *     <li>Stops the interception when disabled.</li>
+     * </ul>
+     *
+     * @param settingsFactory Factory for mock creation settings like type to mock, extra interfaces and so on.
+     * @param handlerFactory Factory for settings. See {@link org.mockito.invocation.MockHandler}.
+     *                <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+     *                {@link #getHandler(Object)} will return this instance.
+     * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+     * @return A control for the mocked construction.
+     * @since 3.5.0
+     */
+    default <T> ConstructionMockControl<T> createConstructionMock(
+            Class<T> type,
+            Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+            Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+            MockedConstruction.MockInitializer<T> mockInitializer) {
+        throw new MockitoException(
+                join(
+                        "The used MockMaker "
+                                + getClass().getSimpleName()
+                                + " does not support the creation of construction mocks",
+                        "",
+                        "Ensure your MockMaker implementation supports this feature.",
+                        "Note that construction mocks maker is not supported on Android."));
+    }
+
+    /**
+     * Clears all cashes for mocked types and removes all byte code alterations, if possible.
+     */
+    default void clearAllCaches() {}
+
+    /**
+     * Carries the mockability information
+     *
+     * @since 2.1.0
+     */
+    interface TypeMockability {
+        /**
+         * informs if type is mockable
+         */
+        boolean mockable();
+
+        /**
+         * informs why type is not mockable
+         */
+        String nonMockableReason();
+    }
+
+    interface StaticMockControl<T> {
+
+        Class<T> getType();
+
+        void enable();
+
+        void disable();
+    }
+
+    interface ConstructionMockControl<T> {
+
+        Class<T> getType();
+
+        void enable();
+
+        void disable();
+
+        List<T> getMocks();
+    }
+}
diff --git a/mockito-core/src/main/java/org/mockito/plugins/MockResolver.java b/mockito-core/src/main/java/org/mockito/plugins/MockResolver.java
new file mode 100644
index 0000000000..6eaa756f7e
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/MockResolver.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+/**
+ * A mock resolver offers an opportunity to resolve a mock from any instance that is
+ * provided to the {@link org.mockito.Mockito}-DSL. This mechanism can be used by
+ * frameworks that provide mocks that are implemented by Mockito but which are wrapped
+ * by other instances to enhance the proxy further.
+ */
+public interface MockResolver {
+
+    /**
+     * Returns the provided instance or the unwrapped mock that the provided
+     * instance represents. This method must not return {@code null}.
+     * @param instance The instance passed to the {@link org.mockito.Mockito}-DSL.
+     * @return The provided instance or the unwrapped mock.
+     */
+    Object resolve(Object instance);
+}
diff --git a/src/main/java/org/mockito/plugins/MockitoLogger.java b/mockito-core/src/main/java/org/mockito/plugins/MockitoLogger.java
similarity index 89%
rename from src/main/java/org/mockito/plugins/MockitoLogger.java
rename to mockito-core/src/main/java/org/mockito/plugins/MockitoLogger.java
index 38ca4a8a23..9c7b6aa3d6 100644
--- a/src/main/java/org/mockito/plugins/MockitoLogger.java
+++ b/mockito-core/src/main/java/org/mockito/plugins/MockitoLogger.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.plugins;
 
-import org.mockito.Incubating;
-
 /**
  * Mockito logger.
  *
@@ -35,13 +33,20 @@
  *
  * @since 2.23.19
  */
-@Incubating
 public interface MockitoLogger {
     /**
      * Log specified object.
      *
      * @param what to be logged
      */
-    @Incubating
     void log(Object what);
+
+    /**
+     * Log specified object as a warning, if supported.
+     *
+     * @param what to be logged.
+     */
+    default void warn(Object what) {
+        log(what);
+    }
 }
diff --git a/mockito-core/src/main/java/org/mockito/plugins/MockitoPlugins.java b/mockito-core/src/main/java/org/mockito/plugins/MockitoPlugins.java
new file mode 100644
index 0000000000..be7512ef7c
--- /dev/null
+++ b/mockito-core/src/main/java/org/mockito/plugins/MockitoPlugins.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.Mockito;
+import org.mockito.MockitoFramework;
+import org.mockito.NotExtensible;
+
+/**
+ * Instance of this interface is available via {@link MockitoFramework#getPlugins()}.
+ * This object enables framework integrators to get access to default Mockito plugins.
+ * <p>
+ * Example use case: one needs to implement custom {@link MockMaker}
+ * and delegate some behavior to the default Mockito implementation.
+ * The interface was introduced to help framework integrations.
+ *
+ * @since 2.10.0
+ */
+@NotExtensible
+public interface MockitoPlugins {
+
+    /**
+     * Returns the default plugin implementation used by Mockito.
+     * Mockito plugins are stateless so it is recommended to keep hold of the returned plugin implementation
+     * rather than calling this method multiple times.
+     * Each time this method is called, new instance of the plugin is created.
+     *
+     * @param pluginType type of the plugin, for example {@link MockMaker}.
+     * @return the plugin instance
+     * @since 2.10.0
+     */
+    <T> T getDefaultPlugin(Class<T> pluginType);
+
+    /**
+     * Returns inline mock maker, an optional mock maker that is bundled with Mockito distribution.
+     * This method is needed because {@link #getDefaultPlugin(Class)} does not provide an instance of inline mock maker.
+     * Creates new instance each time is called so it is recommended to keep hold of the resulting object for future invocations.
+     * For more information about inline mock maker see the javadoc for main {@link Mockito} class.
+     *
+     * @return instance of inline mock maker
+     * @since 2.10.0
+     * @deprecated Please use {@link #getMockMaker(String)} with {@link org.mockito.MockMakers#INLINE} instead.
+     */
+    @Deprecated(since = "5.6.0", forRemoval = true)
+    MockMaker getInlineMockMaker();
+
+    /**
+     * Returns {@link MockMaker} instance used by Mockito with the passed name {@code mockMaker}.
+     *
+     * <p>This will return the instance used by Mockito itself, not a new instance of it.
+     *
+     * <p>This method can be used to increase the interop of mocks created by Mockito and other
+     * libraries using Mockito mock maker API.
+     *
+     * @param mockMaker the name of the mock maker or {@code null} to retrieve the default mock maker
+     * @return instance of the mock maker
+     * @throws IllegalStateException if a mock maker with the name is not found
+     * @since 5.6.0
+     */
+    default MockMaker getMockMaker(String mockMaker) {
+        throw new UnsupportedOperationException("This method is not implemented.");
+    }
+}
diff --git a/src/main/java/org/mockito/plugins/PluginSwitch.java b/mockito-core/src/main/java/org/mockito/plugins/PluginSwitch.java
similarity index 98%
rename from src/main/java/org/mockito/plugins/PluginSwitch.java
rename to mockito-core/src/main/java/org/mockito/plugins/PluginSwitch.java
index 916db246c9..a5db3473f7 100644
--- a/src/main/java/org/mockito/plugins/PluginSwitch.java
+++ b/mockito-core/src/main/java/org/mockito/plugins/PluginSwitch.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.plugins;
 
-import org.mockito.Incubating;
-
 /**
  * Allows switching off the plugins that are discovered on classpath.
  *
@@ -42,7 +40,6 @@
  *
  * @since 1.10.15
  */
-@Incubating
 public interface PluginSwitch {
 
     /**
diff --git a/src/main/java/org/mockito/plugins/StackTraceCleanerProvider.java b/mockito-core/src/main/java/org/mockito/plugins/StackTraceCleanerProvider.java
similarity index 100%
rename from src/main/java/org/mockito/plugins/StackTraceCleanerProvider.java
rename to mockito-core/src/main/java/org/mockito/plugins/StackTraceCleanerProvider.java
diff --git a/src/main/java/org/mockito/plugins/package-info.java b/mockito-core/src/main/java/org/mockito/plugins/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/plugins/package-info.java
rename to mockito-core/src/main/java/org/mockito/plugins/package-info.java
diff --git a/src/main/java/org/mockito/quality/MockitoHint.java b/mockito-core/src/main/java/org/mockito/quality/MockitoHint.java
similarity index 99%
rename from src/main/java/org/mockito/quality/MockitoHint.java
rename to mockito-core/src/main/java/org/mockito/quality/MockitoHint.java
index f261ac1630..cf36a6cc81 100644
--- a/src/main/java/org/mockito/quality/MockitoHint.java
+++ b/mockito-core/src/main/java/org/mockito/quality/MockitoHint.java
@@ -75,5 +75,4 @@
  *
  * @since 2.1.0
  */
-public interface MockitoHint {
-}
+public interface MockitoHint {}
diff --git a/src/main/java/org/mockito/quality/Strictness.java b/mockito-core/src/main/java/org/mockito/quality/Strictness.java
similarity index 96%
rename from src/main/java/org/mockito/quality/Strictness.java
rename to mockito-core/src/main/java/org/mockito/quality/Strictness.java
index 20ce8cb33d..76cd552b38 100644
--- a/src/main/java/org/mockito/quality/Strictness.java
+++ b/mockito-core/src/main/java/org/mockito/quality/Strictness.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.quality;
 
-import org.mockito.Incubating;
 import org.mockito.MockitoSession;
 import org.mockito.exceptions.misusing.PotentialStubbingProblem;
 import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
@@ -38,7 +37,6 @@
  *
  * @since 2.3.0
  */
-@Incubating
 public enum Strictness {
 
     /**
@@ -49,7 +47,6 @@ public enum Strictness {
      *
      * @since 2.3.0
      */
-    @Incubating
     LENIENT,
 
     /**
@@ -62,14 +59,12 @@ public enum Strictness {
      *
      * @since 2.3.0
      */
-    @Incubating
     WARN,
 
     /**
      * Ensures clean tests, reduces test code duplication, improves debuggability.
      * Offers best combination of flexibility and productivity.
      * Highly recommended.
-     * Planned as default for Mockito v4.
      * Enable it via our JUnit support ({@link MockitoJUnit}) or {@link MockitoSession}.
      * <p>
      * Adds following behavior:
@@ -88,6 +83,5 @@ public enum Strictness {
      *
      * @since 2.3.0
      */
-    @Incubating
     STRICT_STUBS;
 }
diff --git a/src/main/java/org/mockito/quality/package-info.java b/mockito-core/src/main/java/org/mockito/quality/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/quality/package-info.java
rename to mockito-core/src/main/java/org/mockito/quality/package-info.java
diff --git a/src/main/java/org/mockito/session/MockitoSessionBuilder.java b/mockito-core/src/main/java/org/mockito/session/MockitoSessionBuilder.java
similarity index 96%
rename from src/main/java/org/mockito/session/MockitoSessionBuilder.java
rename to mockito-core/src/main/java/org/mockito/session/MockitoSessionBuilder.java
index b17cfe77d6..6a84205670 100644
--- a/src/main/java/org/mockito/session/MockitoSessionBuilder.java
+++ b/mockito-core/src/main/java/org/mockito/session/MockitoSessionBuilder.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.session;
 
-import org.mockito.Incubating;
 import org.mockito.MockitoAnnotations;
 import org.mockito.MockitoSession;
 import org.mockito.NotExtensible;
@@ -17,7 +16,6 @@
  *
  * @since 2.7.0
  */
-@Incubating
 @NotExtensible
 public interface MockitoSessionBuilder {
 
@@ -26,10 +24,10 @@ public interface MockitoSessionBuilder {
      * like {@link org.mockito.Mock}.
      * When this method is invoked it <strong>does not perform</strong> initialization of mocks on the spot!
      * Only when {@link #startMocking()} is invoked then annotated fields will be initialized.
-     * Traditional API to initialize mocks, the {@link MockitoAnnotations#initMocks(Object)} method
+     * Traditional API to initialize mocks, the {@link MockitoAnnotations#openMocks(Object)} method
      * has limited support for driving cleaner tests because it does not support configuring {@link Strictness}.
      * Want cleaner tests and better productivity?
-     * Migrate from {@link MockitoAnnotations#initMocks(Object)}
+     * Migrate from {@link MockitoAnnotations#openMocks(Object)}
      * to {@link MockitoSession}!
      * <p>
      * This method may be called multiple times to add multiple, e.g. nested, test class instances.
@@ -41,7 +39,6 @@ public interface MockitoSessionBuilder {
      * @return the same builder instance for fluent configuration of {@code MockitoSession}.
      * @since 2.7.0
      */
-    @Incubating
     MockitoSessionBuilder initMocks(Object testClassInstance);
 
     /**
@@ -59,7 +56,6 @@ public interface MockitoSessionBuilder {
      * @see #initMocks(Object)
      * @since 2.15.0
      */
-    @Incubating
     MockitoSessionBuilder initMocks(Object... testClassInstances);
 
     /**
@@ -81,7 +77,6 @@ public interface MockitoSessionBuilder {
      * @see org.mockito.quality.MockitoHint
      * @since 2.15.0
      */
-    @Incubating
     MockitoSessionBuilder name(String name);
 
     /**
@@ -95,7 +90,6 @@ public interface MockitoSessionBuilder {
      * @return the same builder instance for fluent configuration of {@code MockitoSession}.
      * @since 2.7.0
      */
-    @Incubating
     MockitoSessionBuilder strictness(Strictness strictness);
 
     /**
@@ -114,7 +108,6 @@ public interface MockitoSessionBuilder {
      * @see org.mockito.quality.MockitoHint
      * @since 2.15.0
      */
-    @Incubating
     MockitoSessionBuilder logger(MockitoSessionLogger logger);
 
     /**
@@ -136,6 +129,5 @@ public interface MockitoSessionBuilder {
      * @throws UnfinishedMockingSessionException
      *  when previous session was not concluded with {@link MockitoSession#finishMocking()}
      */
-    @Incubating
     MockitoSession startMocking() throws UnfinishedMockingSessionException;
 }
diff --git a/src/main/java/org/mockito/session/MockitoSessionLogger.java b/mockito-core/src/main/java/org/mockito/session/MockitoSessionLogger.java
similarity index 92%
rename from src/main/java/org/mockito/session/MockitoSessionLogger.java
rename to mockito-core/src/main/java/org/mockito/session/MockitoSessionLogger.java
index f876433c57..7d2e1350cd 100644
--- a/src/main/java/org/mockito/session/MockitoSessionLogger.java
+++ b/mockito-core/src/main/java/org/mockito/session/MockitoSessionLogger.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.session;
 
-import org.mockito.Incubating;
 import org.mockito.MockitoSession;
 import org.mockito.NotExtensible;
 
@@ -17,7 +16,6 @@
  *
  * @since 2.15.0
  */
-@Incubating
 @NotExtensible
 public interface MockitoSessionLogger {
 
@@ -26,7 +24,5 @@ public interface MockitoSessionLogger {
      *
      * @param hint to log; never {@code null}
      */
-    @Incubating
     void log(String hint);
-
 }
diff --git a/src/main/java/org/mockito/stubbing/Answer.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer.java
similarity index 100%
rename from src/main/java/org/mockito/stubbing/Answer.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer.java
diff --git a/src/main/java/org/mockito/stubbing/Answer1.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer1.java
similarity index 96%
rename from src/main/java/org/mockito/stubbing/Answer1.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer1.java
index afc2a5e424..e370dca419 100644
--- a/src/main/java/org/mockito/stubbing/Answer1.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Answer1.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a single argument invocation.
  *
@@ -31,7 +29,6 @@
  * @param <A0> type of the single argument
  * @see Answer
  */
-@Incubating
 public interface Answer1<T, A0> {
     /**
      * @param argument0 the single argument.
diff --git a/src/main/java/org/mockito/stubbing/Answer2.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer2.java
similarity index 96%
rename from src/main/java/org/mockito/stubbing/Answer2.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer2.java
index 77944b7366..71b5a03d03 100644
--- a/src/main/java/org/mockito/stubbing/Answer2.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Answer2.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a two argument invocation.
  *
@@ -32,7 +30,6 @@
  * @param <A1> type of the second argument
  * @see Answer
  */
-@Incubating
 public interface Answer2<T, A0, A1> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/Answer3.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer3.java
similarity index 97%
rename from src/main/java/org/mockito/stubbing/Answer3.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer3.java
index e80f06eadc..1aa4abfb03 100644
--- a/src/main/java/org/mockito/stubbing/Answer3.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Answer3.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a three argument invocation.
  *
@@ -33,7 +31,6 @@
  * @param <A2> type of the third argument
  * @see Answer
  */
-@Incubating
 public interface Answer3<T, A0, A1, A2> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/Answer4.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer4.java
similarity index 97%
rename from src/main/java/org/mockito/stubbing/Answer4.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer4.java
index f89a2019f9..bfc6c3185e 100644
--- a/src/main/java/org/mockito/stubbing/Answer4.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Answer4.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a four argument invocation.
  *
@@ -34,7 +32,6 @@
  * @param <A3> type of the fourth argument
  * @see Answer
  */
-@Incubating
 public interface Answer4<T, A0, A1, A2, A3> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/Answer5.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer5.java
similarity index 97%
rename from src/main/java/org/mockito/stubbing/Answer5.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer5.java
index 3e83968b4c..d5e12e10f4 100644
--- a/src/main/java/org/mockito/stubbing/Answer5.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Answer5.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a five argument invocation.
  *
@@ -34,7 +32,6 @@
  * @param <A3> type of the fourth argument
  * @see Answer
  */
-@Incubating
 public interface Answer5<T, A0, A1, A2, A3, A4> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/Answer6.java b/mockito-core/src/main/java/org/mockito/stubbing/Answer6.java
similarity index 92%
rename from src/main/java/org/mockito/stubbing/Answer6.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Answer6.java
index bf668cf862..b3248db449 100644
--- a/src/main/java/org/mockito/stubbing/Answer6.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Answer6.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a six argument invocation.
  *
@@ -36,7 +34,6 @@
  * @param <A5> type of the sixth argument
  * @see Answer
  */
-@Incubating
 public interface Answer6<T, A0, A1, A2, A3, A4, A5> {
     /**
      * @param argument0 the first argument.
@@ -50,5 +47,6 @@ public interface Answer6<T, A0, A1, A2, A3, A4, A5> {
      *
      * @throws Throwable the throwable to be thrown
      */
-    T answer( A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4, A5 argument5 ) throws Throwable;
+    T answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4, A5 argument5)
+            throws Throwable;
 }
diff --git a/src/main/java/org/mockito/stubbing/BaseStubber.java b/mockito-core/src/main/java/org/mockito/stubbing/BaseStubber.java
similarity index 95%
rename from src/main/java/org/mockito/stubbing/BaseStubber.java
rename to mockito-core/src/main/java/org/mockito/stubbing/BaseStubber.java
index 8c3192815e..7ac714da65 100644
--- a/src/main/java/org/mockito/stubbing/BaseStubber.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/BaseStubber.java
@@ -61,9 +61,11 @@ public interface BaseStubber {
      *
      * @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);
+    // 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:
diff --git a/src/main/java/org/mockito/stubbing/LenientStubber.java b/mockito-core/src/main/java/org/mockito/stubbing/LenientStubber.java
similarity index 100%
rename from src/main/java/org/mockito/stubbing/LenientStubber.java
rename to mockito-core/src/main/java/org/mockito/stubbing/LenientStubber.java
diff --git a/src/main/java/org/mockito/stubbing/OngoingStubbing.java b/mockito-core/src/main/java/org/mockito/stubbing/OngoingStubbing.java
similarity index 94%
rename from src/main/java/org/mockito/stubbing/OngoingStubbing.java
rename to mockito-core/src/main/java/org/mockito/stubbing/OngoingStubbing.java
index 4d370abba3..16c5f39098 100644
--- a/src/main/java/org/mockito/stubbing/OngoingStubbing.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/OngoingStubbing.java
@@ -64,8 +64,9 @@ public interface OngoingStubbing<T> {
      *
      * @return object that allows stubbing consecutive calls
      */
-    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation warnings (on call site)
-    @SuppressWarnings ({"unchecked", "varargs"})
+    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+    // creation warnings (on call site)
+    @SuppressWarnings({"unchecked", "varargs"})
     OngoingStubbing<T> thenReturn(T value, T... values);
 
     /**
@@ -146,9 +147,11 @@ public interface OngoingStubbing<T> {
      * @return object that allows stubbing consecutive calls
      * @since 2.1.0
      */
-    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation warnings (on call site)
-    @SuppressWarnings ({"unchecked", "varargs"})
-    OngoingStubbing<T> thenThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
+    // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+    // creation warnings (on call site)
+    @SuppressWarnings({"unchecked", "varargs"})
+    OngoingStubbing<T> thenThrow(
+            Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
 
     /**
      * Sets the real implementation to be called when the method is called on a mock object.
@@ -161,7 +164,7 @@ public interface OngoingStubbing<T> {
      * <p>
      * However, there are rare cases when partial mocks come handy:
      * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
-     * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
+     * However, I wouldn't use partial mocks for new, test-driven and well-designed code.
      * <pre class="code"><code class="java">
      *   // someMethod() must be safe (e.g. doesn't throw, doesn't have dependencies to the object state, etc.)
      *   // if it isn't safe then you will have trouble stubbing it using this api. Use Mockito.doCallRealMethod() instead.
@@ -223,7 +226,7 @@ public interface OngoingStubbing<T> {
      * <p>
      * It allows to create a stub in one line of code.
      * This can be helpful to keep test code clean.
-     * For example, some boring stub can be created & stubbed at field initialization in a test:
+     * For example, some boring stub can be created and stubbed at field initialization in a test:
      * <pre class="code"><code class="java">
      * public class CarTest {
      *   Car boringStubbedCar = when(mock(Car.class).shiftGear()).thenThrow(EngineNotStarted.class).getMock();
@@ -236,5 +239,4 @@ public interface OngoingStubbing<T> {
      * @since 1.9.0
      */
     <M> M getMock();
-
 }
diff --git a/src/main/java/org/mockito/stubbing/Stubber.java b/mockito-core/src/main/java/org/mockito/stubbing/Stubber.java
similarity index 97%
rename from src/main/java/org/mockito/stubbing/Stubber.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Stubber.java
index 5de954bf78..6b860dba10 100644
--- a/src/main/java/org/mockito/stubbing/Stubber.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Stubber.java
@@ -4,6 +4,7 @@
  */
 package org.mockito.stubbing;
 
+import org.mockito.CheckReturnValue;
 import org.mockito.Mockito;
 import org.mockito.NotExtensible;
 
@@ -39,6 +40,7 @@
  *
  * See examples in javadoc for {@link Mockito}
  */
+@CheckReturnValue
 @SuppressWarnings("unchecked")
 @NotExtensible
 public interface Stubber extends BaseStubber {
diff --git a/src/main/java/org/mockito/stubbing/Stubbing.java b/mockito-core/src/main/java/org/mockito/stubbing/Stubbing.java
similarity index 98%
rename from src/main/java/org/mockito/stubbing/Stubbing.java
rename to mockito-core/src/main/java/org/mockito/stubbing/Stubbing.java
index cba0917f97..48b5ee4dad 100644
--- a/src/main/java/org/mockito/stubbing/Stubbing.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/Stubbing.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
 import org.mockito.MockingDetails;
 import org.mockito.Mockito;
 import org.mockito.NotExtensible;
@@ -60,6 +59,5 @@ public interface Stubbing extends Answer {
      *
      * @since 2.20.0
      */
-    @Incubating
     Strictness getStrictness();
 }
diff --git a/src/main/java/org/mockito/stubbing/ValidableAnswer.java b/mockito-core/src/main/java/org/mockito/stubbing/ValidableAnswer.java
similarity index 91%
rename from src/main/java/org/mockito/stubbing/ValidableAnswer.java
rename to mockito-core/src/main/java/org/mockito/stubbing/ValidableAnswer.java
index 64c5e4189a..a5dacaa46c 100644
--- a/src/main/java/org/mockito/stubbing/ValidableAnswer.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/ValidableAnswer.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
 import org.mockito.invocation.InvocationOnMock;
 
 /**
@@ -39,7 +38,7 @@
  *
  * <pre class="code"><code class="java">
  * when(mock.someMethod(anyString(), anyInt())).then(doSomethingTricky()); // fail at answer execution time
- * when(mock.incompatibleMethod(anyVararg())).then(doSomethingTricky()); // fail at answer execution time
+ * when(mock.incompatibleMethod(any())).then(doSomethingTricky()); // fail at answer execution time
  * </code></pre>
  * </p>
  *
@@ -48,7 +47,7 @@
  * validable at <em>stub time</em> by implementing this contract.
  *
  * <pre class="code"><code class="java">
- * when(mock.incompatibleMethod(anyVararg())).then(doSomethingTricky()); // fail at answer stub time
+ * when(mock.incompatibleMethod(any())).then(doSomethingTricky()); // fail at answer stub time
  *
  * static Answer doSomethingTricky() {
  *     return new TrickyAnswer();
@@ -68,7 +67,6 @@
  *
  * @since 2.3.8
  */
-@Incubating
 public interface ValidableAnswer {
 
     /**
@@ -88,5 +86,4 @@ public interface ValidableAnswer {
      * @since 2.3.8
      */
     void validateFor(InvocationOnMock invocation);
-
 }
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer1.java b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer1.java
similarity index 96%
rename from src/main/java/org/mockito/stubbing/VoidAnswer1.java
rename to mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer1.java
index 9f75bf5b9e..df563a92f5 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer1.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer1.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a single argument invocation that returns nothing.
  *
@@ -30,7 +28,6 @@
  * @param <A0> type of the single argument
  * @see Answer
  */
-@Incubating
 public interface VoidAnswer1<A0> {
     /**
      * @param argument0 the single argument.
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer2.java b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer2.java
similarity index 96%
rename from src/main/java/org/mockito/stubbing/VoidAnswer2.java
rename to mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer2.java
index 8d062f163d..a9b6ef47ab 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer2.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer2.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a two argument invocation that returns nothing.
  *
@@ -31,7 +29,6 @@
  * @param <A1> type of the second argument
  * @see Answer
  */
-@Incubating
 public interface VoidAnswer2<A0, A1> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer3.java b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer3.java
similarity index 97%
rename from src/main/java/org/mockito/stubbing/VoidAnswer3.java
rename to mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer3.java
index b56498297b..a2c6a072a0 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer3.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer3.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a three argument invocation that returns nothing.
  *
@@ -32,7 +30,6 @@
  * @param <A2> type of the third argument
  * @see Answer
  */
-@Incubating
 public interface VoidAnswer3<A0, A1, A2> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer4.java b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer4.java
similarity index 97%
rename from src/main/java/org/mockito/stubbing/VoidAnswer4.java
rename to mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer4.java
index c34abee33b..650bce39f3 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer4.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer4.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a four argument invocation that returns nothing.
  *
@@ -23,7 +21,7 @@
  *         }
  * })).when(mock).someMethod(anyString(), anyInt(), anyString(), anyChar());
  *
- * //Following will raise an exception with the message "ka-boom <3"
+ * //Following will raise an exception with the message "ka-boom &lt;3"
  * mock.someMethod("%s-boom %c%d", 3, "ka", '&lt;');
  * </code></pre>
  *
@@ -33,7 +31,6 @@
  * @param <A3> type of the fourth argument
  * @see Answer
  */
-@Incubating
 public interface VoidAnswer4<A0, A1, A2, A3> {
     /**
      * @param argument0 the first argument.
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer5.java b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer5.java
similarity index 94%
rename from src/main/java/org/mockito/stubbing/VoidAnswer5.java
rename to mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer5.java
index 1ac667c837..4b4c34b46c 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer5.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer5.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a five argument invocation that returns nothing.
  *
@@ -23,7 +21,7 @@
  *         }
  * })).when(mock).someMethod(anyString(), anyInt(), anyString(), anyChar(), anyString());
  *
- * //Following will raise an exception with the message "ka-boom <3 mockito"
+ * //Following will raise an exception with the message "ka-boom &lt;3 mockito"
  * mock.someMethod("%s-boom %c%d %s", 3, "ka", '&lt;', "mockito");
  * </code></pre>
  *
@@ -34,7 +32,6 @@
  * @param <A4> type of the fifth argument
  * @see Answer
  */
-@Incubating
 public interface VoidAnswer5<A0, A1, A2, A3, A4> {
     /**
      * @param argument0 the first argument.
@@ -45,5 +42,6 @@ public interface VoidAnswer5<A0, A1, A2, A3, A4> {
      *
      * @throws Throwable the throwable to be thrown
      */
-    void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4) throws Throwable;
+    void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4)
+            throws Throwable;
 }
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer6.java b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer6.java
similarity index 94%
rename from src/main/java/org/mockito/stubbing/VoidAnswer6.java
rename to mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer6.java
index 5df66a355f..bf4dc94166 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer6.java
+++ b/mockito-core/src/main/java/org/mockito/stubbing/VoidAnswer6.java
@@ -4,8 +4,6 @@
  */
 package org.mockito.stubbing;
 
-import org.mockito.Incubating;
-
 /**
  * Generic interface to be used for configuring mock's answer for a six argument invocation that returns nothing.
  *
@@ -23,7 +21,7 @@
  *         }
  * })).when(mock).someMethod(anyString(), anyInt(), anyString(), anyChar(), any(), anyString());
  *
- * // The following will raise an exception with the message "ka-boom <3 mockito"
+ * // The following will raise an exception with the message "ka-boom &lt;3 mockito"
  * mock.someMethod("%s-boom %c%d %s", 3, "ka", '&lt;', new Object(), "mockito");
  * </code></pre>
  *
@@ -35,7 +33,6 @@
  * @param <A5> type of the sixth argument
  * @see Answer
  */
-@Incubating
 public interface VoidAnswer6<A0, A1, A2, A3, A4, A5> {
     /**
      * @param argument0 the first argument.
@@ -47,5 +44,6 @@ public interface VoidAnswer6<A0, A1, A2, A3, A4, A5> {
      *
      * @throws Throwable the throwable to be thrown
      */
-    void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4, A5 argument5) throws Throwable;
+    void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4, A5 argument5)
+            throws Throwable;
 }
diff --git a/src/main/java/org/mockito/stubbing/package-info.java b/mockito-core/src/main/java/org/mockito/stubbing/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/stubbing/package-info.java
rename to mockito-core/src/main/java/org/mockito/stubbing/package-info.java
diff --git a/src/main/java/org/mockito/verification/After.java b/mockito-core/src/main/java/org/mockito/verification/After.java
similarity index 82%
rename from src/main/java/org/mockito/verification/After.java
rename to mockito-core/src/main/java/org/mockito/verification/After.java
index 54d7453022..ed87333925 100644
--- a/src/main/java/org/mockito/verification/After.java
+++ b/mockito-core/src/main/java/org/mockito/verification/After.java
@@ -13,7 +13,8 @@
  * Typically, you won't use this class explicitly. Instead use timeout() method on Mockito class.
  * See javadoc for {@link VerificationWithTimeout}
  */
-public class After extends VerificationWrapper<VerificationOverTimeImpl> implements VerificationAfterDelay {
+public class After extends VerificationWrapper<VerificationOverTimeImpl>
+        implements VerificationAfterDelay {
 
     /**
      * See the javadoc for {@link VerificationAfterDelay}
@@ -37,4 +38,13 @@ public After(long delayMillis, VerificationMode verificationMode) {
     protected VerificationMode copySelfWithNewVerificationMode(VerificationMode verificationMode) {
         return new After(wrappedVerification.copyWithVerificationMode(verificationMode));
     }
+
+    @Override
+    public String toString() {
+        return "Wanted after "
+                + wrappedVerification.getTimer().duration()
+                + " ms: ["
+                + wrappedVerification.getDelegate()
+                + "]";
+    }
 }
diff --git a/src/main/java/org/mockito/verification/Timeout.java b/mockito-core/src/main/java/org/mockito/verification/Timeout.java
similarity index 81%
rename from src/main/java/org/mockito/verification/Timeout.java
rename to mockito-core/src/main/java/org/mockito/verification/Timeout.java
index 99dcc45f53..405a4356d8 100644
--- a/src/main/java/org/mockito/verification/Timeout.java
+++ b/mockito-core/src/main/java/org/mockito/verification/Timeout.java
@@ -16,7 +16,8 @@
  * Typically, you won't use this class explicitly. Instead use timeout() method on Mockito class.
  * See javadoc for {@link VerificationWithTimeout}
  */
-public class Timeout extends VerificationWrapper<VerificationOverTimeImpl> implements VerificationWithTimeout {
+public class Timeout extends VerificationWrapper<VerificationOverTimeImpl>
+        implements VerificationWithTimeout {
 
     /**
      * See the javadoc for {@link VerificationWithTimeout}
@@ -47,16 +48,27 @@ public Timeout(long millis, VerificationMode delegate) {
     }
 
     @Override
-    protected VerificationMode copySelfWithNewVerificationMode(VerificationMode newVerificationMode) {
+    protected VerificationMode copySelfWithNewVerificationMode(
+            VerificationMode newVerificationMode) {
         return new Timeout(wrappedVerification.copyWithVerificationMode(newVerificationMode));
     }
 
+    @Override
     public VerificationMode atMost(int maxNumberOfInvocations) {
         throw atMostAndNeverShouldNotBeUsedWithTimeout();
     }
 
+    @Override
     public VerificationMode never() {
         throw atMostAndNeverShouldNotBeUsedWithTimeout();
     }
 
+    @Override
+    public String toString() {
+        return "Wanted after at most "
+                + wrappedVerification.getTimer().duration()
+                + " ms: ["
+                + wrappedVerification.getDelegate()
+                + "]";
+    }
 }
diff --git a/src/main/java/org/mockito/verification/VerificationAfterDelay.java b/mockito-core/src/main/java/org/mockito/verification/VerificationAfterDelay.java
similarity index 99%
rename from src/main/java/org/mockito/verification/VerificationAfterDelay.java
rename to mockito-core/src/main/java/org/mockito/verification/VerificationAfterDelay.java
index 96b56f1f73..c99a34d2ee 100644
--- a/src/main/java/org/mockito/verification/VerificationAfterDelay.java
+++ b/mockito-core/src/main/java/org/mockito/verification/VerificationAfterDelay.java
@@ -6,7 +6,6 @@
 
 import org.mockito.Mockito;
 
-
 /**
  * VerificationAfterDelay is a {@link VerificationMode} that allows combining existing verification modes with an initial delay, e.g.
  * <pre class="code"><code class="java">
@@ -65,5 +64,4 @@ public interface VerificationAfterDelay extends VerificationMode {
      * period given, unless another method is invoked (in which case there will be an immediate failure)
      */
     VerificationMode only();
-
 }
diff --git a/src/main/java/org/mockito/verification/VerificationEvent.java b/mockito-core/src/main/java/org/mockito/verification/VerificationEvent.java
similarity index 95%
rename from src/main/java/org/mockito/verification/VerificationEvent.java
rename to mockito-core/src/main/java/org/mockito/verification/VerificationEvent.java
index fad511b6ff..0469bd2fa7 100644
--- a/src/main/java/org/mockito/verification/VerificationEvent.java
+++ b/mockito-core/src/main/java/org/mockito/verification/VerificationEvent.java
@@ -4,13 +4,11 @@
  */
 package org.mockito.verification;
 
-import org.mockito.Incubating;
 import org.mockito.internal.verification.api.VerificationData;
 
 /**
  * Contains all information about a verification that has happened.
  */
-@Incubating
 public interface VerificationEvent {
     /**
      * @return The mock that a verification happened on.
diff --git a/src/main/java/org/mockito/verification/VerificationMode.java b/mockito-core/src/main/java/org/mockito/verification/VerificationMode.java
similarity index 100%
rename from src/main/java/org/mockito/verification/VerificationMode.java
rename to mockito-core/src/main/java/org/mockito/verification/VerificationMode.java
diff --git a/src/main/java/org/mockito/verification/VerificationStrategy.java b/mockito-core/src/main/java/org/mockito/verification/VerificationStrategy.java
similarity index 100%
rename from src/main/java/org/mockito/verification/VerificationStrategy.java
rename to mockito-core/src/main/java/org/mockito/verification/VerificationStrategy.java
diff --git a/src/main/java/org/mockito/verification/VerificationWithTimeout.java b/mockito-core/src/main/java/org/mockito/verification/VerificationWithTimeout.java
similarity index 98%
rename from src/main/java/org/mockito/verification/VerificationWithTimeout.java
rename to mockito-core/src/main/java/org/mockito/verification/VerificationWithTimeout.java
index ad110d0cce..3e70d116bb 100644
--- a/src/main/java/org/mockito/verification/VerificationWithTimeout.java
+++ b/mockito-core/src/main/java/org/mockito/verification/VerificationWithTimeout.java
@@ -12,8 +12,6 @@
  * <pre class="code"><code class="java">
  * verify(mock, timeout(100).times(5)).foo();
  *
- * verify(mock, timeout(100).never()).bar();
- *
  * verify(mock, timeout(200).atLeastOnce()).baz();
  * </code></pre>
  *
diff --git a/src/main/java/org/mockito/verification/package-info.java b/mockito-core/src/main/java/org/mockito/verification/package-info.java
similarity index 100%
rename from src/main/java/org/mockito/verification/package-info.java
rename to mockito-core/src/main/java/org/mockito/verification/package-info.java
diff --git a/mockito-core/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java b/mockito-core/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java
new file mode 100644
index 0000000000..4e2d8b940a
--- /dev/null
+++ b/mockito-core/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.concurrentmockito;
+
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+// this test exposes the problem most of the time
+public class ThreadVerifiesContinuouslyInteractingMockTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    @Test
+    public void shouldAllowVerifyingInThreads() throws Exception {
+        for (int i = 0; i < 100; i++) {
+            performTest();
+        }
+    }
+
+    private void performTest() throws InterruptedException {
+        mock.simpleMethod();
+        final Thread[] listeners = new Thread[2];
+        for (int i = 0; i < listeners.length; i++) {
+            final int x = i;
+            listeners[i] =
+                    new Thread() {
+                        @Override
+                        public void run() {
+                            try {
+                                Thread.sleep(x * 10);
+                            } catch (InterruptedException e) {
+                                throw new RuntimeException(e);
+                            }
+                            mock.simpleMethod();
+                        }
+                    };
+            listeners[i].start();
+        }
+
+        verify(mock, atLeastOnce()).simpleMethod();
+
+        for (Thread listener : listeners) {
+            listener.join();
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java b/mockito-core/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
new file mode 100644
index 0000000000..a56330cee5
--- /dev/null
+++ b/mockito-core/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.concurrentmockito;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.mockito.MockitoTest;
+import org.mockito.exceptions.base.MockitoAssertionErrorTest;
+import org.mockito.exceptions.base.MockitoExceptionTest;
+import org.mockito.internal.AllInvocationsFinderTest;
+import org.mockito.internal.InvalidStateDetectionTest;
+import org.mockito.internal.creation.bytebuddy.TypeCachingMockBytecodeGeneratorTest;
+import org.mockito.internal.exceptions.ReporterTest;
+import org.mockito.internal.handler.MockHandlerImplTest;
+import org.mockito.internal.invocation.InvocationMatcherTest;
+import org.mockito.internal.invocation.InvocationsFinderTest;
+import org.mockito.internal.matchers.ComparableMatchersTest;
+import org.mockito.internal.matchers.EqualsTest;
+import org.mockito.internal.matchers.MatchersToStringTest;
+import org.mockito.internal.progress.MockingProgressImplTest;
+import org.mockito.internal.progress.TimesTest;
+import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValuesTest;
+import org.mockito.internal.stubbing.defaultanswers.ReturnsGenericDeepStubsTest;
+import org.mockito.internal.util.MockUtilTest;
+import org.mockito.internal.verification.DefaultRegisteredInvocationsTest;
+import org.mockito.internal.verification.checkers.MissingInvocationCheckerTest;
+import org.mockito.internal.verification.checkers.MissingInvocationInOrderCheckerTest;
+import org.mockito.internal.verification.checkers.NumberOfInvocationsCheckerTest;
+import org.mockito.internal.verification.checkers.NumberOfInvocationsInOrderCheckerTest;
+import org.mockitousage.basicapi.ReplacingObjectMethodsTest;
+import org.mockitousage.basicapi.ResetTest;
+import org.mockitousage.basicapi.UsingVarargsTest;
+import org.mockitousage.examples.use.ExampleTest;
+import org.mockitousage.matchers.CustomMatchersTest;
+import org.mockitousage.matchers.InvalidUseOfMatchersTest;
+import org.mockitousage.matchers.MatchersTest;
+import org.mockitousage.matchers.VerificationAndStubbingUsingMatchersTest;
+import org.mockitousage.misuse.InvalidUsageTest;
+import org.mockitousage.puzzlers.BridgeMethodPuzzleTest;
+import org.mockitousage.puzzlers.OverloadingPuzzleTest;
+import org.mockitousage.stacktrace.ClickableStackTracesTest;
+import org.mockitousage.stacktrace.PointingStackTraceToActualInvocationTest;
+import org.mockitousage.stacktrace.StackTraceFilteringTest;
+import org.mockitousage.stubbing.BasicStubbingTest;
+import org.mockitousage.stubbing.ReturningDefaultValuesTest;
+import org.mockitousage.stubbing.StubbingWithThrowablesTest;
+import org.mockitousage.verification.AtMostXVerificationTest;
+import org.mockitousage.verification.BasicVerificationInOrderTest;
+import org.mockitousage.verification.BasicVerificationTest;
+import org.mockitousage.verification.DescriptiveMessagesOnVerificationInOrderErrorsTest;
+import org.mockitousage.verification.DescriptiveMessagesWhenTimesXVerificationFailsTest;
+import org.mockitousage.verification.DescriptiveMessagesWhenVerificationFailsTest;
+import org.mockitousage.verification.ExactNumberOfTimesVerificationTest;
+import org.mockitousage.verification.NoMoreInteractionsVerificationTest;
+import org.mockitousage.verification.RelaxedVerificationInOrderTest;
+import org.mockitousage.verification.SelectedMocksInOrderVerificationTest;
+import org.mockitousage.verification.VerificationInOrderMixedWithOrdinaryVerificationTest;
+import org.mockitousage.verification.VerificationInOrderTest;
+import org.mockitousage.verification.VerificationOnMultipleMocksUsingMatchersTest;
+import org.mockitousage.verification.VerificationUsingMatchersTest;
+import org.mockitoutil.TestBase;
+
+public class ThreadsRunAllTestsHalfManualTest extends TestBase {
+
+    private static class AllTestsRunner extends Thread {
+
+        private Set<Class<?>> failed = new HashSet<Class<?>>();
+
+        public void run() {
+            Result result =
+                    JUnitCore.runClasses(
+                            EqualsTest.class,
+                            MockingProgressImplTest.class,
+                            TimesTest.class,
+                            MockHandlerImplTest.class,
+                            AllInvocationsFinderTest.class,
+                            ReturnsEmptyValuesTest.class,
+                            NumberOfInvocationsCheckerTest.class,
+                            DefaultRegisteredInvocationsTest.class,
+                            MissingInvocationCheckerTest.class,
+                            NumberOfInvocationsInOrderCheckerTest.class,
+                            MissingInvocationInOrderCheckerTest.class,
+                            TypeCachingMockBytecodeGeneratorTest.class,
+                            InvocationMatcherTest.class,
+                            InvocationsFinderTest.class,
+                            MockitoTest.class,
+                            MockUtilTest.class,
+                            ReporterTest.class,
+                            MockitoAssertionErrorTest.class,
+                            MockitoExceptionTest.class,
+                            StackTraceFilteringTest.class,
+                            BridgeMethodPuzzleTest.class,
+                            OverloadingPuzzleTest.class,
+                            InvalidUsageTest.class,
+                            UsingVarargsTest.class,
+                            CustomMatchersTest.class,
+                            ComparableMatchersTest.class,
+                            InvalidUseOfMatchersTest.class,
+                            MatchersTest.class,
+                            MatchersToStringTest.class,
+                            VerificationAndStubbingUsingMatchersTest.class,
+                            BasicStubbingTest.class,
+                            ReturningDefaultValuesTest.class,
+                            StubbingWithThrowablesTest.class,
+                            AtMostXVerificationTest.class,
+                            BasicVerificationTest.class,
+                            ExactNumberOfTimesVerificationTest.class,
+                            VerificationInOrderTest.class,
+                            NoMoreInteractionsVerificationTest.class,
+                            SelectedMocksInOrderVerificationTest.class,
+                            VerificationOnMultipleMocksUsingMatchersTest.class,
+                            VerificationUsingMatchersTest.class,
+                            RelaxedVerificationInOrderTest.class,
+                            DescriptiveMessagesWhenVerificationFailsTest.class,
+                            DescriptiveMessagesWhenTimesXVerificationFailsTest.class,
+                            BasicVerificationInOrderTest.class,
+                            VerificationInOrderMixedWithOrdinaryVerificationTest.class,
+                            DescriptiveMessagesOnVerificationInOrderErrorsTest.class,
+                            InvalidStateDetectionTest.class,
+                            ReplacingObjectMethodsTest.class,
+                            ClickableStackTracesTest.class,
+                            ExampleTest.class,
+                            PointingStackTraceToActualInvocationTest.class,
+                            VerificationInOrderFromMultipleThreadsTest.class,
+                            ResetTest.class,
+                            ReturnsGenericDeepStubsTest.class);
+
+            if (!result.wasSuccessful()) {
+                System.err.println("Thread[" + Thread.currentThread().getId() + "]: error!");
+                List<Failure> failures = result.getFailures();
+                System.err.println(failures.size());
+                for (Failure failure : failures) {
+                    System.err.println(failure.getTrace());
+                    failed.add(failure.getDescription().getTestClass());
+                }
+            }
+        }
+
+        public Set<Class<?>> getFailed() {
+            return failed;
+        }
+    }
+
+    @Test
+    public void shouldRunInMultipleThreads() throws Exception {
+        // this test ALWAYS fails if there is a single failing unit
+        assertEquals(
+                "Run in multiple thread failed for tests",
+                Collections.emptySet(),
+                runInMultipleThreads(3));
+    }
+
+    public static Set<Class<?>> runInMultipleThreads(int numberOfThreads) throws Exception {
+        List<AllTestsRunner> threads = new LinkedList<AllTestsRunner>();
+        for (int i = 1; i <= numberOfThreads; i++) {
+            threads.add(new AllTestsRunner());
+        }
+
+        for (Thread t : threads) {
+            t.start();
+        }
+
+        Set<Class<?>> failed = new HashSet<Class<?>>();
+        for (AllTestsRunner t : threads) {
+            t.join();
+            failed.addAll(t.getFailed());
+        }
+
+        return failed;
+    }
+
+    public static void main(String[] args) throws Exception {
+        int numberOfThreads = 20;
+        long before = System.currentTimeMillis();
+        Set<Class<?>> failed = runInMultipleThreads(numberOfThreads);
+        long after = System.currentTimeMillis();
+        long executionTime = (after - before) / 1000;
+        System.out.println(
+                "Finished tests in "
+                        + numberOfThreads
+                        + " threads in "
+                        + executionTime
+                        + " seconds. ("
+                        + failed.size()
+                        + " tests failed)");
+    }
+}
diff --git a/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java b/mockito-core/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
similarity index 75%
rename from src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
rename to mockito-core/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
index 3e01433176..d27276a016 100644
--- a/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
+++ b/mockito-core/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
@@ -16,7 +16,7 @@ public class ThreadsShareAMockTest extends TestBase {
 
     @Test
     public void shouldAllowVerifyingInThreads() throws Exception {
-        for(int i = 0; i < 100; i++) {
+        for (int i = 0; i < 100; i++) {
             performTest();
         }
     }
@@ -25,12 +25,13 @@ private void performTest() throws InterruptedException {
         mock = mock(IMethods.class);
         final Thread[] listeners = new Thread[3];
         for (int i = 0; i < listeners.length; i++) {
-            listeners[i] = new Thread() {
-                @Override
-                public void run() {
-                    mock.simpleMethod("foo");
-                }
-            };
+            listeners[i] =
+                    new Thread() {
+                        @Override
+                        public void run() {
+                            mock.simpleMethod("foo");
+                        }
+                    };
             listeners[i].start();
         }
         for (Thread listener : listeners) {
diff --git a/mockito-core/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java b/mockito-core/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
new file mode 100644
index 0000000000..f937674e75
--- /dev/null
+++ b/mockito-core/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.concurrentmockito;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+// this test always passes but please keep looking sys err
+// this test should be run 10 times, manually
+public class ThreadsShareGenerouslyStubbedMockTest extends TestBase {
+
+    private IMethods mock;
+
+    @Test
+    public void shouldAllowVerifyingInThreads() throws Exception {
+        for (int i = 0; i < 50; i++) {
+            performTest();
+        }
+    }
+
+    private void performTest() throws InterruptedException {
+        mock = mock(IMethods.class);
+
+        when(mock.simpleMethod("foo"))
+                .thenReturn("foo")
+                .thenReturn("bar")
+                .thenReturn("baz")
+                .thenReturn("foo")
+                .thenReturn("bar")
+                .thenReturn("baz");
+
+        final Thread[] listeners = new Thread[100];
+        for (int i = 0; i < listeners.length; i++) {
+            listeners[i] =
+                    new Thread() {
+                        @Override
+                        public void run() {
+                            try {
+                                mock.simpleMethod("foo");
+                                mock.simpleMethod("foo");
+                                mock.simpleMethod("foo");
+                                mock.simpleMethod("foo");
+                                mock.simpleMethod("foo");
+                                mock.simpleMethod("foo");
+                            } catch (Exception e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    };
+            listeners[i].start();
+        }
+        for (Thread listener : listeners) {
+            listener.join();
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java b/mockito-core/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
new file mode 100644
index 0000000000..8f2c5e8535
--- /dev/null
+++ b/mockito-core/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.concurrentmockito;
+
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockitoutil.TestBase;
+
+public class VerificationInOrderFromMultipleThreadsTest extends TestBase {
+
+    @Test
+    public void shouldVerifyInOrderWhenMultipleThreadsInteractWithMock() throws Exception {
+        final Foo testInf = mock(Foo.class);
+
+        Thread threadOne =
+                new Thread(
+                        new Runnable() {
+                            public void run() {
+                                testInf.methodOne();
+                            }
+                        });
+        threadOne.start();
+        threadOne.join();
+
+        Thread threadTwo =
+                new Thread(
+                        new Runnable() {
+                            public void run() {
+                                testInf.methodTwo();
+                            }
+                        });
+        threadTwo.start();
+        threadTwo.join();
+
+        InOrder inOrder = inOrder(testInf);
+        inOrder.verify(testInf).methodOne();
+        inOrder.verify(testInf).methodTwo();
+    }
+
+    public interface Foo {
+        void methodOne();
+
+        void methodTwo();
+    }
+}
diff --git a/src/test/java/org/concurrentmockito/package-info.java b/mockito-core/src/test/java/org/concurrentmockito/package-info.java
similarity index 100%
rename from src/test/java/org/concurrentmockito/package-info.java
rename to mockito-core/src/test/java/org/concurrentmockito/package-info.java
diff --git a/mockito-core/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java b/mockito-core/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
new file mode 100644
index 0000000000..6a017d502e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static java.lang.annotation.ElementType.*;
+
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.mock;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+public class AnnotationsAreCopiedFromMockedTypeTest {
+
+    @Test
+    public void mock_should_have_annotations_copied_from_mocked_type_at_class_level() {
+        AnnotationWithDefaultValue onClassDefaultValue =
+                mock(OnClass.class).getClass().getAnnotation(AnnotationWithDefaultValue.class);
+        AnnotationWithCustomValue onClassCustomValue =
+                mock(OnClass.class).getClass().getAnnotation(AnnotationWithCustomValue.class);
+
+        assumeTrue(
+                "Annotation copying does not apply for inline mocks",
+                mock(OnClass.class).getClass() != OnClass.class);
+
+        Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
+        Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
+    }
+
+    @Test
+    public void mock_should_have_annotations_copied_from_mocked_type_on_methods() {
+        AnnotationWithDefaultValue onClassDefaultValue =
+                method("method", mock(OnMethod.class))
+                        .getAnnotation(AnnotationWithDefaultValue.class);
+        AnnotationWithCustomValue onClassCustomValue =
+                method("method", mock(OnMethod.class))
+                        .getAnnotation(AnnotationWithCustomValue.class);
+
+        Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
+        Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
+    }
+
+    @Test
+    public void mock_should_have_annotations_copied_from_mocked_type_on_method_parameters() {
+        AnnotationWithDefaultValue onClassDefaultValue =
+                firstParamOf(method("method", mock(OnMethod.class)))
+                        .getAnnotation(AnnotationWithDefaultValue.class);
+        AnnotationWithCustomValue onClassCustomValue =
+                firstParamOf(method("method", mock(OnMethod.class)))
+                        .getAnnotation(AnnotationWithCustomValue.class);
+
+        Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
+        Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
+    }
+
+    private AnnotatedElement firstParamOf(Method method) {
+        final Annotation[] firstParamAnnotations = method.getParameterAnnotations()[0];
+
+        return new AnnotatedElement() {
+            @Override
+            public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+                return getAnnotation(annotationClass) != null;
+            }
+
+            @Override
+            @SuppressWarnings("unchecked")
+            public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+                for (Annotation firstParamAnnotation : firstParamAnnotations) {
+                    if (annotationClass.isAssignableFrom(firstParamAnnotation.annotationType())) {
+                        return (T) firstParamAnnotation;
+                    }
+                }
+                return null;
+            }
+
+            @Override
+            public Annotation[] getAnnotations() {
+                return firstParamAnnotations;
+            }
+
+            @Override
+            public Annotation[] getDeclaredAnnotations() {
+                return firstParamAnnotations;
+            }
+        };
+    }
+
+    private Method method(String methodName, Object mock) {
+        for (Method method : mock.getClass().getDeclaredMethods()) {
+            if (methodName.equals(method.getName())) {
+                return method;
+            }
+        }
+        throw new IllegalArgumentException("method name not found : " + methodName);
+    }
+
+    private Field field(String fieldName, Object mock) {
+        for (Field field : mock.getClass().getDeclaredFields()) {
+            if (fieldName.equals(field.getName())) {
+                return field;
+            }
+        }
+        throw new IllegalArgumentException("method name not found : " + fieldName);
+    }
+
+    @AnnotationWithDefaultValue
+    @AnnotationWithCustomValue("yay")
+    public class OnClass {}
+
+    public class OnMethod {
+        @AnnotationWithDefaultValue
+        @AnnotationWithCustomValue("yay")
+        public String method(
+                @AnnotationWithDefaultValue @AnnotationWithCustomValue("yay") String ignored) {
+            return "";
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({TYPE, METHOD, PARAMETER, FIELD})
+    public @interface AnnotationWithDefaultValue {
+        String value() default "yup";
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({TYPE, METHOD, PARAMETER, FIELD})
+    public @interface AnnotationWithCustomValue {
+        String value() default "";
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/ArgumentCaptorTest.java b/mockito-core/src/test/java/org/mockito/ArgumentCaptorTest.java
new file mode 100644
index 0000000000..845c934546
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/ArgumentCaptorTest.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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.validateMockitoUsage;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
+
+import java.util.Map;
+
+public class ArgumentCaptorTest {
+
+    /**
+     * Clean up the internal Mockito-Stubbing state
+     */
+    @After
+    public void tearDown() {
+        try {
+            validateMockitoUsage();
+        } catch (InvalidUseOfMatchersException ignore) {
+        }
+    }
+
+    @Test
+    public void tell_handy_return_values_to_return_value_for() throws Exception {
+
+        ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(Object.class);
+        assertThat(captor.capture()).isNull();
+    }
+
+    @Test
+    public void getCaptorType_returns_captor_type() throws Exception {
+        class Foo {}
+
+        class Bar {}
+
+        ArgumentCaptor<Foo> fooCaptor = ArgumentCaptor.forClass(Foo.class);
+        ArgumentCaptor<Bar> barCaptor = ArgumentCaptor.forClass(Bar.class);
+
+        assertThat(fooCaptor.getCaptorType()).isEqualTo(Foo.class);
+        assertThat(barCaptor.getCaptorType()).isEqualTo(Bar.class);
+    }
+
+    @Test
+    public void captor_calls_forClass_with_the_inferred_argument() throws Exception {
+        ArgumentCaptor<Map<String, Object>> captor = ArgumentCaptor.captor();
+        assertThat(captor.getCaptorType()).isEqualTo(Map.class);
+    }
+
+    @Test
+    public void captor_called_with_explicit_varargs_is_invalid() throws Exception {
+        // Test passing a single argument.
+        assertThatThrownBy(() -> ArgumentCaptor.captor(1234L))
+                .isInstanceOf(IllegalArgumentException.class);
+        // Test passing multiple arguments.
+        assertThatThrownBy(() -> ArgumentCaptor.captor("this shouldn't", "be here"))
+                .isInstanceOf(IllegalArgumentException.class);
+        // Test passing a totally null varargs array.
+        assertThatThrownBy(() -> ArgumentCaptor.<String>captor((String[]) null))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/DescriptionTest.java b/mockito-core/src/test/java/org/mockito/DescriptionTest.java
new file mode 100644
index 0000000000..3f8306ad83
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/DescriptionTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.description;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+/**
+ * Tests for https://github.com/mockito/mockito/issues/1712
+ */
+public class DescriptionTest {
+
+    @Test
+    public void verify_method_not_called_should_include_description_in_report() {
+        final String description = "Failed to call doSomethingElse";
+
+        Dependency dependency = spy(Dependency.class);
+        SystemUnderTest systemUnderTest = new SystemUnderTest();
+        systemUnderTest.doNothing(dependency);
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(dependency, description(description)).doSomethingElse(false);
+                        })
+                .isInstanceOf(MockitoAssertionError.class)
+                .hasMessageContaining(description);
+    }
+
+    @Test
+    public void
+            verify_method_called_with_unexpected_argument_should_include_description_in_report() {
+        final String description = "Failed to call doSomethingElse with expected argument";
+
+        Dependency dependency = spy(Dependency.class);
+        SystemUnderTest systemUnderTest = new SystemUnderTest();
+        systemUnderTest.doSomething(dependency);
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(dependency, description(description)).doSomethingElse(false);
+                        })
+                .isInstanceOf(MockitoAssertionError.class)
+                .hasMessageContaining(description);
+    }
+
+    static class SystemUnderTest {
+        @SuppressWarnings("unused")
+        void doNothing(Dependency dependency) {}
+
+        void doSomething(Dependency dependency) {
+            dependency.doSomethingElse(true);
+        }
+    }
+
+    static class Dependency {
+        @SuppressWarnings("unused")
+        void doSomethingElse(boolean value) {}
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/InvocationFactoryTest.java b/mockito-core/src/test/java/org/mockito/InvocationFactoryTest.java
new file mode 100644
index 0000000000..8864e05a57
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/InvocationFactoryTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.withSettings;
+
+import org.junit.Test;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
+import org.mockitoutil.TestBase;
+
+public class InvocationFactoryTest extends TestBase {
+    static class TestClass {
+        public String testMethod() throws Throwable {
+            return "un-mocked";
+        }
+    }
+
+    final TestClass mock = spy(TestClass.class);
+
+    @Test
+    public void call_method_that_throws_a_throwable() throws Throwable {
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(TestClass.class),
+                                TestClass.class.getDeclaredMethod("testMethod"),
+                                new InvocationFactory.RealMethodBehavior() {
+                                    @Override
+                                    public Object call() throws Throwable {
+                                        throw new Throwable("mocked");
+                                    }
+                                });
+
+        try {
+            Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
+        } catch (Throwable t) {
+            assertEquals("mocked", t.getMessage());
+            return;
+        }
+
+        fail();
+    }
+
+    @Test
+    public void call_method_that_returns_a_string() throws Throwable {
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(TestClass.class),
+                                TestClass.class.getDeclaredMethod("testMethod"),
+                                new InvocationFactory.RealMethodBehavior() {
+                                    @Override
+                                    public Object call() throws Throwable {
+                                        return "mocked";
+                                    }
+                                });
+
+        Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
+        assertEquals("mocked", ret);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/MockTest.java b/mockito-core/src/test/java/org/mockito/MockTest.java
new file mode 100644
index 0000000000..e904ec5d45
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/MockTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import static org.hamcrest.Matchers.not;
+import static org.junit.Assume.assumeThat;
+
+@RunWith(Enclosed.class)
+public class MockTest {
+
+    @RunWith(value = Parameterized.class)
+    public static class StrictnessToMockStrictnessTest {
+
+        public org.mockito.quality.Strictness strictness;
+
+        public StrictnessToMockStrictnessTest(org.mockito.quality.Strictness strictness) {
+            this.strictness = strictness;
+        }
+
+        @Test
+        public void should_have_matching_enum_in_mock_strictness_enum() {
+            Mock.Strictness.valueOf(strictness.name());
+        }
+
+        @Parameterized.Parameters(name = "{0}")
+        public static org.mockito.quality.Strictness[] data() {
+            return org.mockito.quality.Strictness.values();
+        }
+    }
+
+    @RunWith(value = Parameterized.class)
+    public static class MockStrictnessToStrictnessTest {
+
+        public Mock.Strictness strictness;
+
+        public MockStrictnessToStrictnessTest(Mock.Strictness strictness) {
+            this.strictness = strictness;
+        }
+
+        @Test
+        public void should_have_matching_enum_in_strictness_enum() {
+            assumeThat("Ignore NOT_SET", strictness, not(Mock.Strictness.TEST_LEVEL_DEFAULT));
+            org.mockito.quality.Strictness.valueOf(strictness.name());
+        }
+
+        @Parameterized.Parameters(name = "{0}")
+        public static Mock.Strictness[] data() {
+            return Mock.Strictness.values();
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/MockitoClearTest.java b/mockito-core/src/test/java/org/mockito/MockitoClearTest.java
new file mode 100644
index 0000000000..26b7f76d91
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/MockitoClearTest.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class MockitoClearTest {
+
+    @Test
+    public void can_clear_mock() {
+        Base mock = Mockito.mock(Base.class);
+        assertThat(Mockito.mock(Base.class).getClass()).isEqualTo(mock.getClass());
+
+        Mockito.clearAllCaches();
+
+        assertThat(Mockito.mock(Base.class).getClass()).isNotEqualTo(mock.getClass());
+    }
+
+    abstract static class Base {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/MockitoEnvTest.java b/mockito-core/src/test/java/org/mockito/MockitoEnvTest.java
new file mode 100644
index 0000000000..1a162e9390
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/MockitoEnvTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.endsWith;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.nullValue;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.mockito.internal.configuration.plugins.DefaultMockitoPlugins;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+import org.mockito.plugins.MockMaker;
+
+public class MockitoEnvTest {
+    @Test
+    public void uses_default_mock_maker_from_env() {
+        final String mockMaker = System.getenv("MOCK_MAKER");
+        Assume.assumeThat(mockMaker, not(nullValue()));
+        Assume.assumeThat(mockMaker, endsWith("default"));
+
+        assertThat(DefaultMockitoPlugins.getDefaultPluginClass(MockMaker.class.getName()))
+                .isEqualTo(Plugins.getMockMaker().getClass().getName());
+    }
+
+    @Test
+    public void uses_mock_maker_from_env() {
+        final String mockMaker = System.getenv("MOCK_MAKER");
+        Assume.assumeThat(mockMaker, not(nullValue()));
+        Assume.assumeThat(mockMaker, not(endsWith("default")));
+
+        assertThat(DefaultMockitoPlugins.getDefaultPluginClass(mockMaker))
+                .isEqualTo(Plugins.getMockMaker().getClass().getName());
+    }
+
+    @Test
+    public void uses_default_member_accessor_from_env() {
+        final String memberAccessor = System.getenv("MEMBER_ACCESSOR");
+        Assume.assumeThat(memberAccessor, not(nullValue()));
+        Assume.assumeThat(memberAccessor, endsWith("default"));
+
+        assertThat(DefaultMockitoPlugins.getDefaultPluginClass(MemberAccessor.class.getName()))
+                .isEqualTo(Plugins.getMemberAccessor().getClass().getName());
+    }
+
+    @Test
+    public void uses_member_accessor_from_env() {
+        final String memberAccessor = System.getenv("MEMBER_ACCESSOR");
+        Assume.assumeThat(memberAccessor, not(nullValue()));
+        Assume.assumeThat(memberAccessor, not(endsWith("default")));
+
+        assertThat(DefaultMockitoPlugins.getDefaultPluginClass(memberAccessor))
+                .isEqualTo(Plugins.getMemberAccessor().getClass().getName());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/MockitoTest.java b/mockito-core/src/test/java/org/mockito/MockitoTest.java
new file mode 100644
index 0000000000..619bbf2165
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/MockitoTest.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.mockito.Mockito.times;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import java.util.List;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.plugins.InlineMockMaker;
+
+@SuppressWarnings("unchecked")
+public class MockitoTest {
+
+    @Test
+    public void shouldRemoveStubbableFromProgressAfterStubbing() {
+        List mock = Mockito.mock(List.class);
+        Mockito.when(mock.add("test")).thenReturn(true);
+        // TODO Consider to move to separate test
+        assertThat(mockingProgress().pullOngoingStubbing()).isNull();
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldValidateMockWhenVerifying() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.verify("notMock");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContaining(
+                        "Argument passed to verify() is of type String and is not a mock!")
+                .hasMessageContaining("Make sure you place the parenthesis correctly!");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.verify("notMock", times(19));
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContaining(
+                        "Argument passed to verify() is of type String and is not a mock!")
+                .hasMessageContaining("Make sure you place the parenthesis correctly!");
+    }
+
+    @Test
+    public void shouldValidateMockWhenVerifyingNoMoreInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.verifyNoMoreInteractions("notMock");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContaining("Argument(s) passed is not a mock!");
+    }
+
+    @Test
+    public void shouldValidateMockWhenVerifyingNoInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.verifyNoInteractions("notMock");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContaining("Argument(s) passed is not a mock!");
+    }
+
+    @Test
+    public void shouldValidateNullMockWhenVerifyingNoInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.verifyNoInteractions(new Object[] {null});
+                        })
+                .isInstanceOf(NullInsteadOfMockException.class)
+                .hasMessageContaining("Argument(s) passed is null!");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldValidateMockWhenCreatingInOrderObject() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.inOrder("notMock");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContaining("Argument(s) passed is not a mock!");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldGiveExplanationOnStaticMockingMockMaker() {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mockStatic(Object.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "The used MockMaker SubclassByteBuddyMockMaker does not support the creation of static mocks",
+                        "Ensure your MockMaker implementation supports this feature.",
+                        "Note that static mocks maker is not supported on Android.");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldGiveExplanationOnConstructionMockingMockMaker() {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mockConstruction(Object.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "The used MockMaker SubclassByteBuddyMockMaker does not support the creation of construction mocks",
+                        "Ensure your MockMaker implementation supports this feature.",
+                        "Note that construction mocks maker is not supported on Android.");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldGiveExplanationOnConstructionMockingWithInlineMockMaker() {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineMockMaker.class));
+
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mockConstruction(Object.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "It is not possible to mock construction of the Object class to avoid inference with default object constructor chains");
+    }
+
+    @Test
+    public void shouldStartingMockSettingsContainDefaultBehavior() {
+        // given
+        MockSettingsImpl<?> settings = (MockSettingsImpl<?>) Mockito.withSettings();
+
+        // when / then
+        assertThat(settings.getDefaultAnswer()).isEqualTo(Mockito.RETURNS_DEFAULTS);
+    }
+
+    @Test
+    @SuppressWarnings({"DoNotMock", "DoNotMockAutoValue"})
+    public void automaticallyDetectsClassToMock() {
+        List<String> mock = Mockito.mock();
+        Mockito.when(mock.size()).thenReturn(42);
+        assertThat(mock.size()).isEqualTo(42);
+    }
+
+    @Test
+    @SuppressWarnings({"DoNotMock", "DoNotMockAutoValue"})
+    public void newMockMethod_shouldNotBeCalledWithNullParameters() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mock((Object[]) null);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("Please don't pass any values here");
+    }
+
+    @Test
+    public void reifiedMockMethodWithNameSetsTheExpectedName() {
+        List<String> mock = Mockito.mock("My super cool new mock");
+        assertThat(mock).hasToString("My super cool new mock");
+    }
+
+    @Test
+    public void reifiedMockMethodWithDefaultAnswerSetsTheDefaultAnswer() {
+        abstract class Something {
+            abstract Something somethingElse();
+        }
+
+        Something something = Mockito.mock(Answers.RETURNS_SELF);
+
+        assertThat(something.somethingElse()).isSameAs(something);
+    }
+
+    @Test
+    public void reifiedMockMethodWithSettingsAppliesTheSettings() {
+
+        InvocationListener invocationListener = Mockito.mock(InvocationListener.class);
+
+        List<Object> mock =
+                Mockito.mock(
+                        Mockito.withSettings()
+                                .name("my name here")
+                                .invocationListeners(invocationListener));
+
+        assertThat(mock).hasToString("my name here");
+        Mockito.verify(invocationListener).reportInvocation(ArgumentMatchers.any());
+    }
+
+    @Test
+    @SuppressWarnings({"DoNotMock", "DoNotMockAutoValue"})
+    public void newMockMethod_shouldNotBeCalledWithParameters() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mock(asList("1", "2"), asList("3", "4"));
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("Please don't pass any values here");
+    }
+
+    @Test
+    @SuppressWarnings({"DoNotMock", "DoNotMockAutoValue"})
+    public void automaticallyDetectsClassToSpy() {
+        List<String> mock = Mockito.spy();
+        Mockito.when(mock.size()).thenReturn(42);
+        assertThat(mock.size()).isEqualTo(42);
+        assertThat(mock.get(0)).isNull();
+    }
+
+    @Test
+    @SuppressWarnings({"DoNotMock", "DoNotMockAutoValue"})
+    public void newSpyMethod_shouldNotBeCalledWithParameters() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.spy(asList("1", "2"), asList("3", "4"));
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("Please don't pass any values here");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/PrematureGarbageCollectionTest.java b/mockito-core/src/test/java/org/mockito/PrematureGarbageCollectionTest.java
new file mode 100644
index 0000000000..ed5b534c1e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/PrematureGarbageCollectionTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+@Ignore("https://github.com/mockito/mockito/issues/2478")
+public class PrematureGarbageCollectionTest {
+
+    @Test
+    public void provoke_premature_garbage_collection() {
+        for (int i = 0; i < 500; i++) {
+            populateNodeList();
+        }
+    }
+
+    private static void populateNodeList() {
+        Node node = nodes();
+        while (node != null) {
+            Node next = node.next;
+            node.object.run();
+            node = next;
+        }
+    }
+
+    private static Node nodes() {
+        Node node = null;
+        for (int i = 0; i < 1_000; ++i) {
+            Node next = new Node();
+            next.next = node;
+            node = next;
+        }
+        return node;
+    }
+
+    private static class Node {
+
+        private Node next;
+
+        private final Runnable object = Mockito.mock(Runnable.class);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/StaticMockingExperimentTest.java b/mockito-core/src/test/java/org/mockito/StaticMockingExperimentTest.java
new file mode 100644
index 0000000000..361ac13857
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/StaticMockingExperimentTest.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
+import org.mockito.invocation.MockHandler;
+import org.mockitoutil.TestBase;
+
+/**
+ * This test is an experimental use of Mockito API to simulate static mocking.
+ * Other frameworks can use it to build good support for static mocking.
+ * Keep in mind that clean code never needs to mock static methods.
+ * This test is a documentation how it can be done using current public API of Mockito.
+ * This test is not only an experiment it also provides coverage for
+ * some of the advanced public API exposed for framework integrators.
+ * <p>
+ * For more rationale behind this experimental test
+ * <a href="https://www.linkedin.com/pulse/mockito-vs-powermock-opinionated-dogmatic-static-mocking-faber">see the article</a>.
+ */
+public class StaticMockingExperimentTest extends TestBase {
+
+    Foo mock = Mockito.mock(Foo.class);
+    MockHandler handler = Mockito.mockingDetails(mock).getMockHandler();
+    Method staticMethod;
+    InvocationFactory.RealMethodBehavior realMethod =
+            new InvocationFactory.RealMethodBehavior() {
+                @Override
+                public Object call() throws Throwable {
+                    return null;
+                }
+            };
+
+    @Before
+    public void before() throws Throwable {
+        staticMethod = Foo.class.getDeclaredMethod("staticMethod", String.class);
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void verify_static_method() throws Throwable {
+        // register staticMethod call on mock
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "some arg");
+        handler.handle(invocation);
+
+        // verify staticMethod on mock
+        // Mockito cannot capture static methods so we will simulate this scenario in 3 steps:
+        // 1. Call standard 'verify' method. Internally, it will add verificationMode to the thread
+        // local state.
+        //  Effectively, we indicate to Mockito that right now we are about to verify a method call
+        // on this mock.
+        verify(mock);
+        // 2. Create the invocation instance using the new public API
+        //  Mockito cannot capture static methods but we can create an invocation instance of that
+        // static invocation
+        Invocation verification =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "some arg");
+        // 3. Make Mockito handle the static method invocation
+        //  Mockito will find verification mode in thread local state and will try verify the
+        // invocation
+        handler.handle(verification);
+
+        // verify zero times, method with different argument
+        verify(mock, times(0));
+        Invocation differentArg =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "different arg");
+        handler.handle(differentArg);
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void verification_failure_static_method() throws Throwable {
+        // register staticMethod call on mock
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "foo");
+        handler.handle(invocation);
+
+        // verify staticMethod on mock
+        verify(mock);
+        Invocation differentArg =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "different arg");
+
+        try {
+            handler.handle(differentArg);
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+        }
+    }
+
+    @Test
+    public void stubbing_static_method() throws Throwable {
+        // register staticMethod call on mock
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "foo");
+        handler.handle(invocation);
+
+        // register stubbing
+        when(null).thenReturn("hey");
+
+        // validate stubbed return value
+        assertEquals("hey", handler.handle(invocation));
+        assertEquals("hey", handler.handle(invocation));
+
+        // default null value is returned if invoked with different argument
+        Invocation differentArg =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "different arg");
+        assertEquals(null, handler.handle(differentArg));
+    }
+
+    @Test
+    public void do_answer_stubbing_static_method() throws Throwable {
+        // register stubbed return value
+        Object ignored = doReturn("hey").when(mock);
+
+        // complete stubbing by triggering an invocation that needs to be stubbed
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "foo");
+        handler.handle(invocation);
+
+        // validate stubbed return value
+        assertEquals("hey", handler.handle(invocation));
+        assertEquals("hey", handler.handle(invocation));
+
+        // default null value is returned if invoked with different argument
+        Invocation differentArg =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "different arg");
+        assertEquals(null, handler.handle(differentArg));
+    }
+
+    @Test
+    public void verify_no_more_interactions() throws Throwable {
+        // works for now because there are not interactions
+        verifyNoMoreInteractions(mock);
+
+        // register staticMethod call on mock
+        Invocation invocation =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                staticMethod,
+                                realMethod,
+                                "foo");
+        handler.handle(invocation);
+
+        // fails now because we have one static invocation recorded
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void stubbing_new() throws Throwable {
+        Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
+        Method adapter = ConstructorMethodAdapter.class.getDeclaredMethods()[0];
+
+        // stub constructor
+        Object ignored = doReturn(new Foo("hey!")).when(mock);
+        Invocation constructor =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                adapter,
+                                realMethod,
+                                ctr,
+                                "foo");
+        handler.handle(constructor);
+
+        // test stubbing
+        Object result = handler.handle(constructor);
+        assertEquals("foo:hey!", result.toString());
+
+        // stubbing miss
+        Invocation differentArg =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                adapter,
+                                realMethod,
+                                ctr,
+                                "different arg");
+        Object result2 = handler.handle(differentArg);
+        assertEquals(null, result2);
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void verifying_new() throws Throwable {
+        Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
+        Method adapter = ConstructorMethodAdapter.class.getDeclaredMethods()[0];
+
+        // invoke constructor
+        Invocation constructor =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                adapter,
+                                realMethod,
+                                ctr,
+                                "matching arg");
+        handler.handle(constructor);
+
+        // verify successfully
+        verify(mock);
+        handler.handle(constructor);
+
+        // verification failure
+        verify(mock);
+        Invocation differentArg =
+                Mockito.framework()
+                        .getInvocationFactory()
+                        .createInvocation(
+                                mock,
+                                withSettings().build(Foo.class),
+                                adapter,
+                                realMethod,
+                                ctr,
+                                "different arg");
+        try {
+            handler.handle(differentArg);
+            fail();
+        } catch (WantedButNotInvoked e) {
+            assertThat(e.getMessage()).contains("matching arg").contains("different arg");
+        }
+    }
+
+    static class Foo {
+
+        private final String arg;
+
+        public Foo(String arg) {
+            this.arg = arg;
+        }
+
+        public static String staticMethod(String arg) {
+            return "";
+        }
+
+        @Override
+        public String toString() {
+            return "foo:" + arg;
+        }
+    }
+
+    /**
+     * Adapts constructor to method calls needed to work with Mockito API.
+     */
+    interface ConstructorMethodAdapter {
+        Object construct(Constructor constructor, Object... args);
+    }
+}
diff --git a/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java b/mockito-core/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
similarity index 88%
rename from src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
rename to mockito-core/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
index fc2ceaa679..d54e7409a2 100644
--- a/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
+++ b/mockito-core/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
@@ -29,7 +29,8 @@ public void shouldKeepUnfilteredStackTrace() {
     @Test
     public void should_prepend_message_to_original() {
         MockitoAssertionError original = new MockitoAssertionError("original message");
-        MockitoAssertionError errorWithPrependedMessage = new MockitoAssertionError(original, "new message");
+        MockitoAssertionError errorWithPrependedMessage =
+                new MockitoAssertionError(original, "new message");
         assertEquals("new message\noriginal message", errorWithPrependedMessage.getMessage());
     }
 }
diff --git a/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java b/mockito-core/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java
similarity index 100%
rename from src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java
rename to mockito-core/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java
diff --git a/mockito-core/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java b/mockito-core/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
new file mode 100644
index 0000000000..edd6af4c79
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.base;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.mockito.internal.configuration.ConfigurationAccess;
+
+public class MockitoSerializationIssueTest {
+
+    @Test
+    public void should_filter_out_test_class_from_stacktrace_when_clean_flag_is_true() {
+        // given
+        ConfigurationAccess.getConfig().overrideCleansStackTrace(true);
+
+        // when
+        MockitoSerializationIssue issue =
+                new MockitoSerializationIssue("msg", new Exception("cause"));
+
+        // then
+        assertThat(Arrays.toString(issue.getUnfilteredStackTrace()))
+                .contains("MockitoSerializationIssueTest");
+        assertThat(Arrays.toString(issue.getStackTrace()))
+                .doesNotContain("MockitoSerializationIssueTest");
+    }
+
+    @Test
+    public void should_keep_executing_class_in_stacktrace_when_clean_flag_is_false() {
+        // given
+        ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
+
+        // when
+        MockitoSerializationIssue issue =
+                new MockitoSerializationIssue("msg", new Exception("cause"));
+
+        // then
+        assertThat(Arrays.toString(issue.getUnfilteredStackTrace()))
+                .contains("MockitoSerializationIssueTest");
+        assertThat(Arrays.toString(issue.getStackTrace()))
+                .contains("MockitoSerializationIssueTest");
+    }
+}
diff --git a/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java b/mockito-core/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
similarity index 92%
rename from src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
rename to mockito-core/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
index 32f0d75604..d7bf1869b0 100644
--- a/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
+++ b/mockito-core/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
@@ -11,7 +11,7 @@ public class StackTraceBuilder {
 
     private String[] methods;
 
-    public StackTraceBuilder methods(String ... methods) {
+    public StackTraceBuilder methods(String... methods) {
         this.methods = methods;
         return this;
     }
diff --git a/src/test/java/org/mockito/exceptions/base/TraceBuilder.java b/mockito-core/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
similarity index 83%
rename from src/test/java/org/mockito/exceptions/base/TraceBuilder.java
rename to mockito-core/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
index d0fd77457e..66f7a91bae 100644
--- a/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
+++ b/mockito-core/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
@@ -4,6 +4,8 @@
  */
 package org.mockito.exceptions.base;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
@@ -20,7 +22,7 @@ public Throwable toThrowable() {
     }
 
     private List<StackTraceElement> toTraceList() {
-        assert methods.length == 0 || classes.length == 0;
+        assertThat(methods.length == 0 || classes.length == 0).isTrue();
 
         List<StackTraceElement> trace = new LinkedList<StackTraceElement>();
         for (String method : methods) {
@@ -38,12 +40,12 @@ public StackTraceElement[] toTraceArray() {
         return toTraceList().toArray(new StackTraceElement[0]);
     }
 
-    public TraceBuilder classes(String ... classes) {
+    public TraceBuilder classes(String... classes) {
         this.classes = classes;
         return this;
     }
 
-    public TraceBuilder methods(String ... methods) {
+    public TraceBuilder methods(String... methods) {
         this.methods = methods;
         return this;
     }
diff --git a/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java b/mockito-core/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
similarity index 85%
rename from src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
rename to mockito-core/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
index 54a0ff35c2..832d6d7572 100644
--- a/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
+++ b/mockito-core/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
@@ -11,7 +11,7 @@
 
 public class StackTraceCleanerTest {
 
-    private DefaultStackTraceCleaner cleaner= new DefaultStackTraceCleaner();
+    private DefaultStackTraceCleaner cleaner = new DefaultStackTraceCleaner();
 
     @Test
     public void allow_or_disallow_mockito_mockito_objects_in_stacktrace() throws Exception {
@@ -34,11 +34,15 @@ public void allow_or_disallow_mockito_mockito_objects_in_stacktrace() throws Exc
     }
 
     private void assertAcceptedInStackTrace(String className) {
-        assertThat(cleaner.isIn(stackTraceElementWith(className))).describedAs("Must be accepted in stacktrace %s", className).isTrue();
+        assertThat(cleaner.isIn(stackTraceElementWith(className)))
+                .describedAs("Must be accepted in stacktrace %s", className)
+                .isTrue();
     }
 
     private void assertRejectedInStackTrace(String className) {
-        assertThat(cleaner.isIn(stackTraceElementWith(className))).describedAs("Must be rejected in stacktrace %s", className).isFalse();
+        assertThat(cleaner.isIn(stackTraceElementWith(className)))
+                .describedAs("Must be rejected in stacktrace %s", className)
+                .isFalse();
     }
 
     private StackTraceElement stackTraceElementWith(String className) {
diff --git a/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java b/mockito-core/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
similarity index 88%
rename from src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
index 44acd4c9eb..dac34c07e5 100644
--- a/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
@@ -36,22 +36,22 @@ public void setup() {
 
     @Test
     public void no_interactions() throws Exception {
-        //expect
+        // expect
         assertTrue(find(asList(mockOne, mockTwo)).isEmpty());
         assertTrue(findStubbings(asList(mockOne, mockTwo)).isEmpty());
     }
 
     @Test
     public void provides_invocations_in_order() throws Exception {
-        //given
+        // given
         mockOne.simpleMethod(100);
         mockTwo.simpleMethod(200);
         mockOne.simpleMethod(300);
 
-        //when
+        // when
         List<Invocation> invocations = find(asList(mockOne, mockTwo));
 
-        //then
+        // then
         assertEquals(3, invocations.size());
         assertArgumentEquals(100, invocations.get(0));
         assertArgumentEquals(200, invocations.get(1));
@@ -60,28 +60,29 @@ public void provides_invocations_in_order() throws Exception {
 
     @Test
     public void deduplicates_interactions_from_the_same_mock() throws Exception {
-        //given
+        // given
         mockOne.simpleMethod(100);
 
-        //when
+        // when
         List<Invocation> invocations = find(asList(mockOne, mockOne, mockOne));
 
-        //then
+        // then
         assertEquals(1, invocations.size());
     }
 
     @Test
     public void provides_stubbings_in_order() throws Exception {
-        //given
-        mockOne.simpleMethod(50); //ignored, not a stubbing
+        // given
+        mockOne.simpleMethod(50); // ignored, not a stubbing
         when(mockOne.simpleMethod(100)).thenReturn("100");
         when(mockOne.simpleMethod(200)).thenReturn("200");
         when(mockTwo.simpleMethod(300)).thenReturn("300");
 
-        //when
-        List<Stubbing> stubbings = new ArrayList<Stubbing>(findStubbings(asList(mockOne, mockOne, mockTwo)));
+        // when
+        List<Stubbing> stubbings =
+                new ArrayList<Stubbing>(findStubbings(asList(mockOne, mockOne, mockTwo)));
 
-        //then
+        // then
         assertEquals(3, stubbings.size());
         assertArgumentEquals(100, stubbings.get(0).getInvocation());
         assertArgumentEquals(200, stubbings.get(1).getInvocation());
diff --git a/src/test/java/org/mockito/internal/InOrderImplTest.java b/mockito-core/src/test/java/org/mockito/internal/InOrderImplTest.java
similarity index 95%
rename from src/test/java/org/mockito/internal/InOrderImplTest.java
rename to mockito-core/src/test/java/org/mockito/internal/InOrderImplTest.java
index cb5d7ecb81..5224a4fb7b 100644
--- a/src/test/java/org/mockito/internal/InOrderImplTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/InOrderImplTest.java
@@ -23,15 +23,15 @@ public class InOrderImplTest extends TestBase {
 
     @Test
     public void shouldMarkVerifiedInOrder() throws Exception {
-        //given
+        // given
         InOrderImpl impl = new InOrderImpl(singletonList(mock));
         Invocation i = new InvocationBuilder().toInvocation();
         assertFalse(impl.isVerified(i));
 
-        //when
+        // when
         impl.markVerified(i);
 
-        //then
+        // then
         assertTrue(impl.isVerified(i));
     }
 }
diff --git a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java b/mockito-core/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
similarity index 86%
rename from src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
rename to mockito-core/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
index 6e55814ebc..be466a049c 100644
--- a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
@@ -30,12 +30,10 @@
  *
  *    -on method call on mock
  *    -on verify
- *    -on verifyZeroInteractions
  *    -on verifyNoMoreInteractions
  *    -on verify in order
  *    -on stub
  */
-@SuppressWarnings({"unchecked", "deprecation"})
 public class InvalidStateDetectionTest extends TestBase {
 
     @Mock private IMethods mock;
@@ -60,9 +58,6 @@ public void shouldDetectUnfinishedStubbing() {
         when(mock.simpleMethod());
         detectsAndCleansUp(new OnVerifyInOrder(), UnfinishedStubbingException.class);
 
-        when(mock.simpleMethod());
-        detectsAndCleansUp(new OnVerifyZeroInteractions(), UnfinishedStubbingException.class);
-
         when(mock.simpleMethod());
         detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedStubbingException.class);
 
@@ -88,9 +83,6 @@ public void shouldDetectUnfinishedDoAnswerStubbing() {
         doAnswer(null);
         detectsAndCleansUp(new OnVerifyInOrder(), UnfinishedStubbingException.class);
 
-        doAnswer(null);
-        detectsAndCleansUp(new OnVerifyZeroInteractions(), UnfinishedStubbingException.class);
-
         doAnswer(null);
         detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedStubbingException.class);
 
@@ -113,9 +105,6 @@ public void shouldDetectUnfinishedVerification() {
         verify(mock);
         detectsAndCleansUp(new OnVerifyInOrder(), UnfinishedVerificationException.class);
 
-        verify(mock);
-        detectsAndCleansUp(new OnVerifyZeroInteractions(), UnfinishedVerificationException.class);
-
         verify(mock);
         detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedVerificationException.class);
 
@@ -128,39 +117,38 @@ public void shouldDetectUnfinishedVerification() {
 
     @Test
     public void shouldDetectMisplacedArgumentMatcher() {
-        anyObject();
+        Object ignored = any();
         detectsAndCleansUp(new OnVerify(), InvalidUseOfMatchersException.class);
 
-        anyObject();
+        ignored = any();
         detectsAndCleansUp(new OnVerifyInOrder(), InvalidUseOfMatchersException.class);
 
-        anyObject();
-        detectsAndCleansUp(new OnVerifyZeroInteractions(), InvalidUseOfMatchersException.class);
-
-        anyObject();
+        ignored = any();
         detectsAndCleansUp(new OnVerifyNoMoreInteractions(), InvalidUseOfMatchersException.class);
 
-        anyObject();
+        ignored = any();
         detectsAndCleansUp(new OnVerifyNoInteractions(), InvalidUseOfMatchersException.class);
 
-        anyObject();
+        ignored = any();
         detectsAndCleansUp(new OnDoAnswer(), InvalidUseOfMatchersException.class);
     }
 
     @Test
     public void shouldCorrectStateAfterDetectingUnfinishedStubbing() {
-        doThrow(new RuntimeException()).when(mock);
+        Object ignored = doThrow(new RuntimeException()).when(mock);
 
         try {
             doThrow(new RuntimeException()).when(mock).oneArg(true);
             fail();
-        } catch (UnfinishedStubbingException e) {}
+        } catch (UnfinishedStubbingException e) {
+        }
 
         doThrow(new RuntimeException()).when(mock).oneArg(true);
         try {
             mock.oneArg(true);
             fail();
-        } catch (RuntimeException e) {}
+        } catch (RuntimeException e) {
+        }
     }
 
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@@ -172,7 +160,8 @@ public void shouldCorrectStateAfterDetectingUnfinishedVerification() {
         try {
             verify(mock).simpleMethod();
             fail();
-        } catch (UnfinishedVerificationException e) {}
+        } catch (UnfinishedVerificationException e) {
+        }
 
         verify(mock).simpleMethod();
     }
@@ -195,13 +184,6 @@ public void detect(IMethods 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) {
@@ -257,7 +239,7 @@ private void detectsAndCleansUp(DetectsInvalidState detector, Class<?> expected)
         } catch (Exception e) {
             assertEquals(expected, e.getClass());
         }
-        //Make sure state is cleaned up
+        // Make sure state is cleaned up
         new StateMaster().validate();
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
new file mode 100644
index 0000000000..faf86d716f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class ClassPathLoaderTest extends TestBase {
+
+    @Test
+    public void shouldReadConfigurationClassFromClassPath() {
+        ConfigurationAccess.getConfig()
+                .overrideDefaultAnswer(
+                        new Answer<Object>() {
+                            public Object answer(InvocationOnMock invocation) {
+                                return "foo";
+                            }
+                        });
+
+        IMethods mock = mock(IMethods.class);
+        assertEquals("foo", mock.simpleMethod());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
new file mode 100644
index 0000000000..48cf998b00
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import net.bytebuddy.ByteBuddy;
+import org.assertj.core.api.Assertions;
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockitoutil.ClassLoaders;
+import org.objenesis.Objenesis;
+
+public class GlobalConfigurationTest {
+    @Test
+    public void returns_mockito_annotation_engine_of_Plugins_if_no_MockitoConfiguration()
+            throws Throwable {
+        ClassLoader anotherWorld =
+                ClassLoaders.isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, Objenesis.class)
+                        .withPrivateCopyOf("org.mockito", "net.bytebuddy", "org.objenesis")
+                        .withCodeSourceUrlOf(Assertions.class)
+                        .withPrivateCopyOf("org.assertj")
+                        .without("org.mockito.configuration.MockitoConfiguration")
+                        .build();
+
+        ClassLoaders.using(anotherWorld)
+                .execute(
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine())
+                                        .isInstanceOf(Plugins.getAnnotationEngine().getClass());
+                            }
+                        });
+    }
+
+    @After
+    public void reset_annotation_engine() {
+        ConfigurationAccess.getConfig().overrideAnnotationEngine(null);
+    }
+
+    private static class CustomAnnotationEngine implements org.mockito.plugins.AnnotationEngine {
+        @Override
+        public AutoCloseable process(Class<?> clazz, Object testInstance) {
+            return new NoAction();
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/MockAnnotationProcessorTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/MockAnnotationProcessorTest.java
new file mode 100644
index 0000000000..b9e9dd0bb2
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/MockAnnotationProcessorTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.MockedStatic;
+import org.mockito.exceptions.base.MockitoException;
+
+public class MockAnnotationProcessorTest {
+
+    @SuppressWarnings("unused")
+    private MockedStatic<Void> nonGeneric;
+
+    @SuppressWarnings("unused")
+    private MockedStatic<List<?>> generic;
+
+    @SuppressWarnings({"raw", "unused"})
+    private MockedStatic raw;
+
+    @Test
+    public void testNonGeneric() throws Exception {
+        Class<?> type =
+                MockAnnotationProcessor.inferParameterizedType(
+                        MockAnnotationProcessorTest.class
+                                .getDeclaredField("nonGeneric")
+                                .getGenericType(),
+                        "nonGeneric",
+                        "Sample");
+        assertThat(type).isEqualTo(Void.class);
+    }
+
+    @Test
+    public void testGeneric() {
+        assertThatThrownBy(
+                        () -> {
+                            MockAnnotationProcessor.inferParameterizedType(
+                                    MockAnnotationProcessorTest.class
+                                            .getDeclaredField("generic")
+                                            .getGenericType(),
+                                    "generic",
+                                    "Sample");
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "Mockito cannot infer a static mock from a raw type for generic");
+    }
+
+    @Test
+    public void testRaw() {
+        assertThatThrownBy(
+                        () -> {
+                            MockAnnotationProcessor.inferParameterizedType(
+                                    MockAnnotationProcessorTest.class
+                                            .getDeclaredField("raw")
+                                            .getGenericType(),
+                                    "raw",
+                                    "Sample");
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Mockito cannot infer a static mock from a raw type for raw");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
new file mode 100644
index 0000000000..75f0b6e862
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.Observer;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.internal.configuration.injection.MockInjection;
+
+@SuppressWarnings("unchecked")
+public class MockInjectionTest {
+
+    private AnObjectWithConstructor withConstructor;
+    private AnObjectWithoutConstructor withoutConstructor;
+
+    @After
+    public void reset() throws Exception {
+        withConstructor = null;
+        withoutConstructor = null;
+    }
+
+    @Test
+    public void should_not_allow_null_on_field() {
+        assertThatThrownBy(
+                        () -> {
+                            MockInjection.onField((Field) null, this);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("item in fields should not be null");
+    }
+
+    @Test
+    public void should_not_allow_null_on_fields() {
+        assertThatThrownBy(
+                        () -> {
+                            MockInjection.onFields((Set<Field>) null, this);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("fields should not be null");
+    }
+
+    @Test
+    public void should_not_allow_null_on_instance_owning_the_field() {
+        assertThatThrownBy(
+                        () -> {
+                            MockInjection.onField(field("withConstructor"), null);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("fieldOwner should not be null");
+    }
+
+    @Test
+    public void should_not_allow_null_on_mocks() {
+        assertThatThrownBy(
+                        () -> {
+                            MockInjection.onField(field("withConstructor"), this).withMocks(null);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("mocks should not be null");
+    }
+
+    @Test
+    public void can_try_constructor_injection() throws Exception {
+        MockInjection.onField(field("withConstructor"), this)
+                .withMocks(oneSetMock())
+                .tryConstructorInjection()
+                .apply();
+
+        assertThat(withConstructor.initializedWithConstructor).isTrue();
+    }
+
+    @Test
+    public void should_not_fail_if_constructor_injection_is_not_possible() throws Exception {
+        MockInjection.onField(field("withoutConstructor"), this)
+                .withMocks(otherKindOfMocks())
+                .tryConstructorInjection()
+                .apply();
+
+        assertThat(withoutConstructor).isNull();
+    }
+
+    @Test
+    public void can_try_property_or_setter_injection() throws Exception {
+        MockInjection.onField(field("withoutConstructor"), this)
+                .withMocks(oneSetMock())
+                .tryPropertyOrFieldInjection()
+                .apply();
+
+        assertThat(withoutConstructor.theSet).isNotNull();
+    }
+
+    @Test
+    public void should_not_fail_if_property_or_field_injection_is_not_possible() throws Exception {
+        MockInjection.onField(field("withoutConstructor"), this)
+                .withMocks(otherKindOfMocks())
+                .tryPropertyOrFieldInjection()
+                .apply();
+
+        assertThat(withoutConstructor.theSet).isNull();
+    }
+
+    private Set oneSetMock() {
+        return Collections.singleton(mock(Set.class));
+    }
+
+    private Set otherKindOfMocks() {
+        return Collections.singleton(mock(Observer.class));
+    }
+
+    private Field field(String field) throws NoSuchFieldException {
+        return getClass().getDeclaredField(field);
+    }
+
+    public static class AnObjectWithConstructor {
+        public boolean initializedWithConstructor = false;
+
+        public AnObjectWithConstructor(Set<String> strings) {
+            initializedWithConstructor = true;
+        }
+    }
+
+    public static class AnObjectWithoutConstructor {
+        private Set<?> theSet;
+    }
+}
diff --git a/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java
rename to mockito-core/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java
new file mode 100644
index 0000000000..4b4da06728
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.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.configuration.injection;
+
+import static org.junit.Assert.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.util.*;
+
+import org.junit.Test;
+
+public class SimpleArgumentResolverTest {
+
+    @Test
+    public void should_return_object_matching_given_types() throws Exception {
+        ConstructorInjection.SimpleArgumentResolver resolver =
+                new ConstructorInjection.SimpleArgumentResolver(
+                        newSetOf(
+                                new HashSet<Long>(),
+                                new ByteArrayOutputStream(),
+                                new HashMap<String, String>()));
+
+        Object[] resolvedInstance =
+                resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
+
+        assertEquals(3, resolvedInstance.length);
+        assertTrue(resolvedInstance[0] instanceof Set);
+        assertTrue(resolvedInstance[1] instanceof Map);
+        assertTrue(resolvedInstance[2] instanceof OutputStream);
+    }
+
+    @Test
+    public void should_return_null_when_match_is_not_possible_on_given_types() throws Exception {
+        ConstructorInjection.SimpleArgumentResolver resolver =
+                new ConstructorInjection.SimpleArgumentResolver(
+                        newSetOf(new HashSet<Float>(), new ByteArrayOutputStream()));
+
+        Object[] resolvedInstance =
+                resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
+
+        assertEquals(3, resolvedInstance.length);
+        assertTrue(resolvedInstance[0] instanceof Set);
+        assertNull(resolvedInstance[1]);
+        assertTrue(resolvedInstance[2] instanceof OutputStream);
+    }
+
+    @Test
+    public void should_return_null_when_types_are_primitives() throws Exception {
+        ConstructorInjection.SimpleArgumentResolver resolver =
+                new ConstructorInjection.SimpleArgumentResolver(
+                        newSetOf(new HashMap<Integer, String>(), new TreeSet<Integer>()));
+
+        Object[] resolvedInstance =
+                resolver.resolveTypeInstances(Set.class, Map.class, Boolean.class);
+
+        assertEquals(3, resolvedInstance.length);
+        assertTrue(resolvedInstance[0] instanceof Set);
+        assertTrue(resolvedInstance[1] instanceof Map);
+        assertNull(resolvedInstance[2]);
+    }
+
+    private Set<Object> newSetOf(Object... objects) {
+        return new HashSet<Object>(Arrays.asList(objects));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
new file mode 100644
index 0000000000..01024f6275
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import static org.junit.Assert.*;
+import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.INLINE_ALIAS;
+import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.PROXY_ALIAS;
+import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.SUBCLASS_ALIAS;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.MockMakers;
+import org.mockito.Mockito;
+import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.internal.util.ConsoleMockitoLogger;
+import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.plugins.MockitoPlugins;
+import org.mockitoutil.TestBase;
+
+public class DefaultMockitoPluginsTest extends TestBase {
+
+    private final DefaultMockitoPlugins plugins = new DefaultMockitoPlugins();
+
+    @Test
+    public void provides_plugins() throws Exception {
+        assertEquals(
+                "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker",
+                DefaultMockitoPlugins.getDefaultPluginClass(INLINE_ALIAS));
+        assertEquals(InlineByteBuddyMockMaker.class, plugins.getInlineMockMaker().getClass());
+        assertEquals(
+                "org.mockito.internal.creation.proxy.ProxyMockMaker",
+                DefaultMockitoPlugins.getDefaultPluginClass(PROXY_ALIAS));
+        assertEquals(
+                "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker",
+                DefaultMockitoPlugins.getDefaultPluginClass(SUBCLASS_ALIAS));
+        assertEquals(
+                InlineByteBuddyMockMaker.class,
+                plugins.getDefaultPlugin(MockMaker.class).getClass());
+        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
+        assertEquals(
+                ConsoleMockitoLogger.class,
+                plugins.getDefaultPlugin(MockitoLogger.class).getClass());
+    }
+
+    @Test
+    public void test_getMockMaker() {
+        assertNotNull(plugins.getMockMaker(null));
+        assertTrue(plugins.getMockMaker(MockMakers.INLINE) instanceof InlineByteBuddyMockMaker);
+    }
+
+    @Test
+    public void test_getMockMaker_throws_IllegalStateException_on_invalid_name() {
+        Assertions.assertThatThrownBy(
+                        () -> {
+                            plugins.getMockMaker("non existing");
+                        })
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessage("Failed to load MockMaker: non existing");
+    }
+
+    @Test
+    public void
+            test_MockitoPlugins_getMockMaker_default_method_throws_UnsupportedOperationException() {
+        MockitoPlugins pluginsSpy = Mockito.spy(MockitoPlugins.class);
+        Assertions.assertThatThrownBy(
+                        () -> {
+                            pluginsSpy.getMockMaker("non existing");
+                        })
+                .isInstanceOf(UnsupportedOperationException.class)
+                .hasMessage("This method is not implemented.");
+    }
+}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
similarity index 90%
rename from src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
index 40677be6a8..e33e3027b4 100644
--- a/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
@@ -20,12 +20,12 @@ public class PluginFileReaderTest extends TestBase {
 
     @Test
     public void no_class_in_resource() throws IOException {
-        //no class
+        // no class
         assertNull(reader.readPluginClass(impl("")));
         assertNull(reader.readPluginClass(impl("  ")));
         assertNull(reader.readPluginClass(impl(" \n ")));
 
-        //commented out
+        // commented out
         assertNull(reader.readPluginClass(impl("#foo")));
         assertNull(reader.readPluginClass(impl("  # foo  ")));
         assertNull(reader.readPluginClass(impl("  # # # java.langString # ")));
@@ -41,7 +41,8 @@ public void reads_class_name() throws IOException {
         assertEquals("java.lang.String", reader.readPluginClass(impl("java.lang.String")));
         assertEquals("x", reader.readPluginClass(impl("x")));
         assertEquals("x y z", reader.readPluginClass(impl(" x y z ")));
-        assertEquals("foo.Foo", reader.readPluginClass(impl(" #my class\n  foo.Foo \n #other class ")));
+        assertEquals(
+                "foo.Foo", reader.readPluginClass(impl(" #my class\n  foo.Foo \n #other class ")));
         assertEquals("foo.Foo", reader.readPluginClass(impl("foo.Foo  # cool class")));
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
new file mode 100644
index 0000000000..4b704461da
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+
+import java.io.File;
+import java.net.URL;
+import java.util.Collections;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.internal.util.io.IOUtil;
+import org.mockito.plugins.PluginSwitch;
+import org.mockitoutil.TestBase;
+
+public class PluginFinderTest extends TestBase {
+
+    @Mock PluginSwitch switcher;
+    @InjectMocks PluginFinder finder;
+    public @Rule TemporaryFolder tmp = new TemporaryFolder();
+
+    @Test
+    public void empty_resources() {
+        assertNull(finder.findPluginClass(Collections.<URL>emptyList()));
+    }
+
+    @Test
+    public void no_valid_impl() throws Exception {
+        File f = tmp.newFile();
+
+        // when
+        IOUtil.writeText("  \n  ", f);
+
+        // then
+        assertNull(finder.findPluginClass(asList(f.toURI().toURL())));
+    }
+
+    @Test
+    public void single_implementation() throws Exception {
+        File f = tmp.newFile();
+        when(switcher.isEnabled("foo.Foo")).thenReturn(true);
+
+        // when
+        IOUtil.writeText("  foo.Foo  ", f);
+
+        // then
+        assertEquals("foo.Foo", finder.findPluginClass(asList(f.toURI().toURL())));
+    }
+
+    @Test
+    public void single_implementation_disabled() throws Exception {
+        File f = tmp.newFile();
+        when(switcher.isEnabled("foo.Foo")).thenReturn(false);
+
+        // when
+        IOUtil.writeText("  foo.Foo  ", f);
+
+        // then
+        assertEquals(null, finder.findPluginClass(asList(f.toURI().toURL())));
+    }
+
+    @Test
+    public void multiple_implementations_only_one_enabled() throws Exception {
+        File f1 = tmp.newFile();
+        File f2 = tmp.newFile();
+
+        when(switcher.isEnabled("Bar")).thenReturn(true);
+
+        // when
+        IOUtil.writeText("Foo", f1);
+        IOUtil.writeText("Bar", f2);
+
+        // then
+        assertEquals("Bar", finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
+    }
+
+    @Test
+    public void multiple_implementations_only_one_useful() throws Exception {
+        File f1 = tmp.newFile();
+        File f2 = tmp.newFile();
+
+        when(switcher.isEnabled(anyString())).thenReturn(true);
+
+        // when
+        IOUtil.writeText("   ", f1);
+        IOUtil.writeText("X", f2);
+
+        // then
+        assertEquals("X", finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
+    }
+
+    @Test
+    public void multiple_empty_implementations() throws Exception {
+        File f1 = tmp.newFile();
+        File f2 = tmp.newFile();
+
+        when(switcher.isEnabled(anyString())).thenReturn(true);
+
+        // when
+        IOUtil.writeText("   ", f1);
+        IOUtil.writeText("\n", f2);
+
+        // then
+        assertEquals(null, finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
+    }
+
+    @Test
+    public void problems_loading_impl() throws Exception {
+        String fileName = "xxx";
+        File f = tmp.newFile(fileName);
+
+        // when
+        IOUtil.writeText("Bar", f);
+
+        when(switcher.isEnabled(anyString())).thenThrow(new RuntimeException("Boo!"));
+
+        try {
+            // when
+            finder.findPluginClass(asList(f.toURI().toURL()));
+            // then
+            fail();
+        } catch (Exception e) {
+            assertThat(e).hasMessageContaining(fileName);
+            assertThat(e.getCause()).hasMessage("Boo!");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
new file mode 100644
index 0000000000..4f79f24ecf
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration.plugins;
+
+import static org.junit.Assert.assertSame;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+
+public class PluginLoaderTest {
+
+    @Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+    @Mock PluginInitializer initializer;
+    @Mock DefaultMockitoPlugins plugins;
+    @InjectMocks PluginLoader loader;
+
+    @Test
+    public void loads_plugin() {
+        FooPlugin expected = new FooPlugin();
+        when(initializer.loadImpl(FooPlugin.class)).thenReturn(expected);
+
+        // when
+        FooPlugin plugin = loader.loadPlugin(FooPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_preferred_plugin() {
+        FooPlugin expected = new FooPlugin();
+        willReturn(expected).given(initializer).loadImpl(FooPlugin.class);
+
+        // when
+        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(BarPlugin.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin() {
+        willReturn(null).given(initializer).loadImpl(FooPlugin.class);
+        BarPlugin expected = new BarPlugin();
+        willReturn(expected).given(initializer).loadImpl(BarPlugin.class);
+
+        // when
+        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin() {
+        willReturn(null).given(initializer).loadImpl(FooPlugin.class);
+        willReturn(null).given(initializer).loadImpl(BarPlugin.class);
+        FooPlugin expected = new FooPlugin();
+        willReturn(expected).given(plugins).getDefaultPlugin(FooPlugin.class);
+
+        // when
+        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void fails_to_load_plugin() {
+        RuntimeException cause = new RuntimeException("Boo!");
+        when(initializer.loadImpl(Foo.class)).thenThrow(cause);
+
+        // when
+        final Foo plugin = loader.loadPlugin(Foo.class);
+
+        // then
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            @Override
+                            public void call() throws Throwable {
+                                plugin.toString(); // call any method on the plugin
+                            }
+                        })
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessage(
+                        "Could not initialize plugin: interface org.mockito.internal.configuration.plugins.PluginLoaderTest$Foo (alternate: null)")
+                .hasCause(cause);
+    }
+
+    @Test
+    public void loads_preferred_plugin_inheritance() {
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(Foo.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(Foo.class, FooChildPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(FooChildPlugin.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin_inheritance() {
+        willReturn(null).given(initializer).loadImpl(Bar.class);
+        BarChildPlugin expected = new BarChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(BarChildPlugin.class);
+
+        // when
+        Bar plugin = loader.loadPlugin(Bar.class, BarChildPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin_inheritance() {
+        willReturn(null).given(initializer).loadImpl(Foo.class);
+        willReturn(null).given(initializer).loadImpl(FooChildPlugin.class);
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(plugins).getDefaultPlugin(Foo.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(Foo.class, FooChildPlugin.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_preferred_plugin_inheritance_reversed() {
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(FooChildPlugin.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(FooChildPlugin.class, Foo.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(Foo.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin_inheritance_reversed() {
+        willReturn(null).given(initializer).loadImpl(BarChildPlugin.class);
+        BarChildPlugin expected = new BarChildPlugin();
+        willReturn(expected).given(initializer).loadImpl(Bar.class);
+
+        // when
+        Bar plugin = loader.loadPlugin(BarChildPlugin.class, Bar.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin_inheritance_reversed() {
+        willReturn(null).given(initializer).loadImpl(Foo.class);
+        willReturn(null).given(initializer).loadImpl(FooChildPlugin.class);
+        FooChildPlugin expected = new FooChildPlugin();
+        willReturn(expected).given(plugins).getDefaultPlugin(FooChildPlugin.class);
+
+        // when
+        Foo plugin = loader.loadPlugin(FooChildPlugin.class, Foo.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_preferred_plugin_inheritance_lowest_common_denominator() {
+        FooBarChildPlugin1 expected = new FooBarChildPlugin1();
+        willReturn(expected).given(initializer).loadImpl(FooBarChildPlugin1.class);
+
+        // when
+        FooBar plugin = loader.loadPlugin(FooBarChildPlugin1.class, FooBarChildPlugin2.class);
+
+        // then
+        assertSame(expected, plugin);
+        verify(initializer, never()).loadImpl(FooBarChildPlugin2.class);
+    }
+
+    @Test
+    public void loads_alternative_plugin_inheritance_lowest_common_denominator() {
+        willReturn(null).given(initializer).loadImpl(FooBarChildPlugin1.class);
+        FooBarChildPlugin2 expected = new FooBarChildPlugin2();
+        willReturn(expected).given(initializer).loadImpl(FooBarChildPlugin2.class);
+
+        // when
+        FooBar plugin = loader.loadPlugin(FooBarChildPlugin1.class, FooBarChildPlugin2.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    @Test
+    public void loads_default_plugin_inheritance_lowest_common_denominator() {
+        willReturn(null).given(initializer).loadImpl(FooBarChildPlugin1.class);
+        willReturn(null).given(initializer).loadImpl(FooBarChildPlugin2.class);
+        FooBarChildPlugin1 expected = new FooBarChildPlugin1();
+        willReturn(expected).given(plugins).getDefaultPlugin(FooBarChildPlugin1.class);
+
+        // when
+        FooBar plugin = loader.loadPlugin(FooBarChildPlugin1.class, FooBarChildPlugin2.class);
+
+        // then
+        assertSame(expected, plugin);
+    }
+
+    static class FooPlugin {}
+
+    static class BarPlugin {}
+
+    interface Foo {}
+
+    interface Bar {}
+
+    static class BarChildPlugin implements Bar {}
+
+    static class FooChildPlugin implements Foo {}
+
+    interface FooBar {}
+
+    static class FooBarChildPlugin1 implements FooBar {}
+
+    static class FooBarChildPlugin2 implements FooBar {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/AbstractMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/AbstractMockMakerTest.java
new file mode 100644
index 0000000000..d59477829a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/AbstractMockMakerTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation;
+
+import org.junit.Test;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockito.internal.stubbing.answers.CallsRealMethods;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
+import org.mockito.stubbing.Answer;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public abstract class AbstractMockMakerTest<MM extends MockMaker, C> {
+
+    protected final MM mockMaker;
+
+    private final Class<C> target;
+
+    protected AbstractMockMakerTest(MM mockMaker, Class<C> target) {
+        this.mockMaker = mockMaker;
+        this.target = target;
+    }
+
+    @Test
+    public void should_mocks_have_different_interceptors() throws Exception {
+        C mockOne = mockMaker.createMock(settingsFor(target), dummyHandler());
+        C mockTwo = mockMaker.createMock(settingsFor(target), dummyHandler());
+
+        MockHandler handlerOne = mockMaker.getHandler(mockOne);
+        MockHandler handlerTwo = mockMaker.getHandler(mockTwo);
+
+        assertThat(handlerOne).isNotSameAs(handlerTwo);
+    }
+
+    @Test
+    public void should_reset_mock_and_set_new_handler() throws Throwable {
+        MockCreationSettings<C> settings = settingsWithSuperCall(target);
+        C proxy = mockMaker.createMock(settings, new MockHandlerImpl<C>(settings));
+
+        MockHandler handler = new MockHandlerImpl<C>(settings);
+        mockMaker.resetMock(proxy, handler, settings);
+        assertThat(mockMaker.getHandler(proxy)).isSameAs(handler);
+    }
+
+    protected static <T> MockCreationSettings<T> settingsFor(
+            Class<T> type, Class<?>... extraInterfaces) {
+        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+        mockSettings.setTypeToMock(type);
+        if (extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
+        return mockSettings;
+    }
+
+    protected static <T> MockCreationSettings<T> serializableSettingsFor(
+            Class<T> type, SerializableMode serializableMode) {
+        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+        mockSettings.serializable(serializableMode);
+        mockSettings.setTypeToMock(type);
+        return mockSettings;
+    }
+
+    protected static <T> MockCreationSettings<T> settingsWithConstructorFor(Class<T> type) {
+        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+        mockSettings.setTypeToMock(type);
+        return mockSettings;
+    }
+
+    protected static <T> MockCreationSettings<T> settingsWithSuperCall(Class<T> type) {
+        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+        mockSettings.setTypeToMock(type);
+        mockSettings.defaultAnswer(new CallsRealMethods());
+        return mockSettings;
+    }
+
+    protected static MockHandler dummyHandler() {
+        return new DummyMockHandler();
+    }
+
+    private static class DummyMockHandler implements MockHandler<Object> {
+        public Object handle(Invocation invocation) throws Throwable {
+            return null;
+        }
+
+        public MockCreationSettings<Object> getMockSettings() {
+            return null;
+        }
+
+        public InvocationContainer getInvocationContainer() {
+            return null;
+        }
+
+        public void setAnswersForStubbing(List<Answer<?>> list) {}
+    }
+}
diff --git a/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java
rename to mockito-core/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java
diff --git a/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java
rename to mockito-core/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
new file mode 100644
index 0000000000..dc8af35423
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.VerboseMockInvocationLogger;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockitoutil.TestBase;
+
+public class MockSettingsImplTest extends TestBase {
+
+    private MockSettingsImpl<?> mockSettingsImpl = new MockSettingsImpl<Object>();
+
+    @Mock private InvocationListener invocationListener;
+    @Mock private StubbingLookupListener stubbingLookupListener;
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldNotAllowSettingNullInterface() {
+        assertThatThrownBy(
+                        () -> {
+                            mockSettingsImpl.extraInterfaces(List.class, null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("extraInterfaces() does not accept null parameters.");
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldNotAllowNonInterfaces() {
+        assertThatThrownBy(
+                        () -> {
+                            mockSettingsImpl.extraInterfaces(List.class, LinkedList.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "extraInterfaces() accepts only interfaces",
+                        "You passed following type: LinkedList which is not an interface.");
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldNotAllowUsingTheSameInterfaceAsExtra() {
+        assertThatThrownBy(
+                        () -> {
+                            mockSettingsImpl.extraInterfaces(List.class, LinkedList.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "extraInterfaces() accepts only interfaces.",
+                        "You passed following type: LinkedList which is not an interface.");
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldNotAllowEmptyExtraInterfaces() {
+        assertThatThrownBy(
+                        () -> {
+                            mockSettingsImpl.extraInterfaces();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("extraInterfaces() requires at least one interface.");
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldNotAllowNullArrayOfExtraInterfaces() {
+        assertThatThrownBy(
+                        () -> {
+                            mockSettingsImpl.extraInterfaces((Class<?>[]) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("extraInterfaces() requires at least one interface.");
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldAllowMultipleInterfaces() {
+        // when
+        mockSettingsImpl.extraInterfaces(List.class, Set.class);
+
+        // then
+        assertThat(mockSettingsImpl.getExtraInterfaces().size()).isEqualTo(2);
+        assertThat(mockSettingsImpl.getExtraInterfaces()).contains(List.class);
+        assertThat(mockSettingsImpl.getExtraInterfaces()).contains(Set.class);
+    }
+
+    @Test
+    public void shouldSetMockToBeSerializable() {
+        // when
+        mockSettingsImpl.serializable();
+
+        // then
+        assertThat(mockSettingsImpl.isSerializable()).isTrue();
+    }
+
+    @Test
+    public void shouldKnowIfIsSerializable() {
+        // given
+        assertThat(mockSettingsImpl.isSerializable()).isFalse();
+
+        // when
+        mockSettingsImpl.serializable();
+
+        // then
+        assertThat(mockSettingsImpl.isSerializable()).isTrue();
+    }
+
+    @Test
+    public void shouldAddVerboseLoggingListener() {
+        // given
+        assertThat(mockSettingsImpl.hasInvocationListeners()).isFalse();
+
+        // when
+        mockSettingsImpl.verboseLogging();
+
+        // then
+        assertThat(mockSettingsImpl.getInvocationListeners())
+                .extracting("class")
+                .contains(VerboseMockInvocationLogger.class);
+    }
+
+    @Test
+    public void shouldAddVerboseLoggingListenerOnlyOnce() {
+        // given
+        assertThat(mockSettingsImpl.hasInvocationListeners()).isFalse();
+
+        // when
+        mockSettingsImpl.verboseLogging().verboseLogging();
+
+        // then
+        assertThat(mockSettingsImpl.getInvocationListeners()).hasSize(1);
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldAddInvocationListener() {
+        // given
+        assertThat(mockSettingsImpl.hasInvocationListeners()).isFalse();
+
+        // when
+        mockSettingsImpl.invocationListeners(invocationListener);
+
+        // then
+        assertThat(mockSettingsImpl.getInvocationListeners()).contains(invocationListener);
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void canAddDuplicateInvocationListeners_ItsNotOurBusinessThere() {
+        // given
+        assertThat(mockSettingsImpl.hasInvocationListeners()).isFalse();
+
+        // when
+        mockSettingsImpl
+                .invocationListeners(invocationListener, invocationListener)
+                .invocationListeners(invocationListener);
+
+        // then
+        assertThat(mockSettingsImpl.getInvocationListeners())
+                .containsSequence(invocationListener, invocationListener, invocationListener);
+    }
+
+    @Test
+    public void validates_listeners() {
+        assertThatThrownBy(
+                        () ->
+                                mockSettingsImpl.addListeners(
+                                        new Object[] {}, new LinkedList<Object>(), "myListeners"))
+                .hasMessageContaining("myListeners() requires at least one listener");
+
+        assertThatThrownBy(
+                        () ->
+                                mockSettingsImpl.addListeners(
+                                        null, new LinkedList<Object>(), "myListeners"))
+                .hasMessageContaining("myListeners() does not accept null vararg array");
+
+        assertThatThrownBy(
+                        () ->
+                                mockSettingsImpl.addListeners(
+                                        new Object[] {null},
+                                        new LinkedList<Object>(),
+                                        "myListeners"))
+                .hasMessageContaining("myListeners() does not accept null listeners");
+    }
+
+    @Test
+    public void validates_stubbing_lookup_listeners() {
+        assertThatThrownBy(
+                        () ->
+                                mockSettingsImpl.stubbingLookupListeners(
+                                        new StubbingLookupListener[] {}))
+                .hasMessageContaining("stubbingLookupListeners() requires at least one listener");
+
+        assertThatThrownBy(() -> mockSettingsImpl.stubbingLookupListeners(null))
+                .hasMessageContaining(
+                        "stubbingLookupListeners() does not accept null vararg array");
+
+        assertThatThrownBy(
+                        () ->
+                                mockSettingsImpl.stubbingLookupListeners(
+                                        new StubbingLookupListener[] {null}))
+                .hasMessageContaining("stubbingLookupListeners() does not accept null listeners");
+    }
+
+    @Test
+    public void validates_invocation_listeners() {
+        assertThatThrownBy(() -> mockSettingsImpl.invocationListeners(new InvocationListener[] {}))
+                .hasMessageContaining("invocationListeners() requires at least one listener");
+
+        assertThatThrownBy(() -> mockSettingsImpl.invocationListeners(null))
+                .hasMessageContaining("invocationListeners() does not accept null vararg array");
+
+        assertThatThrownBy(
+                        () -> mockSettingsImpl.invocationListeners(new InvocationListener[] {null}))
+                .hasMessageContaining("invocationListeners() does not accept null listeners");
+    }
+
+    @Test
+    public void addListeners_has_empty_listeners_by_default() {
+        assertThat(mockSettingsImpl.getInvocationListeners()).isEmpty();
+        assertThat(mockSettingsImpl.getStubbingLookupListeners()).isEmpty();
+    }
+
+    @Test
+    public void addListeners_shouldAddMockObjectListeners() {
+        // when
+        mockSettingsImpl.invocationListeners(invocationListener);
+        mockSettingsImpl.stubbingLookupListeners(stubbingLookupListener);
+
+        // then
+        assertThat(mockSettingsImpl.getInvocationListeners()).contains(invocationListener);
+        assertThat(mockSettingsImpl.getStubbingLookupListeners()).contains(stubbingLookupListener);
+    }
+
+    @Test
+    public void addListeners_canAddDuplicateMockObjectListeners_ItsNotOurBusinessThere() {
+        // when
+        mockSettingsImpl
+                .stubbingLookupListeners(stubbingLookupListener)
+                .stubbingLookupListeners(stubbingLookupListener)
+                .invocationListeners(invocationListener)
+                .invocationListeners(invocationListener);
+
+        // then
+        assertThat(mockSettingsImpl.getInvocationListeners())
+                .containsSequence(invocationListener, invocationListener);
+        assertThat(mockSettingsImpl.getStubbingLookupListeners())
+                .containsSequence(stubbingLookupListener, stubbingLookupListener);
+    }
+
+    @Test
+    public void validates_strictness() {
+        assertThatThrownBy(() -> mockSettingsImpl.strictness(null))
+                .hasMessageContaining("strictness() does not accept null parameter");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
new file mode 100644
index 0000000000..93c8913ace
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockitoutil.ClassLoaders.coverageTool;
+
+import java.io.Serializable;
+
+import net.bytebuddy.ByteBuddy;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.creation.AbstractMockMakerTest;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
+import org.mockitoutil.ClassLoaders;
+import org.mockitoutil.SimpleSerializationUtil;
+import org.objenesis.ObjenesisStd;
+
+public abstract class AbstractByteBuddyMockMakerTest<MM extends MockMaker>
+        extends AbstractMockMakerTest<MM, AbstractByteBuddyMockMakerTest.SomeClass> {
+
+    protected AbstractByteBuddyMockMakerTest(MM mockMaker) {
+        super(mockMaker, SomeClass.class);
+    }
+
+    protected abstract Class<?> mockTypeOf(Class<?> type);
+
+    @Test
+    public void should_create_mock_from_interface() throws Exception {
+        SomeInterface proxy =
+                mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+        Class<?> superClass = proxy.getClass().getSuperclass();
+        assertThat(superClass).isEqualTo(Object.class);
+    }
+
+    @Test
+    public void should_create_mock_from_class() throws Exception {
+        ClassWithoutConstructor proxy =
+                mockMaker.createMock(settingsFor(ClassWithoutConstructor.class), dummyHandler());
+
+        Class<?> superClass = mockTypeOf(proxy.getClass());
+        assertThat(superClass).isEqualTo(ClassWithoutConstructor.class);
+    }
+
+    @Test
+    public void should_create_mock_from_class_even_when_constructor_is_dodgy() throws Exception {
+        try {
+            new ClassWithDodgyConstructor();
+            fail();
+        } catch (Exception expected) {
+        }
+
+        ClassWithDodgyConstructor mock =
+                mockMaker.createMock(settingsFor(ClassWithDodgyConstructor.class), dummyHandler());
+        assertThat(mock).isNotNull();
+    }
+
+    @Test
+    public void should_use_ancillary_Types() {
+        SomeClass mock =
+                mockMaker.createMock(
+                        settingsFor(SomeClass.class, SomeInterface.class), dummyHandler());
+
+        assertThat(mock).isInstanceOf(SomeInterface.class);
+    }
+
+    @Test
+    public void should_create_class_by_constructor() {
+        OtherClass mock =
+                mockMaker.createMock(settingsWithConstructorFor(OtherClass.class), dummyHandler());
+        assertThat(mock).isNotNull();
+    }
+
+    @Test
+    public void should_allow_serialization() throws Exception {
+        SerializableClass proxy =
+                mockMaker.createMock(
+                        serializableSettingsFor(SerializableClass.class, SerializableMode.BASIC),
+                        dummyHandler());
+
+        SerializableClass serialized = SimpleSerializationUtil.serializeAndBack(proxy);
+        assertThat(serialized).isNotNull();
+
+        MockHandler handlerOne = mockMaker.getHandler(proxy);
+        MockHandler handlerTwo = mockMaker.getHandler(serialized);
+
+        assertThat(handlerOne).isNotSameAs(handlerTwo);
+    }
+
+    @Test
+    public void should_create_mock_from_class_with_super_call_to_final_method() throws Exception {
+        MockCreationSettings<CallingSuperMethodClass> settings =
+                settingsWithSuperCall(CallingSuperMethodClass.class);
+        SampleClass proxy =
+                mockMaker.createMock(
+                        settings, new MockHandlerImpl<CallingSuperMethodClass>(settings));
+        assertThat(proxy.foo()).isEqualTo("foo");
+    }
+
+    class SomeClass {}
+
+    interface SomeInterface {}
+
+    static class OtherClass {}
+
+    static class SerializableClass implements Serializable {}
+
+    private class ClassWithoutConstructor {}
+
+    private class ClassWithDodgyConstructor {
+        public ClassWithDodgyConstructor() {
+            throw new RuntimeException();
+        }
+    }
+
+    @Test
+    public void instantiate_fine_when_objenesis_on_the_classpath() throws Exception {
+        // given
+        ClassLoader classpath_with_objenesis =
+                ClassLoaders.excludingClassLoader()
+                        .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, ObjenesisStd.class)
+                        .withCodeSourceUrlOf(coverageTool())
+                        .build();
+
+        Class<?> mock_maker_class_loaded_fine_until =
+                Class.forName(
+                        "org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker",
+                        true,
+                        classpath_with_objenesis);
+
+        // when
+        mock_maker_class_loaded_fine_until.getConstructor().newInstance();
+
+        // then everything went fine
+    }
+
+    private static class SampleClass {
+        public String foo() {
+            return "foo";
+        }
+    }
+
+    private static class CallingSuperMethodClass extends SampleClass {
+        @Override
+        public String foo() {
+            return super.foo();
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
similarity index 87%
rename from src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
rename to mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
index 8dfc4d5122..1a9eebec82 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
@@ -7,7 +7,6 @@
 import static org.mockito.Mockito.verify;
 
 import org.junit.Test;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.internal.creation.settings.CreationSettings;
 import org.mockito.internal.handler.MockHandlerImpl;
@@ -15,14 +14,12 @@
 
 public class ByteBuddyMockMakerTest extends TestBase {
 
-    @InjectMocks
-    private ByteBuddyMockMaker mockMaker = new ByteBuddyMockMaker();
-
-    @Mock
-    private ClassCreatingMockMaker delegate;
+    @Mock private SubclassByteBuddyMockMaker delegate;
 
     @Test
     public void should_delegate_call() {
+        ByteBuddyMockMaker mockMaker = new ByteBuddyMockMaker(delegate);
+
         CreationSettings<Object> creationSettings = new CreationSettings<Object>();
         MockHandlerImpl<Object> handler = new MockHandlerImpl<Object>(creationSettings);
 
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
new file mode 100644
index 0000000000..9069e50b85
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockitoutil.TestBase;
+
+import static org.mockito.Mockito.verify;
+
+public class InlineByteBuddyMockMakerTest extends TestBase {
+
+    @Mock private InlineDelegateByteBuddyMockMaker delegate;
+
+    @Test
+    public void should_delegate_call() {
+        InlineByteBuddyMockMaker mockMaker = new InlineByteBuddyMockMaker(delegate);
+
+        CreationSettings<Object> creationSettings = new CreationSettings<Object>();
+        MockHandlerImpl<Object> handler = new MockHandlerImpl<Object>(creationSettings);
+
+        mockMaker.createMockType(creationSettings);
+        mockMaker.createMock(creationSettings, handler);
+        mockMaker.createStaticMock(Object.class, creationSettings, handler);
+        mockMaker.createConstructionMock(Object.class, null, null, null);
+        mockMaker.getHandler(this);
+        mockMaker.isTypeMockable(Object.class);
+        mockMaker.resetMock(this, handler, creationSettings);
+        mockMaker.clearMock(this);
+        mockMaker.clearAllMocks();
+        mockMaker.clearAllCaches();
+
+        verify(delegate).createMock(creationSettings, handler);
+        verify(delegate).createStaticMock(Object.class, creationSettings, handler);
+        verify(delegate).createConstructionMock(Object.class, null, null, null);
+        verify(delegate).createMockType(creationSettings);
+        verify(delegate).getHandler(this);
+        verify(delegate).isTypeMockable(Object.class);
+        verify(delegate).resetMock(this, handler, creationSettings);
+        verify(delegate).clearMock(this);
+        verify(delegate).clearAllMocks();
+        verify(delegate).clearAllCaches();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
new file mode 100644
index 0000000000..19fc9ce581
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
@@ -0,0 +1,710 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.Assert.*;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.implementation.FixedValue;
+import net.bytebuddy.implementation.StubMethod;
+import net.bytebuddy.utility.JavaConstant;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.creation.bytebuddy.sample.DifferentPackage;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.framework.DisabledMockHandler;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.internal.util.collections.Sets;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
+
+public class InlineDelegateByteBuddyMockMakerTest
+        extends AbstractByteBuddyMockMakerTest<InlineByteBuddyMockMaker> {
+
+    public InlineDelegateByteBuddyMockMakerTest() {
+        super(new InlineByteBuddyMockMaker());
+    }
+
+    @Override
+    protected Class<?> mockTypeOf(Class<?> type) {
+        return type;
+    }
+
+    @Test
+    public void should_create_mock_from_final_class() throws Exception {
+        MockCreationSettings<FinalClass> settings = settingsFor(FinalClass.class);
+        FinalClass proxy =
+                mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
+        assertThat(proxy.foo()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_create_mock_from_final_spy() throws Exception {
+        MockCreationSettings<FinalSpy> settings = settingsFor(FinalSpy.class);
+        Optional<FinalSpy> proxy =
+                mockMaker.createSpy(
+                        settings,
+                        new MockHandlerImpl<>(settings),
+                        new FinalSpy("value", true, (byte) 1, (short) 1, (char) 1, 1, 1L, 1f, 1d));
+        assertThat(proxy)
+                .hasValueSatisfying(
+                        spy -> {
+                            assertThat(spy.aString).isEqualTo("value");
+                            assertThat(spy.aBoolean).isTrue();
+                            assertThat(spy.aByte).isEqualTo((byte) 1);
+                            assertThat(spy.aShort).isEqualTo((short) 1);
+                            assertThat(spy.aChar).isEqualTo((char) 1);
+                            assertThat(spy.anInt).isEqualTo(1);
+                            assertThat(spy.aLong).isEqualTo(1L);
+                            assertThat(spy.aFloat).isEqualTo(1f);
+                            assertThat(spy.aDouble).isEqualTo(1d);
+                        });
+    }
+
+    @Test
+    public void should_create_mock_from_accessible_inner_spy() throws Exception {
+        MockCreationSettings<Outer.Inner> settings = settingsFor(Outer.Inner.class);
+        Optional<Outer.Inner> proxy =
+                mockMaker.createSpy(
+                        settings,
+                        new MockHandlerImpl<>(settings),
+                        new Outer.Inner(new Object(), new Object()));
+        assertThat(proxy)
+                .hasValueSatisfying(
+                        spy -> {
+                            assertThat(spy.p1).isNotNull();
+                            assertThat(spy.p2).isNotNull();
+                        });
+    }
+
+    @Test
+    public void should_create_mock_from_visible_inner_spy() throws Exception {
+        MockCreationSettings<DifferentPackage> settings = settingsFor(DifferentPackage.class);
+        Optional<DifferentPackage> proxy =
+                mockMaker.createSpy(
+                        settings,
+                        new MockHandlerImpl<>(settings),
+                        new DifferentPackage(new Object(), new Object()));
+        assertThat(proxy)
+                .hasValueSatisfying(
+                        spy -> {
+                            assertThat(spy.p1).isNotNull();
+                            assertThat(spy.p2).isNotNull();
+                        });
+    }
+
+    @Test
+    public void should_create_mock_from_non_constructable_class() throws Exception {
+        MockCreationSettings<NonConstructableClass> settings =
+                settingsFor(NonConstructableClass.class);
+        NonConstructableClass proxy =
+                mockMaker.createMock(
+                        settings, new MockHandlerImpl<NonConstructableClass>(settings));
+        assertThat(proxy.foo()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_create_mock_from_final_class_in_the_JDK() throws Exception {
+        MockCreationSettings<Pattern> settings = settingsFor(Pattern.class);
+        Pattern proxy = mockMaker.createMock(settings, new MockHandlerImpl<Pattern>(settings));
+        assertThat(proxy.pattern()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_create_mock_from_abstract_class_with_final_method() throws Exception {
+        MockCreationSettings<FinalMethodAbstractType> settings =
+                settingsFor(FinalMethodAbstractType.class);
+        FinalMethodAbstractType proxy =
+                mockMaker.createMock(
+                        settings, new MockHandlerImpl<FinalMethodAbstractType>(settings));
+        assertThat(proxy.foo()).isEqualTo("bar");
+        assertThat(proxy.bar()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_create_mock_from_final_class_with_interface_methods() throws Exception {
+        MockCreationSettings<FinalMethod> settings =
+                settingsFor(FinalMethod.class, SampleInterface.class);
+        FinalMethod proxy =
+                mockMaker.createMock(settings, new MockHandlerImpl<FinalMethod>(settings));
+        assertThat(proxy.foo()).isEqualTo("bar");
+        assertThat(((SampleInterface) proxy).bar()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_detect_non_overridden_generic_method_of_supertype() throws Exception {
+        MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
+        GenericSubClass proxy =
+                mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+        assertThat(proxy.value()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_create_mock_from_hashmap() throws Exception {
+        MockCreationSettings<HashMap> settings = settingsFor(HashMap.class);
+        HashMap proxy = mockMaker.createMock(settings, new MockHandlerImpl<HashMap>(settings));
+        assertThat(proxy.get(null)).isEqualTo("bar");
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void should_throw_exception_redefining_unmodifiable_class() {
+        MockCreationSettings settings = settingsFor(int.class);
+        try {
+            mockMaker.createMock(settings, new MockHandlerImpl(settings));
+            fail("Expected a MockitoException");
+        } catch (MockitoException e) {
+            e.printStackTrace();
+            assertThat(e).hasMessageContaining("Could not modify all classes");
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void should_throw_exception_redefining_array() {
+        int[] array = new int[5];
+        MockCreationSettings<? extends int[]> settings = settingsFor(array.getClass());
+        try {
+            mockMaker.createMock(settings, new MockHandlerImpl(settings));
+            fail("Expected a MockitoException");
+        } catch (MockitoException e) {
+            assertThat(e).hasMessageContaining("Arrays cannot be mocked");
+        }
+    }
+
+    @Test
+    public void should_create_mock_from_enum() throws Exception {
+        MockCreationSettings<EnumClass> settings = settingsFor(EnumClass.class);
+        EnumClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<EnumClass>(settings));
+        assertThat(proxy.foo()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_fail_at_creating_a_mock_of_a_final_class_with_explicit_serialization()
+            throws Exception {
+        MockCreationSettings<FinalClass> settings =
+                new CreationSettings<FinalClass>()
+                        .setTypeToMock(FinalClass.class)
+                        .setSerializableMode(SerializableMode.BASIC);
+
+        try {
+            mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
+            fail("Expected a MockitoException");
+        } catch (MockitoException e) {
+            assertThat(e)
+                    .hasMessageContaining("Unsupported settings")
+                    .hasMessageContaining("serialization")
+                    .hasMessageContaining("extra interfaces");
+        }
+    }
+
+    @Test
+    public void should_fail_at_creating_a_mock_of_a_final_class_with_extra_interfaces()
+            throws Exception {
+        MockCreationSettings<FinalClass> settings =
+                new CreationSettings<FinalClass>()
+                        .setTypeToMock(FinalClass.class)
+                        .setExtraInterfaces(Sets.<Class<?>>newSet(List.class));
+
+        try {
+            mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
+            fail("Expected a MockitoException");
+        } catch (MockitoException e) {
+            assertThat(e)
+                    .hasMessageContaining("Unsupported settings")
+                    .hasMessageContaining("serialization")
+                    .hasMessageContaining("extra interfaces");
+        }
+    }
+
+    @Test
+    public void should_mock_interface() {
+        MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
+        mockSettings.setTypeToMock(Set.class);
+        mockSettings.defaultAnswer(new Returns(10));
+        Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
+
+        assertThat(proxy.size()).isEqualTo(10);
+    }
+
+    @Test
+    public void should_mock_interface_to_string() {
+        MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
+        mockSettings.setTypeToMock(Set.class);
+        mockSettings.defaultAnswer(new Returns("foo"));
+        Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
+
+        assertThat(proxy.toString()).isEqualTo("foo");
+    }
+
+    /**
+     * @see <a href="https://github.com/mockito/mockito/issues/2154">https://github.com/mockito/mockito/issues/2154</a>
+     */
+    @Test
+    public void should_mock_class_to_string() {
+        MockSettingsImpl<Object> mockSettings = new MockSettingsImpl<Object>();
+        mockSettings.setTypeToMock(Object.class);
+        mockSettings.defaultAnswer(new Returns("foo"));
+        Object proxy =
+                mockMaker.createMock(mockSettings, new MockHandlerImpl<Object>(mockSettings));
+
+        assertThat(proxy.toString()).isEqualTo("foo");
+    }
+
+    @Test
+    public void should_leave_causing_stack() throws Exception {
+        MockSettingsImpl<ExceptionThrowingClass> settings = new MockSettingsImpl<>();
+        settings.setTypeToMock(ExceptionThrowingClass.class);
+        settings.defaultAnswer(Answers.CALLS_REAL_METHODS);
+
+        Optional<ExceptionThrowingClass> proxy =
+                mockMaker.createSpy(
+                        settings, new MockHandlerImpl<>(settings), new ExceptionThrowingClass());
+
+        StackTraceElement[] returnedStack =
+                assertThrows(IOException.class, () -> proxy.get().throwException()).getStackTrace();
+
+        assertNotNull("Stack trace from mockito expected", returnedStack);
+
+        List<StackTraceElement> exceptionClassElements =
+                Arrays.stream(returnedStack)
+                        .filter(
+                                element ->
+                                        element.getClassName()
+                                                .equals(ExceptionThrowingClass.class.getName()))
+                        .collect(Collectors.toList());
+        assertEquals(3, exceptionClassElements.size());
+        assertEquals("internalThrowException", exceptionClassElements.get(0).getMethodName());
+        assertEquals("internalThrowException", exceptionClassElements.get(1).getMethodName());
+        assertEquals("throwException", exceptionClassElements.get(2).getMethodName());
+    }
+
+    @Test
+    public void should_leave_causing_stack_with_two_spies() throws Exception {
+        // given
+        MockSettingsImpl<ExceptionThrowingClass> settingsEx = new MockSettingsImpl<>();
+        settingsEx.setTypeToMock(ExceptionThrowingClass.class);
+        settingsEx.defaultAnswer(Answers.CALLS_REAL_METHODS);
+        Optional<ExceptionThrowingClass> proxyEx =
+                mockMaker.createSpy(
+                        settingsEx,
+                        new MockHandlerImpl<>(settingsEx),
+                        new ExceptionThrowingClass());
+
+        MockSettingsImpl<WrapperClass> settingsWr = new MockSettingsImpl<>();
+        settingsWr.setTypeToMock(WrapperClass.class);
+        settingsWr.defaultAnswer(Answers.CALLS_REAL_METHODS);
+        Optional<WrapperClass> proxyWr =
+                mockMaker.createSpy(
+                        settingsWr, new MockHandlerImpl<>(settingsWr), new WrapperClass());
+
+        // when
+        IOException ex =
+                assertThrows(IOException.class, () -> proxyWr.get().callWrapped(proxyEx.get()));
+        List<StackTraceElement> wrapperClassElements =
+                Arrays.stream(ex.getStackTrace())
+                        .filter(
+                                element ->
+                                        element.getClassName().equals(WrapperClass.class.getName()))
+                        .collect(Collectors.toList());
+
+        // then
+        assertEquals(1, wrapperClassElements.size());
+        assertEquals("callWrapped", wrapperClassElements.get(0).getMethodName());
+    }
+
+    @Test
+    public void should_remove_recursive_self_call_from_stack_trace() throws Exception {
+        StackTraceElement[] stack =
+                new StackTraceElement[] {
+                    new StackTraceElement("foo", "", "", -1),
+                    new StackTraceElement(SampleInterface.class.getName(), "", "", 15),
+                    new StackTraceElement("qux", "", "", -1),
+                    new StackTraceElement("bar", "", "", -1),
+                    new StackTraceElement(SampleInterface.class.getName(), "", "", 15),
+                    new StackTraceElement("baz", "", "", -1)
+                };
+
+        Throwable throwable = new Throwable();
+        throwable.setStackTrace(stack);
+        throwable = MockMethodAdvice.removeRecursiveCalls(throwable, SampleInterface.class);
+
+        assertThat(throwable.getStackTrace())
+                .isEqualTo(
+                        new StackTraceElement[] {
+                            new StackTraceElement("foo", "", "", -1),
+                            new StackTraceElement("qux", "", "", -1),
+                            new StackTraceElement("bar", "", "", -1),
+                            new StackTraceElement(SampleInterface.class.getName(), "", "", 15),
+                            new StackTraceElement("baz", "", "", -1)
+                        });
+    }
+
+    @Test
+    public void should_handle_missing_or_inconsistent_stack_trace() {
+        Throwable throwable = new Throwable();
+        throwable.setStackTrace(new StackTraceElement[0]);
+        assertThat(MockMethodAdvice.removeRecursiveCalls(throwable, SampleInterface.class))
+                .isSameAs(throwable);
+    }
+
+    @Test
+    public void should_provide_reason_for_wrapper_class() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Integer.class);
+        assertThat(mockable.nonMockableReason())
+                .isEqualTo("Cannot mock wrapper types, String.class or Class.class");
+    }
+
+    @Test
+    public void should_provide_reason_for_vm_unsupported() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int[].class);
+        assertThat(mockable.nonMockableReason())
+                .isEqualTo("VM does not support modification of given type");
+    }
+
+    @Test
+    public void should_mock_method_of_package_private_class() throws Exception {
+        MockCreationSettings<NonPackagePrivateSubClass> settings =
+                settingsFor(NonPackagePrivateSubClass.class);
+        NonPackagePrivateSubClass proxy =
+                mockMaker.createMock(
+                        settings, new MockHandlerImpl<NonPackagePrivateSubClass>(settings));
+        assertThat(proxy.value()).isEqualTo("bar");
+    }
+
+    @Test
+    public void is_type_mockable_excludes_String() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(String.class);
+        assertThat(mockable.mockable()).isFalse();
+        assertThat(mockable.nonMockableReason())
+                .contains("Cannot mock wrapper types, String.class or Class.class");
+    }
+
+    @Test
+    public void is_type_mockable_excludes_Class() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Class.class);
+        assertThat(mockable.mockable()).isFalse();
+        assertThat(mockable.nonMockableReason())
+                .contains("Cannot mock wrapper types, String.class or Class.class");
+    }
+
+    @Test
+    public void is_type_mockable_excludes_primitive_classes() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
+        assertThat(mockable.mockable()).isFalse();
+        assertThat(mockable.nonMockableReason()).contains("primitive");
+    }
+
+    @Test
+    public void is_type_mockable_allows_anonymous() {
+        Observer anonymous =
+                new Observer() {
+                    @Override
+                    public void update(Observable o, Object arg) {}
+                };
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
+        assertThat(mockable.mockable()).isTrue();
+        assertThat(mockable.nonMockableReason()).contains("");
+    }
+
+    @Test
+    public void is_type_mockable_give_empty_reason_if_type_is_mockable() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(SomeClass.class);
+        assertThat(mockable.mockable()).isTrue();
+        assertThat(mockable.nonMockableReason()).isEqualTo("");
+    }
+
+    @Test
+    public void is_type_mockable_give_allow_final_mockable_from_JDK() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Pattern.class);
+        assertThat(mockable.mockable()).isTrue();
+        assertThat(mockable.nonMockableReason()).isEqualTo("");
+    }
+
+    @Test
+    public void test_parameters_retention() throws Exception {
+        Class<?> typeWithParameters =
+                new ByteBuddy()
+                        .subclass(Object.class)
+                        .defineMethod("foo", void.class, Visibility.PUBLIC)
+                        .withParameter(String.class, "bar")
+                        .intercept(StubMethod.INSTANCE)
+                        .make()
+                        .load(null)
+                        .getLoaded();
+
+        MockCreationSettings<?> settings = settingsFor(typeWithParameters);
+        @SuppressWarnings("unchecked")
+        Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
+
+        assertThat(proxy.getClass()).isEqualTo(typeWithParameters);
+        assertThat(
+                        new TypeDescription.ForLoadedType(typeWithParameters)
+                                .getDeclaredMethods()
+                                .filter(named("foo"))
+                                .getOnly()
+                                .getParameters()
+                                .getOnly()
+                                .getName())
+                .isEqualTo("bar");
+    }
+
+    @Test
+    public void test_constant_dynamic_compatibility() throws Exception {
+        Class<?> typeWithCondy =
+                new ByteBuddy()
+                        .subclass(Callable.class)
+                        .method(named("call"))
+                        .intercept(FixedValue.value(JavaConstant.Dynamic.ofNullConstant()))
+                        .make()
+                        .load(null)
+                        .getLoaded();
+
+        MockCreationSettings<?> settings = settingsFor(typeWithCondy);
+        @SuppressWarnings("unchecked")
+        Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
+
+        assertThat(proxy.getClass()).isEqualTo(typeWithCondy);
+    }
+
+    @Test
+    public void test_clear_mock_clears_handler() {
+        MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
+        GenericSubClass proxy =
+                mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+        assertThat(mockMaker.getHandler(proxy)).isNotNull();
+
+        // when
+        mockMaker.clearMock(proxy);
+
+        // then
+        assertThat(mockMaker.getHandler(proxy)).isEqualTo(DisabledMockHandler.HANDLER);
+    }
+
+    @Test
+    public void test_clear_all_mock_assigns_disabled_handler() {
+        MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
+        GenericSubClass proxy1 =
+                mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+        assertThat(mockMaker.getHandler(proxy1)).isNotNull();
+
+        settings = settingsFor(GenericSubClass.class);
+        GenericSubClass proxy2 =
+                mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+        assertThat(mockMaker.getHandler(proxy1)).isNotNull();
+
+        // when
+        mockMaker.clearAllMocks();
+
+        // then
+        assertThat(mockMaker.getHandler(proxy1)).isEqualTo(DisabledMockHandler.HANDLER);
+        assertThat(mockMaker.getHandler(proxy2)).isEqualTo(DisabledMockHandler.HANDLER);
+    }
+
+    protected static <T> MockCreationSettings<T> settingsFor(
+            Class<T> type, Class<?>... extraInterfaces) {
+        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+        mockSettings.setTypeToMock(type);
+        mockSettings.defaultAnswer(new Returns("bar"));
+        if (extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
+        return mockSettings;
+    }
+
+    @Test
+    public void testMockDispatcherIsRelocated() {
+        assertThat(
+                        InlineByteBuddyMockMaker.class
+                                .getClassLoader()
+                                .getResource(
+                                        "org/mockito/internal/creation/bytebuddy/inject-MockMethodDispatcher.raw"))
+                .isNotNull();
+
+        assertThat(
+                        InlineByteBuddyMockMaker.class
+                                .getClassLoader()
+                                .getResource(
+                                        "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class"))
+                .isNull();
+    }
+
+    private static final class FinalClass {
+
+        public String foo() {
+            return "foo";
+        }
+    }
+
+    private static final class FinalSpy {
+
+        private final String aString;
+        private final boolean aBoolean;
+        private final byte aByte;
+        private final short aShort;
+        private final char aChar;
+        private final int anInt;
+        private final long aLong;
+        private final float aFloat;
+        private final double aDouble;
+
+        private FinalSpy(
+                String aString,
+                boolean aBoolean,
+                byte aByte,
+                short aShort,
+                char aChar,
+                int anInt,
+                long aLong,
+                float aFloat,
+                double aDouble) {
+            this.aString = aString;
+            this.aBoolean = aBoolean;
+            this.aByte = aByte;
+            this.aShort = aShort;
+            this.aChar = aChar;
+            this.anInt = anInt;
+            this.aLong = aLong;
+            this.aFloat = aFloat;
+            this.aDouble = aDouble;
+        }
+    }
+
+    private static class NonConstructableClass {
+
+        private NonConstructableClass() {
+            throw new AssertionError();
+        }
+
+        public String foo() {
+            return "foo";
+        }
+    }
+
+    private enum EnumClass {
+        INSTANCE;
+
+        public String foo() {
+            return "foo";
+        }
+    }
+
+    private abstract static class FinalMethodAbstractType {
+
+        public final String foo() {
+            return "foo";
+        }
+
+        public abstract String bar();
+    }
+
+    private static class FinalMethod {
+
+        public final String foo() {
+            return "foo";
+        }
+    }
+
+    private interface SampleInterface {
+
+        String bar();
+    }
+
+    /*package-private*/ abstract class PackagePrivateSuperClass {
+
+        public abstract String indirect();
+
+        public String value() {
+            return indirect() + "qux";
+        }
+    }
+
+    public class NonPackagePrivateSubClass extends PackagePrivateSuperClass {
+
+        @Override
+        public String indirect() {
+            return "foo";
+        }
+    }
+
+    public static class GenericClass<T> {
+
+        public T value() {
+            return null;
+        }
+    }
+
+    public static class WrapperClass {
+        public void callWrapped(ExceptionThrowingClass exceptionThrowingClass) throws IOException {
+            exceptionThrowingClass.throwException();
+        }
+    }
+
+    public static class GenericSubClass extends GenericClass<String> {}
+
+    public static class ExceptionThrowingClass {
+        public IOException getException() {
+            try {
+                throwException();
+            } catch (IOException ex) {
+                return ex;
+            }
+            return null;
+        }
+
+        public void throwException() throws IOException {
+            internalThrowException(1);
+        }
+
+        void internalThrowException(int test) throws IOException {
+            // some lines of code, so the exception is not thrown in the first line of the method
+            int i = 0;
+            if (test != i) {
+                throw new IOException("fatal");
+            }
+        }
+    }
+
+    static class Outer {
+
+        final Object p1;
+
+        private Outer(Object p1) {
+            this.p1 = p1;
+        }
+
+        private static class Inner extends Outer {
+
+            final Object p2;
+
+            Inner(Object p1, Object p2) {
+                super(p1);
+                this.p2 = p2;
+            }
+        }
+    }
+
+    public static class SamePackage {
+
+        public final Object p1;
+
+        protected SamePackage(Object p1) {
+            this.p1 = p1;
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/PlatformUtilsTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/PlatformUtilsTest.java
new file mode 100644
index 0000000000..ba2263715d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/PlatformUtilsTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import java.util.Properties;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.parallel.Isolated;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Ashley Scopes
+ */
+@Isolated("modifies system properties temporarily")
+class PlatformUtilsTest {
+    Properties globalProperties;
+
+    @BeforeEach
+    void setUp() {
+        globalProperties = new Properties();
+        globalProperties.putAll(System.getProperties());
+        System.getProperties().clear();
+    }
+
+    @AfterEach
+    void tearDown() {
+        System.getProperties().clear();
+        System.getProperties().putAll(globalProperties);
+    }
+
+    @CsvSource(
+            value = {
+                "java.specification.vendor, expected result",
+                "                  android,            true",
+                "                  AnDrOId,            true",
+                "             anythingElse,           false",
+                "                         ,           false",
+            },
+            useHeadersInDisplayName = true)
+    @ParameterizedTest
+    void isAndroidPlatform_returns_expected_value(String vendor, boolean result) {
+        // Given
+        setProperty("java.specification.vendor", vendor);
+
+        // Then
+        assertThat(PlatformUtils.isAndroidPlatform()).isEqualTo(result);
+    }
+
+    @CsvSource(
+            value = {
+                "      os.name,                      java.home, expected result",
+                "        linux, /data/data/com.termux/whatever,            true",
+                "        linux,    /foo/bar/com.termux/somedir,            true",
+                "        LINUX, /data/data/com.termux/whatever,            true",
+                "        Linux,    /foo/bar/com.termux/somedir,            true",
+                "Mac OS X 13.0,    /foo/bar/com.termux/somedir,           false",
+                "   Windows 10,    /foo/bar/com.termux/somedir,           false",
+                "         OS/2,    /foo/bar/com.termux/somedir,           false",
+                "        Linux,                /usr/share/java,           false",
+                "             ,                               ,           false",
+                "          foo,                               ,           false",
+                "             ,                            foo,           false",
+                "        linux,                               ,           false",
+                "             , /data/data/com.termux/whatever,           false",
+            },
+            useHeadersInDisplayName = true)
+    @ParameterizedTest
+    void isProbablyTermuxEnvironment_returns_expected_value(
+            String os, String javaHome, boolean result) {
+        // Given
+        setProperty("os.name", os);
+        setProperty("java.home", javaHome);
+
+        // Then
+        assertThat(PlatformUtils.isProbablyTermuxEnvironment()).isEqualTo(result);
+    }
+
+    static void setProperty(String name, String value) {
+        if (value == null) {
+            System.clearProperty(name);
+        } else {
+            System.setProperty(name, value);
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
new file mode 100644
index 0000000000..e6a0086c9f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.description.modifier.TypeManifestation;
+import net.bytebuddy.dynamic.DynamicType;
+import org.junit.Test;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.plugins.MockMaker;
+
+import java.io.Serializable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Observable;
+import java.util.Observer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SubclassByteBuddyMockMakerTest
+        extends AbstractByteBuddyMockMakerTest<SubclassByteBuddyMockMaker> {
+
+    public SubclassByteBuddyMockMakerTest() {
+        super(new SubclassByteBuddyMockMaker());
+    }
+
+    @Test
+    public void is_type_mockable_excludes_primitive_wrapper_classes() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Integer.class);
+        assertThat(mockable.mockable()).isFalse();
+        assertThat(mockable.nonMockableReason()).contains("final");
+    }
+
+    @Test
+    public void is_type_mockable_excludes_sealed_classes() {
+        if (ClassFileVersion.ofThisVm().isAtMost(ClassFileVersion.JAVA_V16)) {
+            return;
+        }
+        DynamicType.Builder<?> base = new ByteBuddy().subclass(Object.class);
+        DynamicType.Builder<?> subclass =
+                new ByteBuddy().subclass(base.toTypeDescription()).merge(TypeManifestation.FINAL);
+        Class<?> type =
+                base.permittedSubclass(subclass.toTypeDescription())
+                        .make()
+                        .include(subclass.make())
+                        .load(null)
+                        .getLoaded();
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(type);
+        assertThat(mockable.mockable()).isFalse();
+        assertThat(mockable.nonMockableReason()).contains("sealed");
+    }
+
+    @Test
+    public void is_type_mockable_excludes_primitive_classes() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
+        assertThat(mockable.mockable()).isFalse();
+        assertThat(mockable.nonMockableReason()).contains("primitive");
+    }
+
+    @Test
+    public void is_type_mockable_allow_anonymous() {
+        Observer anonymous =
+                new Observer() {
+                    @Override
+                    public void update(Observable o, Object arg) {}
+                };
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
+        assertThat(mockable.mockable()).isTrue();
+        assertThat(mockable.nonMockableReason()).contains("");
+    }
+
+    @Test
+    public void is_type_mockable_give_empty_reason_if_type_is_mockable() {
+        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(SomeClass.class);
+        assertThat(mockable.mockable()).isTrue();
+        assertThat(mockable.nonMockableReason()).isEqualTo("");
+    }
+
+    @Test
+    public void mock_class_with_annotations() throws Exception {
+        MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<>();
+        mockSettings.setTypeToMock(ClassWithAnnotation.class);
+
+        ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
+
+        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isTrue();
+        assertThat(proxy.getClass().getAnnotation(SampleAnnotation.class).value()).isEqualTo("foo");
+
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .isAnnotationPresent(SampleAnnotation.class))
+                .isTrue();
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .getAnnotation(SampleAnnotation.class)
+                                .value())
+                .isEqualTo("bar");
+    }
+
+    @Test
+    public void mock_class_with_annotations_with_additional_interface() throws Exception {
+        MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<>();
+        mockSettings.setTypeToMock(ClassWithAnnotation.class);
+        mockSettings.extraInterfaces(Serializable.class);
+
+        ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
+
+        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isTrue();
+        assertThat(proxy.getClass().getAnnotation(SampleAnnotation.class).value()).isEqualTo("foo");
+
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .isAnnotationPresent(SampleAnnotation.class))
+                .isTrue();
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .getAnnotation(SampleAnnotation.class)
+                                .value())
+                .isEqualTo("bar");
+    }
+
+    @Test
+    public void mock_interface_with_annotations() throws Exception {
+        MockSettingsImpl<InterfaceWithAnnotation> mockSettings = new MockSettingsImpl<>();
+        mockSettings.setTypeToMock(InterfaceWithAnnotation.class);
+
+        InterfaceWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
+
+        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isTrue();
+        assertThat(proxy.getClass().getAnnotation(SampleAnnotation.class).value()).isEqualTo("foo");
+
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .isAnnotationPresent(SampleAnnotation.class))
+                .isTrue();
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .getAnnotation(SampleAnnotation.class)
+                                .value())
+                .isEqualTo("bar");
+    }
+
+    @Test
+    public void mock_interface_with_annotations_with_additional_interface() throws Exception {
+        MockSettingsImpl<InterfaceWithAnnotation> mockSettings = new MockSettingsImpl<>();
+        mockSettings.setTypeToMock(InterfaceWithAnnotation.class);
+        mockSettings.extraInterfaces(Serializable.class);
+
+        InterfaceWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
+
+        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isFalse();
+
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .isAnnotationPresent(SampleAnnotation.class))
+                .isTrue();
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .getAnnotation(SampleAnnotation.class)
+                                .value())
+                .isEqualTo("bar");
+    }
+
+    @Test
+    public void mock_type_without_annotations() throws Exception {
+        MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<>();
+        mockSettings.setTypeToMock(ClassWithAnnotation.class);
+        mockSettings.withoutAnnotations();
+
+        ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
+
+        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isFalse();
+        assertThat(
+                        proxy.getClass()
+                                .getMethod("sampleMethod")
+                                .isAnnotationPresent(SampleAnnotation.class))
+                .isFalse();
+    }
+
+    @Override
+    protected Class<?> mockTypeOf(Class<?> type) {
+        return type.getSuperclass();
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface SampleAnnotation {
+
+        String value();
+    }
+
+    @SampleAnnotation("foo")
+    public static class ClassWithAnnotation {
+
+        @SampleAnnotation("bar")
+        public void sampleMethod() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @SampleAnnotation("foo")
+    public interface InterfaceWithAnnotation {
+
+        @SampleAnnotation("bar")
+        void sampleMethod();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
new file mode 100644
index 0000000000..56878b8cc8
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.internal.creation.bytebuddy.MockFeatures.withMockFeatures;
+import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
+import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Phaser;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.mock.SerializableMode;
+import org.mockitoutil.VmArgAssumptions;
+
+public class TypeCachingMockBytecodeGeneratorTest {
+
+    @Before
+    public void ensure_disable_gc_is_activated() throws Exception {
+        VmArgAssumptions.assumeVmArgNotPresent("-XX:+DisableExplicitGC");
+    }
+
+    @Test
+    public void ensure_cache_is_cleared_if_no_reference_to_classloader_and_classes()
+            throws Exception {
+        // given
+        ClassLoader classloader_with_life_shorter_than_cache =
+                inMemoryClassLoader()
+                        .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+                        .build();
+
+        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+                new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+
+        Class<?> the_mock_type =
+                cachingMockBytecodeGenerator.mockClass(
+                        withMockFeatures(
+                                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                Collections.<Class<?>>emptySet(),
+                                SerializableMode.NONE,
+                                false,
+                                Answers.RETURNS_DEFAULTS));
+
+        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
+        Reference<Object> typeReference =
+                new PhantomReference<Object>(the_mock_type, referenceQueue);
+
+        // when
+        classloader_with_life_shorter_than_cache = is_no_more_referenced();
+        the_mock_type = is_no_more_referenced();
+
+        System.gc();
+        ensure_gc_happened();
+
+        // then
+        assertThat(referenceQueue.poll()).isEqualTo(typeReference);
+    }
+
+    @Test
+    public void ensure_cache_returns_same_instance() throws Exception {
+        // given
+        ClassLoader classloader_with_life_shorter_than_cache =
+                inMemoryClassLoader()
+                        .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+                        .build();
+
+        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+                new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+        Class<?> the_mock_type =
+                cachingMockBytecodeGenerator.mockClass(
+                        withMockFeatures(
+                                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                Collections.<Class<?>>emptySet(),
+                                SerializableMode.NONE,
+                                false,
+                                Answers.RETURNS_DEFAULTS));
+
+        Class<?> other_mock_type =
+                cachingMockBytecodeGenerator.mockClass(
+                        withMockFeatures(
+                                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                Collections.<Class<?>>emptySet(),
+                                SerializableMode.NONE,
+                                false,
+                                Answers.RETURNS_DEFAULTS));
+
+        assertThat(other_mock_type).isSameAs(the_mock_type);
+
+        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
+        Reference<Object> typeReference =
+                new PhantomReference<Object>(the_mock_type, referenceQueue);
+
+        // when
+        classloader_with_life_shorter_than_cache = is_no_more_referenced();
+        the_mock_type = is_no_more_referenced();
+        other_mock_type = is_no_more_referenced();
+
+        System.gc();
+        ensure_gc_happened();
+
+        // then
+        assertThat(referenceQueue.poll()).isEqualTo(typeReference);
+    }
+
+    @Test
+    public void ensure_cache_returns_different_instance_serializableMode() throws Exception {
+        // given
+        ClassLoader classloader_with_life_shorter_than_cache =
+                inMemoryClassLoader()
+                        .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+                        .build();
+
+        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+                new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+        Class<?> the_mock_type =
+                cachingMockBytecodeGenerator.mockClass(
+                        withMockFeatures(
+                                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                Collections.<Class<?>>emptySet(),
+                                SerializableMode.NONE,
+                                false,
+                                Answers.RETURNS_DEFAULTS));
+
+        Class<?> other_mock_type =
+                cachingMockBytecodeGenerator.mockClass(
+                        withMockFeatures(
+                                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                Collections.<Class<?>>emptySet(),
+                                SerializableMode.BASIC,
+                                false,
+                                Answers.RETURNS_DEFAULTS));
+
+        assertThat(other_mock_type).isNotSameAs(the_mock_type);
+    }
+
+    @Test
+    public void ensure_cache_returns_same_instance_defaultAnswer() throws Exception {
+        // given
+        ClassLoader classloader_with_life_shorter_than_cache =
+                inMemoryClassLoader()
+                        .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+                        .build();
+
+        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+                new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+
+        Answers[] answers = Answers.values();
+        Set<Class<?>> classes = Collections.newSetFromMap(new IdentityHashMap<>());
+        classes.add(
+                cachingMockBytecodeGenerator.mockClass(
+                        withMockFeatures(
+                                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                Collections.<Class<?>>emptySet(),
+                                SerializableMode.NONE,
+                                false,
+                                null)));
+        for (Answers answer : answers) {
+            Class<?> klass =
+                    cachingMockBytecodeGenerator.mockClass(
+                            withMockFeatures(
+                                    classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+                                    Collections.<Class<?>>emptySet(),
+                                    SerializableMode.NONE,
+                                    false,
+                                    answer));
+            assertThat(classes.add(klass)).isFalse();
+        }
+
+        assertThat(classes).hasSize(1);
+    }
+
+    @Test
+    public void
+            validate_simple_code_idea_where_weakhashmap_with_classloader_as_key_get_GCed_when_no_more_references()
+                    throws Exception {
+        // given
+        WeakHashMap<ClassLoader, Object> cache = new WeakHashMap<ClassLoader, Object>();
+        ClassLoader short_lived_classloader =
+                inMemoryClassLoader()
+                        .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+                        .build();
+
+        cache.put(
+                short_lived_classloader,
+                new HoldingAReference(
+                        new WeakReference<Class<?>>(short_lived_classloader.loadClass("foo.Bar"))));
+
+        assertThat(cache).hasSize(1);
+
+        // when
+        short_lived_classloader = is_no_more_referenced();
+
+        System.gc();
+        ensure_gc_happened();
+
+        // then
+        assertThat(cache).isEmpty();
+    }
+
+    @Test
+    public void cacheLockingStressTest_same_hashcode_different_interface()
+            throws InterruptedException, TimeoutException {
+        Class<?>[] classes = cacheLockingInMemClassLoaderClasses();
+        Class<?> ifA = classes[0];
+        Class<?> ifB = classes[1];
+        var featA = newMockFeatures(ifA, ifB);
+        var featB = newMockFeatures(ifB, ifA);
+        cacheLockingStressTestImpl(featA, featB);
+    }
+
+    @Test
+    public void cacheLockingStressTest_same_hashcode_same_interface()
+            throws InterruptedException, TimeoutException {
+        Class<?>[] classes = cacheLockingInMemClassLoaderClasses();
+        Class<?> ifA = classes[0];
+        var featA = newMockFeatures(ifA);
+        cacheLockingStressTestImpl(featA, featA);
+    }
+
+    @Test
+    public void cacheLockingStressTest_different_hashcode()
+            throws InterruptedException, TimeoutException {
+        Class<?>[] classes = cacheLockingInMemClassLoaderClasses();
+        Class<?> ifA = classes[0];
+        Class<?> ifB = classes[1];
+        Class<?> ifC = classes[2];
+        var featA = newMockFeatures(ifA, ifB);
+        var featB = newMockFeatures(ifB, ifC);
+        cacheLockingStressTestImpl(featA, featB);
+    }
+
+    @Test
+    public void cacheLockingStressTest_unrelated_classes()
+            throws InterruptedException, TimeoutException {
+        Class<?>[] classes = cacheLockingInMemClassLoaderClasses();
+        Class<?> ifA = classes[0];
+        Class<?> ifB = classes[1];
+        var featA = newMockFeatures(ifA);
+        var featB = newMockFeatures(ifB);
+        cacheLockingStressTestImpl(featA, featB);
+    }
+
+    private void cacheLockingStressTestImpl(MockFeatures<?> featA, MockFeatures<?> featB)
+            throws InterruptedException, TimeoutException {
+        int iterations = 10_000;
+
+        TypeCachingBytecodeGenerator bytecodeGenerator =
+                new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+
+        Phaser phaser = new Phaser(4);
+        Function<Runnable, CompletableFuture<Void>> runCode =
+                code ->
+                        CompletableFuture.runAsync(
+                                () -> {
+                                    phaser.arriveAndAwaitAdvance();
+                                    try {
+                                        for (int i = 0; i < iterations; i++) {
+                                            code.run();
+                                        }
+                                    } finally {
+                                        phaser.arrive();
+                                    }
+                                });
+        var mockFeatAFuture =
+                runCode.apply(
+                        () -> {
+                            Class<?> mockClass = bytecodeGenerator.mockClass(featA);
+                            assertValidMockClass(featA, mockClass);
+                        });
+
+        var mockFeatBFuture =
+                runCode.apply(
+                        () -> {
+                            Class<?> mockClass = bytecodeGenerator.mockClass(featB);
+                            assertValidMockClass(featB, mockClass);
+                        });
+        var cacheFuture = runCode.apply(bytecodeGenerator::clearAllCaches);
+        // Start test
+        phaser.arriveAndAwaitAdvance();
+        // Wait for test to end
+        int phase = phaser.arrive();
+        try {
+
+            phaser.awaitAdvanceInterruptibly(phase, 30, TimeUnit.SECONDS);
+        } finally {
+            // Collect exceptions from the futures, to make issues visible.
+            mockFeatAFuture.getNow(null);
+            mockFeatBFuture.getNow(null);
+            cacheFuture.getNow(null);
+        }
+    }
+
+    private static <T> MockFeatures<T> newMockFeatures(
+            Class<T> mockedType, Class<?>... interfaces) {
+        return MockFeatures.withMockFeatures(
+                mockedType,
+                new HashSet<>(Arrays.asList(interfaces)),
+                SerializableMode.NONE,
+                false,
+                null);
+    }
+
+    private static Class<?>[] cacheLockingInMemClassLoaderClasses() {
+        ClassLoader inMemClassLoader =
+                inMemoryClassLoader()
+                        .withClassDefinition("foo.IfA", makeMarkerInterface("foo.IfA"))
+                        .withClassDefinition("foo.IfB", makeMarkerInterface("foo.IfB"))
+                        .withClassDefinition("foo.IfC", makeMarkerInterface("foo.IfC"))
+                        .build();
+        try {
+            return new Class[] {
+                inMemClassLoader.loadClass("foo.IfA"),
+                inMemClassLoader.loadClass("foo.IfB"),
+                inMemClassLoader.loadClass("foo.IfC")
+            };
+        } catch (ClassNotFoundException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private void assertValidMockClass(MockFeatures<?> mockFeature, Class<?> mockClass) {
+        assertThat(mockClass).isAssignableTo(mockFeature.mockedType);
+        for (Class<?> anInterface : mockFeature.interfaces) {
+            assertThat(mockClass).isAssignableTo(anInterface);
+        }
+    }
+
+    static class HoldingAReference {
+        final WeakReference<Class<?>> a;
+
+        HoldingAReference(WeakReference<Class<?>> a) {
+            this.a = a;
+        }
+    }
+
+    private static <T> T is_no_more_referenced() {
+        return null;
+    }
+
+    private static void ensure_gc_happened() throws InterruptedException {
+        // wait in order to make sure the GC happened
+        Thread.sleep(500);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/sample/DifferentPackage.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/sample/DifferentPackage.java
new file mode 100644
index 0000000000..9ae382ec5a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/sample/DifferentPackage.java
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy.sample;
+
+import org.mockito.internal.creation.bytebuddy.InlineDelegateByteBuddyMockMakerTest;
+
+public class DifferentPackage extends InlineDelegateByteBuddyMockMakerTest.SamePackage {
+
+    public final Object p2;
+
+    public DifferentPackage(Object p1, Object p2) {
+        super(p1);
+        this.p2 = p2;
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
new file mode 100644
index 0000000000..a498073128
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.instance;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+public class ConstructorInstantiatorTest extends TestBase {
+
+    static class SomeClass {}
+
+    class SomeInnerClass {}
+
+    class ChildOfThis extends ConstructorInstantiatorTest {}
+
+    static class SomeClass2 {
+
+        SomeClass2(String x) {}
+    }
+
+    static class SomeClass3 {
+
+        SomeClass3(int i) {}
+    }
+
+    @Test
+    public void creates_instances() {
+        assertThat(
+                        new ConstructorInstantiator(false, new Object[0])
+                                .newInstance(SomeClass.class)
+                                .getClass())
+                .isEqualTo(SomeClass.class);
+    }
+
+    @Test
+    public void creates_instances_of_inner_classes() {
+        assertThat(
+                        new ConstructorInstantiator(true, this)
+                                .newInstance(SomeInnerClass.class)
+                                .getClass())
+                .isEqualTo(SomeInnerClass.class);
+        assertThat(
+                        new ConstructorInstantiator(true, new ChildOfThis())
+                                .newInstance(SomeInnerClass.class)
+                                .getClass())
+                .isEqualTo(SomeInnerClass.class);
+    }
+
+    @Test
+    public void creates_instances_with_arguments() {
+        assertThat(
+                        new ConstructorInstantiator(false, "someString")
+                                .newInstance(SomeClass2.class)
+                                .getClass())
+                .isEqualTo(SomeClass2.class);
+    }
+
+    @Test
+    public void creates_instances_with_null_arguments() {
+        assertThat(
+                        new ConstructorInstantiator(false, new Object[] {null})
+                                .newInstance(SomeClass2.class)
+                                .getClass())
+                .isEqualTo(SomeClass2.class);
+    }
+
+    @Test
+    public void creates_instances_with_primitive_arguments() {
+        assertThat(new ConstructorInstantiator(false, 123).newInstance(SomeClass3.class).getClass())
+                .isEqualTo(SomeClass3.class);
+    }
+
+    @Test
+    public void fails_when_null_is_passed_for_a_primitive() {
+        assertThatThrownBy(
+                        () -> {
+                            new ConstructorInstantiator(false, new Object[] {null})
+                                    .newInstance(SomeClass3.class)
+                                    .getClass();
+                        })
+                .isInstanceOf(org.mockito.creation.instance.InstantiationException.class)
+                .hasMessageContaining("Unable to create instance of 'SomeClass3'.");
+    }
+
+    @Test
+    public void explains_when_constructor_cannot_be_found() {
+        try {
+            new ConstructorInstantiator(false, new Object[0]).newInstance(SomeClass2.class);
+            fail();
+        } catch (org.mockito.creation.instance.InstantiationException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "Unable to create instance of 'SomeClass2'.\n"
+                                    + "Please ensure that the target class has a 0-arg constructor.");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/proxy/ProxyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/proxy/ProxyMockMakerTest.java
new file mode 100644
index 0000000000..fd6009dae3
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/proxy/ProxyMockMakerTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.junit.Test;
+import org.mockito.internal.creation.AbstractMockMakerTest;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ProxyMockMakerTest
+        extends AbstractMockMakerTest<ProxyMockMaker, ProxyMockMakerTest.SomeInterface> {
+
+    public ProxyMockMakerTest() {
+        super(new ProxyMockMaker(), SomeInterface.class);
+    }
+
+    @Test
+    public void should_create_mock_from_interface() {
+        SomeInterface proxy =
+                mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+        Class<?> superClass = proxy.getClass().getSuperclass();
+        assertThat(superClass).isEqualTo(Proxy.class);
+    }
+
+    @Test
+    public void should_create_mock_from_interface_with_extra_interface() {
+        SomeInterface proxy =
+                mockMaker.createMock(
+                        settingsFor(SomeInterface.class, Serializable.class), dummyHandler());
+
+        Class<?> superClass = proxy.getClass().getSuperclass();
+        assertThat(superClass).isEqualTo(Proxy.class);
+        assertThat(proxy).isInstanceOf(Serializable.class);
+    }
+
+    @Test
+    public void should_discover_mockable_input() {
+        assertThat(mockMaker.isTypeMockable(Number.class).mockable()).isFalse();
+        assertThat(mockMaker.isTypeMockable(Number.class).nonMockableReason())
+                .isEqualTo("non-interface");
+        assertThat(mockMaker.isTypeMockable(SomeInterface.class).mockable()).isTrue();
+        assertThat(mockMaker.isTypeMockable(Object.class).mockable()).isTrue();
+    }
+
+    @Test
+    public void can_compute_hash_code() throws Throwable {
+        SomeInterface proxy =
+                mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+        InvocationHandler handler = Proxy.getInvocationHandler(proxy);
+
+        assertThat(handler.invoke(proxy, Object.class.getMethod("hashCode"), null))
+                .isEqualTo(System.identityHashCode(proxy));
+    }
+
+    @Test
+    public void can_compute_equality() throws Throwable {
+        SomeInterface proxy =
+                mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+        InvocationHandler handler = Proxy.getInvocationHandler(proxy);
+
+        assertThat(
+                        handler.invoke(
+                                proxy,
+                                Object.class.getMethod("equals", Object.class),
+                                new Object[] {proxy}))
+                .isEqualTo(true);
+        assertThat(
+                        handler.invoke(
+                                proxy,
+                                Object.class.getMethod("equals", Object.class),
+                                new Object[] {null}))
+                .isEqualTo(false);
+        assertThat(
+                        handler.invoke(
+                                proxy,
+                                Object.class.getMethod("equals", Object.class),
+                                new Object[] {new Object()}))
+                .isEqualTo(false);
+    }
+
+    @Test
+    public void can_invoke_toString() throws Throwable {
+        SomeInterface proxy =
+                mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+        InvocationHandler handler = Proxy.getInvocationHandler(proxy);
+
+        assertThat(handler.invoke(proxy, Object.class.getMethod("toString"), null)).isNull();
+    }
+
+    interface SomeInterface {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java b/mockito-core/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
new file mode 100644
index 0000000000..a81aa98d2f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockitoutil.TestBase;
+
+public class LoggingListenerTest extends TestBase {
+
+    @Test
+    public void may_not_have_any_information() {
+        // given
+        LoggingListener listener = new LoggingListener(true);
+
+        // expect
+        assertEquals("", listener.getStubbingInfo());
+    }
+
+    @Test
+    public void informs_about_unused_stubs() {
+        // given
+        LoggingListener listener = new LoggingListener(false);
+
+        // when
+        listener.foundUnusedStub(invocationAt("at com.FooTest:30"));
+        listener.foundUnusedStub(invocationAt("at com.FooTest:32"));
+
+        // then
+        assertEquals(
+                "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] 1. at com.FooTest:30\n"
+                        + "[Mockito] 2. at com.FooTest:32",
+                listener.getStubbingInfo());
+    }
+
+    @Test
+    public void calculates_indexes_for_clean_output() {
+        assertEquals(1, LoggingListener.indexOfNextPair(0));
+        assertEquals(2, LoggingListener.indexOfNextPair(2));
+        assertEquals(3, LoggingListener.indexOfNextPair(4));
+        assertEquals(4, LoggingListener.indexOfNextPair(6));
+    }
+
+    @Test
+    public void informs_about_unused_stubs_due_arg_mismatch() {
+        // given
+        LoggingListener listener = new LoggingListener(false);
+
+        // when
+        listener.foundStubCalledWithDifferentArgs(
+                invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
+        listener.foundStubCalledWithDifferentArgs(
+                invocationAt("at com.FooTest:21"), invocationMatcherAt("at com.Foo:121"));
+
+        // then
+        assertEquals(
+                "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] 1. Stubbed at com.FooTest:20\n"
+                        + "[Mockito]    Invoked at com.Foo:100\n"
+                        + "[Mockito] 2. Stubbed at com.FooTest:21\n"
+                        + "[Mockito]    Invoked at com.Foo:121",
+                listener.getStubbingInfo());
+    }
+
+    @Test
+    public void informs_about_various_kinds_of_stubs() {
+        // given
+        LoggingListener listener = new LoggingListener(true);
+
+        // when
+        listener.foundUnusedStub(invocationAt("at com.FooTest:30"));
+        listener.foundStubCalledWithDifferentArgs(
+                invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
+        listener.foundUnstubbed(invocationMatcherAt("at com.Foo:96"));
+
+        // then
+        assertEquals(
+                "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] 1. Stubbed at com.FooTest:20\n"
+                        + "[Mockito]    Invoked at com.Foo:100\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] 1. at com.FooTest:30\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] Un-stubbed method invocations (perhaps missing stubbing in the test?):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] 1. at com.Foo:96",
+                listener.getStubbingInfo());
+    }
+
+    @Test
+    public void hides_unstubbed() {
+        // given
+        LoggingListener listener = new LoggingListener(false);
+
+        // when
+        listener.foundUnstubbed(new InvocationBuilder().toInvocationMatcher());
+
+        // then
+        assertEquals("", listener.getStubbingInfo());
+    }
+
+    @Test
+    public void informs_about_unstubbed() {
+        // given
+        LoggingListener listener = new LoggingListener(true);
+
+        // when
+        listener.foundUnstubbed(invocationMatcherAt("com.Foo:20"));
+
+        // then
+        assertEquals(
+                "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] Un-stubbed method invocations (perhaps missing stubbing in the test?):\n"
+                        + "[Mockito]\n"
+                        + "[Mockito] 1. com.Foo:20",
+                listener.getStubbingInfo());
+    }
+}
diff --git a/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java b/mockito-core/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
similarity index 86%
rename from src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
rename to mockito-core/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
index 6b722f4729..2fb7a0ddb4 100644
--- a/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
@@ -57,7 +57,8 @@ public void should_print_invocation_with_return_value() {
     @Test
     public void should_print_invocation_with_exception() {
         // when
-        listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+        listener.reportInvocation(
+                new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
 
         // then
         assertThat(printed())
@@ -87,13 +88,16 @@ public void should_print_stubbed_info_if_available() throws Exception {
     @Test
     public void should_log_count_of_interactions() {
         // when & then
-        listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+        listener.reportInvocation(
+                new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
         assertThat(printed()).contains("#1");
 
-        listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+        listener.reportInvocation(
+                new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
         assertThat(printed()).contains("#2");
 
-        listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+        listener.reportInvocation(
+                new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
         assertThat(printed()).contains("#3");
     }
 
diff --git a/mockito-core/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java b/mockito-core/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
new file mode 100644
index 0000000000..c8fd02fb2d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.debugging;
+
+import static java.util.Arrays.asList;
+
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.invocation.Invocation;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class WarningsFinderTest extends TestBase {
+
+    @Mock private IMethods mock;
+    @Mock private FindingsListener listener;
+
+    @Test
+    public void shouldPrintUnusedStub() {
+        // given
+        Invocation unusedStub = new InvocationBuilder().simpleMethod().toInvocation();
+
+        // when
+        WarningsFinder finder =
+                new WarningsFinder(asList(unusedStub), Arrays.<InvocationMatcher>asList());
+        finder.find(listener);
+
+        // then
+        verify(listener, only()).foundUnusedStub(unusedStub);
+    }
+
+    @Test
+    public void shouldPrintUnstubbedInvocation() {
+        // given
+        InvocationMatcher unstubbedInvocation =
+                new InvocationBuilder().differentMethod().toInvocationMatcher();
+
+        // when
+        WarningsFinder finder =
+                new WarningsFinder(
+                        Arrays.<Invocation>asList(),
+                        Arrays.<InvocationMatcher>asList(unstubbedInvocation));
+        finder.find(listener);
+
+        // then
+        verify(listener, only()).foundUnstubbed(unstubbedInvocation);
+    }
+
+    @Test
+    public void shouldPrintStubWasUsedWithDifferentArgs() {
+        // given
+        Invocation stub = new InvocationBuilder().arg("foo").mock(mock).toInvocation();
+        InvocationMatcher wrongArg =
+                new InvocationBuilder().arg("bar").mock(mock).toInvocationMatcher();
+
+        // when
+        WarningsFinder finder =
+                new WarningsFinder(
+                        Arrays.<Invocation>asList(stub),
+                        Arrays.<InvocationMatcher>asList(wrongArg));
+        finder.find(listener);
+
+        // then
+        verify(listener, only()).foundStubCalledWithDifferentArgs(stub, wrongArg);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/exceptions/ReporterTest.java b/mockito-core/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
new file mode 100644
index 0000000000..9e4ca2381a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.exceptions;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.invocation.Invocation;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class ReporterTest extends TestBase {
+
+    @Test
+    public void should_let_passing_null_last_actual_stack_trace() {
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.tooFewActualInvocations(
+                                    new org.mockito.internal.reporting.Discrepancy(1, 2),
+                                    new InvocationBuilder().toInvocation(),
+                                    null);
+                        })
+                .isInstanceOf(TooFewActualInvocations.class)
+                .hasMessageContainingAll(
+                        "iMethods.simpleMethod();", "Wanted 1 time:", "But was 2 times:");
+    }
+
+    @Test
+    public void should_throw_correct_exception_for_null_invocation_listener() {
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.methodDoesNotAcceptParameter(
+                                    "invocationListeners", "null vararg array");
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage(
+                        "invocationListeners() does not accept null vararg array See the Javadoc.");
+    }
+
+    @Test
+    public void
+            can_use_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted() {
+        Invocation invocation_with_bogus_default_answer =
+                new InvocationBuilder()
+                        .mock(mock(IMethods.class, new Returns(false)))
+                        .toInvocation();
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.noMoreInteractionsWanted(
+                                    invocation_with_bogus_default_answer,
+                                    Collections.<VerificationAwareInvocation>emptyList());
+                        })
+                .isInstanceOf(NoInteractionsWanted.class)
+                .hasMessageContainingAll(
+                        "No interactions wanted here:",
+                        "But found this interaction on mock 'iMethods':");
+    }
+
+    @Test
+    public void
+            can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted_in_order() {
+        Invocation invocation_with_bogus_default_answer =
+                new InvocationBuilder()
+                        .mock(mock(IMethods.class, new Returns(false)))
+                        .toInvocation();
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.noMoreInteractionsWantedInOrder(
+                                    invocation_with_bogus_default_answer);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "No interactions wanted here:",
+                        "But found this interaction on mock 'iMethods':");
+    }
+
+    @Test
+    public void
+            can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_invalid_argument_position() {
+        Invocation invocation_with_bogus_default_answer =
+                new InvocationBuilder()
+                        .mock(mock(IMethods.class, new Returns(false)))
+                        .toInvocation();
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.invalidArgumentPositionRangeAtInvocationTime(
+                                    invocation_with_bogus_default_answer, true, 0);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Invalid argument index for the current invocation of method :",
+                        " -> iMethods.simpleMethod()",
+                        "Last parameter wanted but the method has no arguments.");
+    }
+
+    @Test
+    public void
+            can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_wrong_argument_to_return() {
+        Invocation invocation_with_bogus_default_answer =
+                new InvocationBuilder()
+                        .mock(mock(IMethods.class, new Returns(false)))
+                        .toInvocation();
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.wrongTypeOfArgumentToReturn(
+                                    invocation_with_bogus_default_answer, "", String.class, 0);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "The argument of type 'String' cannot be returned because the following",
+                        "method should return the type ''",
+                        " -> iMethods.simpleMethod()",
+                        "The reason for this error can be :",
+                        "1. The wanted argument position is incorrect.",
+                        "2. The answer is used on the wrong interaction.",
+                        "Position of the wanted argument is 0 and the method has no arguments.");
+    }
+
+    @Test
+    public void
+            can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_dont_exists() {
+        Invocation dumb_invocation = new InvocationBuilder().toInvocation();
+        IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.delegatedMethodDoesNotExistOnDelegate(
+                                    dumb_invocation.getMethod(),
+                                    mock_with_bogus_default_answer,
+                                    String.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Methods called on mock must exist in delegated instance.",
+                        "When calling: public abstract java.lang.String org.mockitousage.IMethods.simpleMethod() on mock: iMethods",
+                        "no such method was found.",
+                        "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
+                        "(delegate instance had type: Class)");
+    }
+
+    @Test
+    public void
+            can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_has_wrong_return_type() {
+        Invocation dumb_invocation = new InvocationBuilder().toInvocation();
+        IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.delegatedMethodHasWrongReturnType(
+                                    dumb_invocation.getMethod(),
+                                    dumb_invocation.getMethod(),
+                                    mock_with_bogus_default_answer,
+                                    String.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Methods called on delegated instance must have compatible return types with the mock.",
+                        "When calling: public abstract java.lang.String org.mockitousage.IMethods.simpleMethod() on mock: iMethods",
+                        "return type should be: String, but was: String",
+                        "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
+                        "(delegate instance had type: Class)");
+    }
+
+    @Test
+    public void
+            can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_injection_failure() {
+        IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
+
+        assertThatThrownBy(
+                        () -> {
+                            throw Reporter.cannotInjectDependency(
+                                    someField(), mock_with_bogus_default_answer, new Exception());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Mockito couldn't inject mock dependency 'iMethods' on field",
+                        "'static final org.mockito.internal.MockitoCore org.mockito.Mockito.MOCKITO_CORE'",
+                        "whose type 'org.mockito.Mockito' was annotated by @InjectMocks in your test.",
+                        "Also I failed because: null");
+    }
+
+    private Field someField() {
+        return Mockito.class.getDeclaredFields()[0];
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java b/mockito-core/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
new file mode 100644
index 0000000000..064bca5e54
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.exceptions.stacktrace;
+
+import static org.mockitoutil.Conditions.onlyThoseClassesInStackTrace;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.TraceBuilder;
+import org.mockito.internal.configuration.ConfigurationAccess;
+import org.mockitoutil.TestBase;
+
+public class ConditionalStackTraceFilterTest extends TestBase {
+
+    private ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
+
+    @Test
+    public void shouldNotFilterWhenConfigurationSaysNo() {
+        ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
+
+        Throwable t =
+                new TraceBuilder()
+                        .classes("org.test.MockitoSampleTest", "org.mockito.Mockito")
+                        .toThrowable();
+
+        filter.filter(t);
+
+        Assertions.assertThat(t)
+                .has(
+                        onlyThoseClassesInStackTrace(
+                                "org.mockito.Mockito", "org.test.MockitoSampleTest"));
+    }
+
+    @Test
+    public void shouldFilterWhenConfigurationSaysYes() {
+        ConfigurationAccess.getConfig().overrideCleansStackTrace(true);
+
+        Throwable t =
+                new TraceBuilder()
+                        .classes("org.test.MockitoSampleTest", "org.mockito.Mockito")
+                        .toThrowable();
+
+        filter.filter(t);
+
+        Assertions.assertThat(t).has(onlyThoseClassesInStackTrace("org.test.MockitoSampleTest"));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java b/mockito-core/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
new file mode 100644
index 0000000000..589c03cbf2
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.exceptions.stacktrace;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockitoutil.Conditions.onlyThoseClasses;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.TraceBuilder;
+import org.mockitoutil.TestBase;
+
+public class StackTraceFilterTest extends TestBase {
+
+    private final StackTraceFilter filter = new StackTraceFilter();
+
+    @Test
+    public void shouldFilterOutCglibGarbage() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes("MockitoExampleTest", "List$$EnhancerByMockitoWithCGLIB$$2c406024")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest"));
+    }
+
+    @Test
+    public void shouldFilterOutByteBuddyGarbage() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "MockitoExampleTest",
+                                "org.testcase.MockedClass$MockitoMock$1882975947.doSomething(Unknown Source)")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest"));
+    }
+
+    @Test
+    public void shouldFilterOutMockitoPackage() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes("org.test.MockitoSampleTest", "org.mockito.Mockito")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest"));
+    }
+
+    @Test
+    public void shouldNotFilterOutTracesMiddleGoodTraces() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "org.test.MockitoSampleTest",
+                                "org.test.TestSupport",
+                                "org.mockito.Mockito",
+                                "org.test.TestSupport",
+                                "org.mockito.Mockito")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered)
+                .has(
+                        onlyThoseClasses(
+                                "org.test.TestSupport",
+                                "org.test.TestSupport",
+                                "org.test.MockitoSampleTest"));
+    }
+
+    @Test
+    public void shouldKeepRunners() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "org.mockito.runners.Runner",
+                                "junit.stuff",
+                                "org.test.MockitoSampleTest",
+                                "org.mockito.Mockito")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered)
+                .has(
+                        onlyThoseClasses(
+                                "org.test.MockitoSampleTest",
+                                "junit.stuff",
+                                "org.mockito.runners.Runner"));
+    }
+
+    @Test
+    public void shouldNotFilterElementsAboveMockitoJUnitRule() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)",
+                                "org.mockito.runners.Runner",
+                                "junit.stuff",
+                                "org.test.MockitoSampleTest",
+                                "org.mockito.internal.MockitoCore.verifyNoMoreInteractions",
+                                "org.mockito.internal.debugging.LocationImpl")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered)
+                .has(
+                        onlyThoseClasses(
+                                "org.test.MockitoSampleTest",
+                                "junit.stuff",
+                                "org.mockito.runners.Runner",
+                                "org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)"));
+    }
+
+    @Test
+    public void shouldKeepInternalRunners() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "org.mockito.internal.runners.Runner", "org.test.MockitoSampleTest")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, false);
+
+        Assertions.assertThat(filtered)
+                .has(
+                        onlyThoseClasses(
+                                "org.test.MockitoSampleTest",
+                                "org.mockito.internal.runners.Runner"));
+    }
+
+    @Test
+    public void shouldStartFilteringAndKeepTop() {
+        // given
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "org.test.Good",
+                                "org.mockito.internal.Bad",
+                                "org.test.MockitoSampleTest")
+                        .toTraceArray();
+
+        // when
+        StackTraceElement[] filtered = filter.filter(t, true);
+
+        // then
+        Assertions.assertThat(filtered)
+                .has(onlyThoseClasses("org.test.MockitoSampleTest", "org.test.Good"));
+    }
+
+    @Test
+    public void
+            shouldKeepGoodTraceFromTheTopBecauseRealImplementationsOfSpiesSometimesThrowExceptions() {
+        StackTraceElement[] t =
+                new TraceBuilder()
+                        .classes(
+                                "org.good.Trace",
+                                "org.yet.another.good.Trace",
+                                "org.mockito.internal.to.be.Filtered",
+                                "org.test.MockitoSampleTest")
+                        .toTraceArray();
+
+        StackTraceElement[] filtered = filter.filter(t, true);
+
+        Assertions.assertThat(filtered)
+                .has(
+                        onlyThoseClasses(
+                                "org.test.MockitoSampleTest",
+                                "org.yet.another.good.Trace",
+                                "org.good.Trace"));
+    }
+
+    @Test
+    public void shouldReturnEmptyArrayWhenInputIsEmpty() throws Exception {
+        // when
+        StackTraceElement[] filtered = filter.filter(new StackTraceElement[0], false);
+        // then
+        assertEquals(0, filtered.length);
+    }
+}
diff --git a/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java b/mockito-core/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
similarity index 86%
rename from src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
rename to mockito-core/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
index 3a897d164e..68df19372f 100644
--- a/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
@@ -22,28 +22,26 @@ public class ScenarioPrinterTest extends TestBase {
 
     @Test
     public void shouldPrintInvocations() {
-        //given
+        // given
         Invocation verified = new InvocationBuilder().simpleMethod().verified().toInvocation();
         Invocation unverified = new InvocationBuilder().differentMethod().toInvocation();
 
-        //when
+        // when
         String out = sp.print((List) asList(verified, unverified));
 
-        //then
-        assertThat(out)
-            .contains("1. -> at")
-            .contains("2. [?]-> at");
+        // then
+        assertThat(out).contains("1. -> at").contains("2. [?]-> at");
     }
 
     @Test
     public void shouldNotPrintInvocationsWhenSingleUnwanted() {
-        //given
+        // given
         Invocation unverified = new InvocationBuilder().differentMethod().toInvocation();
 
-        //when
+        // when
         String out = sp.print((List) asList(unverified));
 
-        //then
+        // then
         assertThat(out).contains("Actually, above is the only interaction with this mock.");
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java b/mockito-core/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
new file mode 100644
index 0000000000..a352629264
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.framework;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+import static org.mockitoutil.ThrowableAssert.assertThat;
+
+import java.util.List;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.platform.commons.util.Preconditions;
+import org.mockito.ArgumentMatchers;
+import org.mockito.MockSettings;
+import org.mockito.MockedStatic;
+import org.mockito.StateMaster;
+import org.mockito.exceptions.misusing.DisabledMockException;
+import org.mockito.exceptions.misusing.RedundantListenerException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.listeners.MockCreationListener;
+import org.mockito.listeners.MockitoListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InlineMockMaker;
+import org.mockitoutil.TestBase;
+
+class PersonWithName {
+    private final String myName;
+
+    PersonWithName(String name) {
+        myName = Preconditions.notNull(name, "non-null name");
+    }
+
+    public String getMyName() {
+        return myName.toUpperCase();
+    }
+}
+
+class HasStatic {
+    public static String staticName() {
+        return "static name";
+    }
+}
+
+public class DefaultMockitoFrameworkTest extends TestBase {
+
+    private DefaultMockitoFramework framework = new DefaultMockitoFramework();
+
+    @After
+    public void clearListeners() {
+        new StateMaster().clearMockitoListeners();
+    }
+
+    @Test
+    public void prevents_adding_null_listener() {
+        assertThatThrownBy(
+                        () -> {
+                            framework.addListener(null);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("listener should not be null");
+    }
+
+    @Test
+    public void prevents_removing_null_listener() {
+        assertThatThrownBy(
+                        () -> {
+                            framework.removeListener(null);
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("listener should not be null");
+    }
+
+    @Test
+    public void ok_to_remove_unknown_listener() {
+        // it is safe to remove listener that was not added before
+        framework.removeListener(new MockitoListener() {});
+    }
+
+    @Test
+    public void ok_to_remove_listener_multiple_times() {
+        MockitoListener listener = new MockitoListener() {};
+
+        // when
+        framework.addListener(listener);
+
+        // then it is ok to:
+        framework.removeListener(listener);
+        framework.removeListener(listener);
+    }
+
+    @Test
+    public void adds_creation_listener() {
+        // given creation listener is added
+        MockCreationListener listener = mock(MockCreationListener.class);
+        framework.addListener(listener);
+
+        // when
+        MockSettings settings = withSettings().name("my list");
+        List mock = mock(List.class, settings);
+        Set mock2 = mock(Set.class);
+
+        // then
+        verify(listener).onMockCreated(eq(mock), any(MockCreationSettings.class));
+        verify(listener).onMockCreated(eq(mock2), any(MockCreationSettings.class));
+        verifyNoMoreInteractions(listener);
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void removes_creation_listener() {
+        // given creation listener is added
+        MockCreationListener listener = mock(MockCreationListener.class);
+        framework.addListener(listener);
+
+        // and hooked up correctly
+        mock(List.class);
+        verify(listener).onMockCreated(ArgumentMatchers.any(), any(MockCreationSettings.class));
+
+        // when
+        framework.removeListener(listener);
+        mock(Set.class);
+
+        // then
+        verifyNoMoreInteractions(listener);
+    }
+
+    @Test
+    public void prevents_duplicate_listeners_of_the_same_type() {
+        // given creation listener is added
+        framework.addListener(new MyListener());
+
+        assertThat(
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                framework.addListener(new MyListener());
+                            }
+                        })
+                .throwsException(RedundantListenerException.class)
+                .throwsMessage(
+                        "\n"
+                                + "Problems adding Mockito listener.\n"
+                                + "Listener of type 'MyListener' has already been added and not removed.\n"
+                                + "It indicates that previous listener was not removed according to the API.\n"
+                                + "When you add a listener, don't forget to remove the listener afterwards:\n"
+                                + "  Mockito.framework().removeListener(myListener);\n"
+                                + "For more information, see the javadoc for RedundantListenerException class.");
+    }
+
+    @Test
+    public void clearing_all_mocks_is_safe_regardless_of_mock_maker_type() {
+        List mock = mock(List.class);
+
+        // expect
+        assertTrue(mockingDetails(mock).isMock());
+        framework.clearInlineMocks();
+    }
+
+    @Test
+    public void behavior_after_clear_inline_mocks() {
+        // clearing mocks only works with inline mocking
+        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
+
+        PersonWithName obj = mock(PersonWithName.class);
+        when(obj.getMyName()).thenReturn("Bob");
+        assertEquals("Bob", obj.getMyName());
+        assertTrue(mockingDetails(obj).isMock());
+
+        framework.clearInlineMocks();
+
+        try {
+            obj.getMyName();
+        } catch (DisabledMockException e) {
+            return;
+        }
+        Assert.fail("Should have thrown DisabledMockException");
+    }
+
+    @Test
+    public void clear_inline_mocks_clears_static_mocks() {
+        // disabling mocks only works with inline mocking
+        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
+        assertEquals("static name", HasStatic.staticName());
+
+        // create a static mock
+        MockedStatic<HasStatic> mocked = mockStatic(HasStatic.class);
+
+        mocked.when(HasStatic::staticName).thenReturn("hacked name");
+        assertEquals("hacked name", HasStatic.staticName());
+
+        framework.clearInlineMocks();
+
+        assertEquals("static name", HasStatic.staticName());
+    }
+
+    @Test
+    public void behavior_after_clear_inline_mocks_is_mock() {
+        // clearing mocks only works with inline mocking
+        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
+
+        PersonWithName obj = mock(PersonWithName.class);
+        when(obj.getMyName()).thenReturn("Bob");
+        assertEquals("Bob", obj.getMyName());
+        assertTrue(mockingDetails(obj).isMock());
+
+        framework.clearInlineMocks();
+
+        try {
+            mockingDetails(obj).isMock();
+        } catch (DisabledMockException e) {
+            return;
+        }
+        Assert.fail("Should have thrown DisabledMockException");
+    }
+
+    @Test
+    public void clears_mock() {
+        // clearing mocks only works with inline mocking
+        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
+
+        // given
+        List list1 = mock(List.class);
+        assertTrue(mockingDetails(list1).isMock());
+        List list2 = mock(List.class);
+        assertTrue(mockingDetails(list2).isMock());
+
+        // when
+        framework.clearInlineMock(list1);
+
+        // then
+        assertThrows(DisabledMockException.class, () -> mockingDetails(list1).isMock());
+        assertTrue(mockingDetails(list2).isMock());
+    }
+
+    @Test
+    public void clears_mocks() {
+        // clearing mocks only works with inline mocking
+        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
+
+        // given
+        List list1 = mock(List.class);
+        assertTrue(mockingDetails(list1).isMock());
+        List list2 = mock(List.class);
+        assertTrue(mockingDetails(list2).isMock());
+
+        framework.clearInlineMocks();
+
+        // then
+        assertThrows(DisabledMockException.class, () -> mockingDetails(list1).isMock());
+        assertThrows(DisabledMockException.class, () -> mockingDetails(list2).isMock());
+    }
+
+    private static class MyListener implements MockitoListener {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java b/mockito-core/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
new file mode 100644
index 0000000000..154a7bc91b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.hamcrest;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.hamcrest.MatcherGenericTypeExtractor.genericTypeOfMatcher;
+
+import java.io.Serializable;
+import java.util.HashMap;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+public class MatcherGenericTypeExtractorTest extends TestBase {
+
+    // traditional inner class for matcher
+    private class IntMatcher extends BaseMatcher<Integer> {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    // static class with matcher
+    private static class StaticIntMatcher extends BaseMatcher<Integer> {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    // static subclass
+    private static class StaticIntMatcherSubclass extends StaticIntMatcher {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    // non-generic
+    @SuppressWarnings("rawtypes")
+    private static class NonGenericMatcher extends BaseMatcher {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    // Matcher interface implementation (instead of the BaseMatcher)
+    private class IntMatcherFromInterface extends BaseMatcher<Integer> {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeMismatch(Object item, Description mismatchDescription) {}
+
+        public void describeTo(Description description) {}
+    }
+
+    // Static Matcher interface implementation (instead of the BaseMatcher)
+    private static class StaticIntMatcherFromInterface extends BaseMatcher<Integer> {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeMismatch(Object item, Description mismatchDescription) {}
+
+        public void describeTo(Description description) {}
+    }
+
+    // non-generic matcher implementing the interface
+    @SuppressWarnings("rawtypes")
+    private static class NonGenericMatcherFromInterface extends BaseMatcher {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeMismatch(Object item, Description mismatchDescription) {}
+
+        public void describeTo(Description description) {}
+    }
+
+    private interface IMatcher extends Matcher<Integer> {}
+
+    // non-generic matcher implementing the interface
+    private static class SubclassGenericMatcherFromInterface extends BaseMatcher<Integer>
+            implements Serializable, Cloneable, IMatcher {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeMismatch(Object item, Description mismatchDescription) {}
+
+        public void describeTo(Description description) {}
+    }
+
+    // I refuse to comment on the sanity of this case
+    private static class InsaneEdgeCase extends SubclassGenericMatcherFromInterface {}
+
+    @Test
+    public void findsGenericType() {
+        assertEquals(Integer.class, genericTypeOfMatcher(IntMatcher.class));
+        assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcher.class));
+        assertEquals(Integer.class, genericTypeOfMatcher(IntMatcherFromInterface.class));
+        assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcherSubclass.class));
+        assertEquals(Integer.class, genericTypeOfMatcher(IntMatcherFromInterface.class));
+        assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcherFromInterface.class));
+        assertEquals(
+                Integer.class, genericTypeOfMatcher(SubclassGenericMatcherFromInterface.class));
+        assertEquals(Integer.class, genericTypeOfMatcher(InsaneEdgeCase.class));
+
+        assertEquals(
+                Integer.class,
+                genericTypeOfMatcher(
+                        new BaseMatcher<Integer>() {
+                            public void describeTo(Description description) {}
+
+                            public boolean matches(Object o) {
+                                return false;
+                            }
+                        }.getClass()));
+        assertEquals(
+                Integer.class,
+                genericTypeOfMatcher(
+                        new BaseMatcher<Integer>() {
+                            public void describeTo(Description description) {}
+
+                            public boolean matches(Object o) {
+                                return false;
+                            }
+
+                            public void describeMismatch(
+                                    Object item, Description mismatchDescription) {}
+                        }.getClass()));
+
+        assertEquals(Object.class, genericTypeOfMatcher(Object.class));
+        assertEquals(Object.class, genericTypeOfMatcher(String.class));
+        assertEquals(Object.class, genericTypeOfMatcher(HashMap.class));
+        assertEquals(
+                Object.class, genericTypeOfMatcher(new HashMap<String, String>() {}.getClass()));
+        assertEquals(Object.class, genericTypeOfMatcher(NonGenericMatcher.class));
+        assertEquals(Object.class, genericTypeOfMatcher(NonGenericMatcherFromInterface.class));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java b/mockito-core/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
new file mode 100644
index 0000000000..54e8394c09
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.handler;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willThrow;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.invocation.Invocation;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.MethodInvocationReport;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Answer;
+
+@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
+public class InvocationNotifierHandlerTest {
+    private static final String SOME_LOCATION = "some location";
+    private static final RuntimeException SOME_EXCEPTION = new RuntimeException();
+    private static final OutOfMemoryError SOME_ERROR = new OutOfMemoryError();
+    private static final Answer<?> SOME_ANSWER = mock(Answer.class);
+
+    @Mock private InvocationListener listener1;
+    @Mock private InvocationListener listener2;
+    @Spy private CustomListener customListener;
+
+    @Mock private Invocation invocation;
+    @Mock private MockHandlerImpl<ArrayList<Answer<?>>> mockHandler;
+
+    private InvocationNotifierHandler<ArrayList<Answer<?>>> notifier;
+
+    @Before
+    public void setUp() throws Exception {
+        notifier =
+                new InvocationNotifierHandler<>(
+                        mockHandler,
+                        (MockCreationSettings<ArrayList<Answer<?>>>)
+                                new MockSettingsImpl<ArrayList<Answer<?>>>()
+                                        .invocationListeners(customListener, listener1, listener2));
+    }
+
+    @Test
+    public void should_notify_all_listeners_when_calling_delegate_handler() throws Throwable {
+        // given
+        given(mockHandler.handle(invocation)).willReturn("returned value");
+
+        // when
+        notifier.handle(invocation);
+
+        // then
+        verify(listener1)
+                .reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
+        verify(listener2)
+                .reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
+    }
+
+    @Test
+    public void should_notify_all_listeners_when_called_delegate_handler_returns_ex()
+            throws Throwable {
+        // given
+        Exception computedException = new Exception("computed");
+        given(mockHandler.handle(invocation)).willReturn(computedException);
+
+        // when
+        notifier.handle(invocation);
+
+        // then
+        verify(listener1)
+                .reportInvocation(
+                        new NotifiedMethodInvocationReport(invocation, (Object) computedException));
+        verify(listener2)
+                .reportInvocation(
+                        new NotifiedMethodInvocationReport(invocation, (Object) computedException));
+    }
+
+    @Test
+    public void
+            should_notify_all_listeners_when_called_delegate_handler_throws_exception_and_rethrow_it()
+                    throws Throwable {
+        // given
+        ParseException parseException = new ParseException("", 0);
+        given(mockHandler.handle(invocation)).willThrow(parseException);
+
+        // when
+        assertThatThrownBy(
+                        () -> {
+                            notifier.handle(invocation);
+                        })
+                .isInstanceOf(ParseException.class)
+                .hasMessage("");
+
+        // then
+        verify(listener1)
+                .reportInvocation(new NotifiedMethodInvocationReport(invocation, parseException));
+        verify(listener2)
+                .reportInvocation(new NotifiedMethodInvocationReport(invocation, parseException));
+    }
+
+    @Test
+    public void should_report_listener_exception() throws Throwable {
+        willThrow(new NullPointerException())
+                .given(customListener)
+                .reportInvocation(any(MethodInvocationReport.class));
+
+        try {
+            notifier.handle(invocation);
+            fail();
+        } catch (MockitoException me) {
+            assertThat(me.getMessage())
+                    .contains("invocation listener")
+                    .contains("CustomListener")
+                    .contains("threw an exception")
+                    .contains("NullPointerException");
+        }
+    }
+
+    @Test
+    public void should_delegate_all_MockHandlerInterface_to_the_parameterized_MockHandler() {
+        notifier.getInvocationContainer();
+        notifier.getMockSettings();
+
+        verify(mockHandler).getInvocationContainer();
+        verify(mockHandler).getMockSettings();
+    }
+
+    private static class CustomListener implements InvocationListener {
+        public void reportInvocation(MethodInvocationReport methodInvocationReport) {
+            // nop
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java b/mockito-core/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
new file mode 100644
index 0000000000..d82bc7829e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.handler;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+/**
+ * by Szczepan Faber, created at: 5/22/12
+ */
+public class MockHandlerFactoryTest extends TestBase {
+
+    private final IMethods mock = Mockito.mock(IMethods.class);
+
+    @Test
+    // see issue 331
+    public void handle_result_must_not_be_null_for_primitives() throws Throwable {
+        // given:
+        MockCreationSettings<?> settings =
+                (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(null));
+        MockHandler<?> handler = createMockHandler(settings);
+
+        mock.intReturningMethod();
+        Invocation invocation = super.getLastInvocation();
+
+        // when:
+        Object result = handler.handle(invocation);
+
+        // then null value is not a valid result for a primitive
+        assertNotNull(result);
+        assertEquals(0, result);
+    }
+
+    @Test
+    // see issue 331
+    public void valid_handle_result_is_permitted() throws Throwable {
+        // given:
+        MockCreationSettings<?> settings =
+                (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(123));
+        MockHandler<?> handler = createMockHandler(settings);
+
+        mock.intReturningMethod();
+        Invocation invocation = super.getLastInvocation();
+
+        // when:
+        Object result = handler.handle(invocation);
+
+        // then
+        assertEquals(123, result);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java b/mockito-core/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
new file mode 100644
index 0000000000..a0169c25f8
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.handler;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
+import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.invocation.MatchersBinder;
+import org.mockito.internal.progress.ArgumentMatcherStorage;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.internal.verification.VerificationModeFactory;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.MethodInvocationReport;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings({"unchecked"})
+public class MockHandlerImplTest extends TestBase {
+
+    @Test
+    public void should_remove_verification_mode_even_when_invalid_matchers() throws Throwable {
+        // given
+        Invocation invocation = new InvocationBuilder().toInvocation();
+        @SuppressWarnings("rawtypes")
+        MockHandlerImpl<?> handler = new MockHandlerImpl(new MockSettingsImpl());
+        mockingProgress().verificationStarted(VerificationModeFactory.atLeastOnce());
+        handler.matchersBinder =
+                new MatchersBinder() {
+                    public InvocationMatcher bindMatchers(
+                            ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
+                        throw new InvalidUseOfMatchersException();
+                    }
+                };
+
+        try {
+            // when
+            handler.handle(invocation);
+
+            // then
+            fail();
+        } catch (InvalidUseOfMatchersException ignored) {
+        }
+
+        assertNull(mockingProgress().pullVerificationMode());
+    }
+
+    @Test
+    public void should_throw_mockito_exception_when_invocation_handler_throws_anything() {
+        // given
+        InvocationListener throwingListener = mock(InvocationListener.class);
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            doThrow(new Throwable())
+                                    .when(throwingListener)
+                                    .reportInvocation(any(MethodInvocationReport.class));
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Checked exception is invalid for this method!",
+                        "Invalid: java.lang.Throwable");
+    }
+
+    @Test
+    public void should_report_bogus_default_answer() throws Throwable {
+        // given
+        MockSettingsImpl mockSettings = mock(MockSettingsImpl.class);
+        MockHandlerImpl<?> handler = new MockHandlerImpl(mockSettings);
+        given(mockSettings.getDefaultAnswer()).willReturn(new Returns(AWrongType.WRONG_TYPE));
+        Invocation invocation =
+                new InvocationBuilder()
+                        .method(Object.class.getDeclaredMethod("toString"))
+                        .toInvocation();
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            @SuppressWarnings("unused") // otherwise cast is not done
+                            String there_should_not_be_a_CCE_here =
+                                    (String) handler.handle(invocation);
+                        })
+                .isInstanceOf(WrongTypeOfReturnValue.class)
+                .hasMessageContainingAll(
+                        "Default answer returned a result with the wrong type:",
+                        "AWrongType cannot be returned by toString()",
+                        "toString() should return String",
+                        "The default answer of iMethods that was configured on the mock is probably incorrectly implemented.");
+    }
+
+    private static class AWrongType {
+        public static final AWrongType WRONG_TYPE = new AWrongType();
+    }
+}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
similarity index 82%
rename from src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
rename to mockito-core/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
index 4cb228af72..55b721e9f2 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
@@ -19,38 +19,40 @@ public class InvocationMarkerTest extends TestBase {
 
     @Test
     public void shouldMarkInvocationAsVerified() {
-        //given
+        // given
         Invocation i = new InvocationBuilder().toInvocation();
         InvocationMatcher im = new InvocationBuilder().toInvocationMatcher();
         assertFalse(i.isVerified());
 
-        //when
+        // when
         InvocationMarker.markVerified(Arrays.asList(i), im);
 
-        //then
+        // then
         assertTrue(i.isVerified());
     }
 
     @Test
     public void shouldCaptureArguments() {
-        //given
+        // given
         Invocation i = new InvocationBuilder().toInvocation();
         final AtomicReference<Invocation> box = new AtomicReference<Invocation>();
-        MatchableInvocation c = new InvocationMatcher(i) {
-            public void captureArgumentsFrom(Invocation i) {
-                box.set(i);
-            }};
+        MatchableInvocation c =
+                new InvocationMatcher(i) {
+                    public void captureArgumentsFrom(Invocation i) {
+                        box.set(i);
+                    }
+                };
 
-        //when
+        // when
         InvocationMarker.markVerified(Arrays.asList(i), c);
 
-        //then
+        // then
         assertEquals(i, box.get());
     }
 
     @Test
     public void shouldMarkInvocationsAsVerifiedInOrder() {
-        //given
+        // given
         InOrderContextImpl context = new InOrderContextImpl();
 
         Invocation i = new InvocationBuilder().toInvocation();
@@ -58,10 +60,10 @@ public void shouldMarkInvocationsAsVerifiedInOrder() {
         assertFalse(context.isVerified(i));
         assertFalse(i.isVerified());
 
-        //when
+        // when
         InvocationMarker.markVerifiedInOrder(Arrays.asList(i), im, context);
 
-        //then
+        // then
         assertTrue(context.isVerified(i));
         assertTrue(i.isVerified());
     }
diff --git a/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
new file mode 100644
index 0000000000..a217d4d8d3
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.internal.matchers.Any.ANY;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.internal.matchers.CapturingMatcher;
+import org.mockito.internal.matchers.Equals;
+import org.mockito.internal.matchers.NotNull;
+import org.mockito.invocation.Invocation;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class InvocationMatcherTest extends TestBase {
+
+    private InvocationMatcher simpleMethod;
+    @Mock private IMethods mock;
+
+    @Before
+    public void setup() {
+        simpleMethod = new InvocationBuilder().mock(mock).simpleMethod().toInvocationMatcher();
+    }
+
+    @Test
+    public void should_be_a_citizen_of_hashes() throws Exception {
+        Invocation invocation = new InvocationBuilder().toInvocation();
+        Invocation invocationTwo = new InvocationBuilder().args("blah").toInvocation();
+
+        Map<InvocationMatcher, String> map = new HashMap<InvocationMatcher, String>();
+        map.put(new InvocationMatcher(invocation), "one");
+        map.put(new InvocationMatcher(invocationTwo), "two");
+
+        assertEquals(2, map.size());
+    }
+
+    @Test
+    public void should_not_equal_if_number_of_arguments_differ() throws Exception {
+        InvocationMatcher withOneArg =
+                new InvocationMatcher(new InvocationBuilder().args("test").toInvocation());
+        InvocationMatcher withTwoArgs =
+                new InvocationMatcher(new InvocationBuilder().args("test", 100).toInvocation());
+
+        assertFalse(withOneArg.equals(null));
+        assertFalse(withOneArg.equals(withTwoArgs));
+    }
+
+    @Test
+    public void should_to_string_with_matchers() throws Exception {
+        ArgumentMatcher m = NotNull.NOT_NULL;
+        InvocationMatcher notNull =
+                new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(m));
+        ArgumentMatcher mTwo = new Equals('x');
+        InvocationMatcher equals =
+                new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(mTwo));
+
+        assertThat(notNull.toString()).contains("simpleMethod(notNull())");
+        assertThat(equals.toString()).contains("simpleMethod('x')");
+    }
+
+    @Test
+    public void should_know_if_is_similar_to() throws Exception {
+        Invocation same = new InvocationBuilder().mock(mock).simpleMethod().toInvocation();
+        assertTrue(simpleMethod.hasSimilarMethod(same));
+
+        Invocation different = new InvocationBuilder().mock(mock).differentMethod().toInvocation();
+        assertFalse(simpleMethod.hasSimilarMethod(different));
+    }
+
+    @Test
+    public void should_not_be_similar_to_verified_invocation() throws Exception {
+        Invocation verified = new InvocationBuilder().simpleMethod().verified().toInvocation();
+        assertFalse(simpleMethod.hasSimilarMethod(verified));
+    }
+
+    @Test
+    public void should_not_be_similar_if_mocks_are_different() throws Exception {
+        Invocation onDifferentMock =
+                new InvocationBuilder().simpleMethod().mock("different mock").toInvocation();
+        assertFalse(simpleMethod.hasSimilarMethod(onDifferentMock));
+    }
+
+    @Test
+    public void should_not_be_similar_if_is_overloaded_but_used_with_the_same_arg()
+            throws Exception {
+        Method method = IMethods.class.getMethod("simpleMethod", String.class);
+        Method overloadedMethod = IMethods.class.getMethod("simpleMethod", Object.class);
+
+        String sameArg = "test";
+
+        InvocationMatcher invocation =
+                new InvocationBuilder().method(method).arg(sameArg).toInvocationMatcher();
+        Invocation overloadedInvocation =
+                new InvocationBuilder().method(overloadedMethod).arg(sameArg).toInvocation();
+
+        assertFalse(invocation.hasSimilarMethod(overloadedInvocation));
+    }
+
+    @Test
+    public void should_be_similar_if_is_overloaded_but_used_with_different_arg() throws Exception {
+        Method method = IMethods.class.getMethod("simpleMethod", String.class);
+        Method overloadedMethod = IMethods.class.getMethod("simpleMethod", Object.class);
+
+        InvocationMatcher invocation =
+                new InvocationBuilder().mock(mock).method(method).arg("foo").toInvocationMatcher();
+        Invocation overloadedInvocation =
+                new InvocationBuilder()
+                        .mock(mock)
+                        .method(overloadedMethod)
+                        .arg("bar")
+                        .toInvocation();
+
+        assertTrue(invocation.hasSimilarMethod(overloadedInvocation));
+    }
+
+    @Test
+    public void should_capture_arguments_from_invocation() throws Exception {
+        // given
+        Invocation invocation = new InvocationBuilder().args("1", 100).toInvocation();
+        CapturingMatcher capturingMatcher = new CapturingMatcher(List.class);
+        InvocationMatcher invocationMatcher =
+                new InvocationMatcher(invocation, (List) asList(new Equals("1"), capturingMatcher));
+
+        // when
+        invocationMatcher.captureArgumentsFrom(invocation);
+
+        // then
+        assertEquals(1, capturingMatcher.getAllValues().size());
+        assertEquals(100, capturingMatcher.getLastValue());
+    }
+
+    @Test
+    public void should_match_varargs_using_any_varargs() {
+        // given
+        mock.varargs("1", "2");
+        Invocation invocation = getLastInvocation();
+        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, asList(ANY, ANY));
+
+        // when
+        boolean match = invocationMatcher.matches(invocation);
+
+        // then
+        assertTrue(match);
+    }
+
+    @Test
+    public void should_capture_varargs_as_vararg() {
+        // given
+        mock.mixedVarargs(1, "a", "b");
+        Invocation invocation = getLastInvocation();
+        CapturingMatcher<String[]> m = new CapturingMatcher(String[].class);
+        InvocationMatcher invocationMatcher =
+                new InvocationMatcher(invocation, Arrays.<ArgumentMatcher>asList(new Equals(1), m));
+
+        // when
+        invocationMatcher.captureArgumentsFrom(invocation);
+
+        // then
+        Assertions.assertThat(m.getAllValues()).containsExactly(new String[] {"a", "b"});
+    }
+
+    @Test // like using several time the captor in the vararg
+    public void should_capture_arguments_when_args_count_does_NOT_match() {
+        // given
+        mock.varargs();
+        Invocation invocation = getLastInvocation();
+
+        // when
+        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(ANY));
+
+        // then
+        invocationMatcher.captureArgumentsFrom(invocation);
+    }
+
+    @Test
+    public void should_create_from_invocations() throws Exception {
+        // given
+        Invocation i = new InvocationBuilder().toInvocation();
+        // when
+        List<InvocationMatcher> out = InvocationMatcher.createFrom(asList(i));
+        // then
+        assertEquals(1, out.size());
+        assertEquals(i, out.get(0).getInvocation());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
new file mode 100644
index 0000000000..fd02ac5769
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.verification.InOrderContextImpl;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class InvocationsFinderTest extends TestBase {
+
+    private LinkedList<Invocation> invocations = new LinkedList<Invocation>();
+    private Invocation simpleMethodInvocation;
+    private Invocation simpleMethodInvocationTwo;
+    private Invocation differentMethodInvocation;
+
+    private final InOrderContext context = new InOrderContextImpl();
+
+    @Mock private IMethods mock;
+
+    @Before
+    public void setup() throws Exception {
+        simpleMethodInvocation =
+                new InvocationBuilder().mock(mock).simpleMethod().seq(1).toInvocation();
+        simpleMethodInvocationTwo =
+                new InvocationBuilder().mock(mock).simpleMethod().seq(2).toInvocation();
+        differentMethodInvocation =
+                new InvocationBuilder().mock(mock).differentMethod().seq(3).toInvocation();
+        invocations.addAll(
+                Arrays.asList(
+                        simpleMethodInvocation,
+                        simpleMethodInvocationTwo,
+                        differentMethodInvocation));
+    }
+
+    @Test
+    public void shouldFindActualInvocations() throws Exception {
+        List<Invocation> actual =
+                InvocationsFinder.findInvocations(
+                        invocations, new InvocationMatcher(simpleMethodInvocation));
+        Assertions.assertThat(actual)
+                .containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
+
+        actual =
+                InvocationsFinder.findInvocations(
+                        invocations, new InvocationMatcher(differentMethodInvocation));
+        Assertions.assertThat(actual).containsSequence(differentMethodInvocation);
+    }
+
+    @Test
+    public void shouldFindFirstUnverifiedInvocation() throws Exception {
+        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverified(invocations));
+
+        simpleMethodInvocationTwo.markVerified();
+        simpleMethodInvocation.markVerified();
+
+        assertSame(differentMethodInvocation, InvocationsFinder.findFirstUnverified(invocations));
+
+        differentMethodInvocation.markVerified();
+        assertNull(InvocationsFinder.findFirstUnverified(invocations));
+    }
+
+    @Test
+    public void shouldFindFirstUnverifiedInOrder() throws Exception {
+        // given
+        InOrderContextImpl context = new InOrderContextImpl();
+        assertSame(
+                simpleMethodInvocation,
+                InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+
+        // when
+        context.markVerified(simpleMethodInvocationTwo);
+        context.markVerified(simpleMethodInvocation);
+
+        // then
+        assertSame(
+                differentMethodInvocation,
+                InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+
+        // when
+        context.markVerified(differentMethodInvocation);
+
+        // then
+        assertNull(InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+    }
+
+    @Test
+    public void shouldFindFirstUnverifiedInOrderAndRespectSequenceNumber() throws Exception {
+        // given
+        InOrderContextImpl context = new InOrderContextImpl();
+        assertSame(
+                simpleMethodInvocation,
+                InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+
+        // when
+        // skipping verification of first invocation, then:
+        context.markVerified(simpleMethodInvocationTwo);
+        context.markVerified(differentMethodInvocation);
+
+        // then
+        assertSame(null, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+    }
+
+    @Test
+    public void shouldFindFirstUnverifiedInvocationOnMock() throws Exception {
+        assertSame(
+                simpleMethodInvocation,
+                InvocationsFinder.findFirstUnverified(
+                        invocations, simpleMethodInvocation.getMock()));
+        assertNull(InvocationsFinder.findFirstUnverified(invocations, "different mock"));
+    }
+
+    @Test
+    public void shouldFindFirstSimilarInvocationByName() throws Exception {
+        Invocation overloadedSimpleMethod =
+                new InvocationBuilder().mock(mock).simpleMethod().arg("test").toInvocation();
+
+        Invocation found =
+                InvocationsFinder.findSimilarInvocation(
+                        invocations, new InvocationMatcher(overloadedSimpleMethod));
+        assertSame(found, simpleMethodInvocation);
+    }
+
+    @Test
+    public void shouldFindInvocationWithTheSameMethod() throws Exception {
+        Invocation overloadedDifferentMethod =
+                new InvocationBuilder().differentMethod().arg("test").toInvocation();
+
+        invocations.add(overloadedDifferentMethod);
+
+        Invocation found =
+                InvocationsFinder.findSimilarInvocation(
+                        invocations, new InvocationMatcher(overloadedDifferentMethod));
+        assertSame(found, overloadedDifferentMethod);
+    }
+
+    @Test
+    public void shouldGetLastStackTrace() throws Exception {
+        Location last = InvocationsFinder.getLastLocation(invocations);
+        assertSame(differentMethodInvocation.getLocation(), last);
+
+        assertNull(InvocationsFinder.getLastLocation(Collections.<Invocation>emptyList()));
+    }
+
+    @Test
+    public void shouldFindAllMatchingUnverifiedChunks() throws Exception {
+        List<Invocation> allMatching =
+                InvocationsFinder.findAllMatchingUnverifiedChunks(
+                        invocations, new InvocationMatcher(simpleMethodInvocation), context);
+        Assertions.assertThat(allMatching)
+                .containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
+
+        context.markVerified(simpleMethodInvocation);
+        allMatching =
+                InvocationsFinder.findAllMatchingUnverifiedChunks(
+                        invocations, new InvocationMatcher(simpleMethodInvocation), context);
+        Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocationTwo);
+
+        context.markVerified(simpleMethodInvocationTwo);
+        allMatching =
+                InvocationsFinder.findAllMatchingUnverifiedChunks(
+                        invocations, new InvocationMatcher(simpleMethodInvocation), context);
+        assertTrue(allMatching.isEmpty());
+    }
+
+    @Test
+    public void shouldFindMatchingChunk() throws Exception {
+        List<Invocation> chunk =
+                InvocationsFinder.findMatchingChunk(
+                        invocations, new InvocationMatcher(simpleMethodInvocation), 2, context);
+        Assertions.assertThat(chunk)
+                .containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
+    }
+
+    @Test
+    public void shouldReturnAllChunksWhenModeIsAtLeastOnce() throws Exception {
+        Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
+        invocations.add(simpleMethodInvocationThree);
+
+        List<Invocation> chunk =
+                InvocationsFinder.findMatchingChunk(
+                        invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
+        Assertions.assertThat(chunk)
+                .containsSequence(
+                        simpleMethodInvocation,
+                        simpleMethodInvocationTwo,
+                        simpleMethodInvocationThree);
+    }
+
+    @Test
+    public void shouldReturnAllChunksWhenWantedCountDoesntMatch() throws Exception {
+        Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
+        invocations.add(simpleMethodInvocationThree);
+
+        List<Invocation> chunk =
+                InvocationsFinder.findMatchingChunk(
+                        invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
+        Assertions.assertThat(chunk)
+                .containsSequence(
+                        simpleMethodInvocation,
+                        simpleMethodInvocationTwo,
+                        simpleMethodInvocationThree);
+    }
+
+    @Test
+    public void shouldFindPreviousInOrder() throws Exception {
+        Invocation previous = InvocationsFinder.findPreviousVerifiedInOrder(invocations, context);
+        assertNull(previous);
+
+        context.markVerified(simpleMethodInvocation);
+        context.markVerified(simpleMethodInvocationTwo);
+
+        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/mockito-core/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
new file mode 100644
index 0000000000..21c94b1525
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.internal.invocation.MatcherApplicationStrategy.getMatcherApplicationStrategyFor;
+import static org.mockito.internal.matchers.Any.ANY;
+
+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.invocation.Invocation;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class MatcherApplicationStrategyTest extends TestBase {
+
+    @Mock IMethods mock;
+    private Invocation invocation;
+    private List<? extends ArgumentMatcher<?>> matchers;
+
+    private RecordingAction recordAction;
+
+    @Before
+    public void before() {
+        recordAction = new RecordingAction();
+    }
+
+    @Test
+    public void shouldKnowWhenActualArgsSizeIsDifferent1() {
+        // given
+        invocation = varargs("1");
+        matchers = asList(new Equals("1"));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(RETURN_ALWAYS_FALSE);
+
+        // then
+        assertFalse(match);
+    }
+
+    @Test
+    public void shouldKnowWhenActualArgsSizeIsDifferent2() {
+        // given
+        invocation = varargs("1");
+        matchers = asList(new Equals("1"));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
+
+        // then
+        assertTrue(match);
+    }
+
+    @Test
+    public void shouldKnowWhenActualArgsSizeIsDifferent() {
+        // given
+        invocation = varargs("1", "2");
+        matchers = asList(new Equals("1"));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
+
+        // then
+        assertFalse(match);
+    }
+
+    @Test
+    public void shouldKnowWhenMatchersSizeIsDifferent() {
+        // given
+        invocation = varargs("1");
+        matchers = asList(new Equals("1"), new Equals("2"));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
+
+        // then
+        assertFalse(match);
+    }
+
+    @Test
+    public void shouldKnowWhenVarargsMatch() {
+        // given
+        invocation = varargs("1", "2", "3");
+        matchers = asList(new Equals("1"), Any.ANY, new InstanceOf(String.class));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(recordAction);
+
+        // then
+        assertTrue(match);
+    }
+
+    @Test
+    public void shouldAllowAnyMatchEntireVararg() {
+        // given
+        invocation = varargs("1", "2");
+        matchers = asList(ANY, ANY);
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(recordAction);
+
+        // then
+        assertTrue(match);
+    }
+
+    @Test
+    public void shouldNotAllowAnyWithMixedVarargs() {
+        // given
+        invocation = mixedVarargs(1, "1", "2");
+        matchers = asList(new Equals(1));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(recordAction);
+
+        // then
+        assertFalse(match);
+    }
+
+    @Test
+    public void shouldAllowAnyWithMixedVarargs() {
+        // given
+        invocation = mixedVarargs(1, "1", "2");
+        matchers = asList(new Equals(1), ANY, ANY);
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(recordAction);
+
+        // then
+        assertTrue(match);
+    }
+
+    @Test
+    public void shouldAnyDealWithDifferentSizeOfArgs() {
+        // given
+        invocation = mixedVarargs(1, "1", "2");
+        matchers = asList(new Equals(1));
+
+        // when
+        boolean match =
+                getMatcherApplicationStrategyFor(invocation, matchers)
+                        .forEachMatcherAndArgument(recordAction);
+
+        // then
+        assertFalse(match);
+
+        recordAction.assertIsEmpty();
+    }
+
+    @Test
+    public void shouldMatchAnyEvenIfOneOfTheArgsIsNull() {
+        // given
+        invocation = mixedVarargs(null, null, "2");
+        matchers = asList(new Equals(null), ANY, ANY);
+
+        // when
+        getMatcherApplicationStrategyFor(invocation, matchers)
+                .forEachMatcherAndArgument(recordAction);
+
+        // then
+        recordAction.assertContainsExactly(new Equals(null), ANY, ANY);
+    }
+
+    @Test
+    public void shouldMatchAnyEvenIfMatcherIsDecorated() {
+        // given
+        invocation = varargs("1", "2");
+        matchers = asList(ANY, ANY);
+
+        // when
+        getMatcherApplicationStrategyFor(invocation, matchers)
+                .forEachMatcherAndArgument(recordAction);
+
+        // then
+        recordAction.assertContainsExactly(ANY, ANY);
+    }
+
+    @Test
+    public void shouldMatchAnyEvenIfMatcherIsWrappedInHamcrestMatcher() {
+        // given
+        invocation = varargs("1", "2");
+        HamcrestArgumentMatcher<Integer> argumentMatcher =
+                new HamcrestArgumentMatcher<>(new IntMatcher());
+        matchers = asList(argumentMatcher, argumentMatcher);
+
+        // when
+        getMatcherApplicationStrategyFor(invocation, matchers)
+                .forEachMatcherAndArgument(recordAction);
+
+        // then
+        recordAction.assertContainsExactly(argumentMatcher, argumentMatcher);
+    }
+
+    @Test
+    public void shouldMatchAnyThatMatchesRawVarArgType() {
+        // given
+        invocation = varargs("1", "2");
+        InstanceOf any = new InstanceOf(String[].class, "<any String[]>");
+        matchers = asList(any);
+
+        // when
+        getMatcherApplicationStrategyFor(invocation, matchers)
+                .forEachMatcherAndArgument(recordAction);
+
+        // then
+        recordAction.assertContainsExactly(any);
+    }
+
+    private static class IntMatcher extends BaseMatcher<Integer> {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    private static class IntArrayMatcher extends BaseMatcher<Integer[]> {
+        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();
+    }
+
+    private Invocation varargs(String... s) {
+        mock.varargs(s);
+        return getLastInvocation();
+    }
+
+    private static class RecordingAction implements ArgumentMatcherAction {
+        private final List<ArgumentMatcher<?>> matchers = new ArrayList<ArgumentMatcher<?>>();
+
+        @Override
+        public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
+            matchers.add(matcher);
+            return true;
+        }
+
+        public void assertIsEmpty() {
+            assertThat(matchers).isEmpty();
+        }
+
+        public void assertContainsExactly(ArgumentMatcher<?>... matchers) {
+            assertThat(this.matchers).containsExactly(matchers);
+        }
+    }
+
+    private static final ArgumentMatcherAction RETURN_ALWAYS_TRUE =
+            new ArgumentMatcherAction() {
+                @Override
+                public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
+                    return true;
+                }
+            };
+
+    private static final ArgumentMatcherAction RETURN_ALWAYS_FALSE =
+            new ArgumentMatcherAction() {
+                @Override
+                public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
+                    return false;
+                }
+            };
+}
diff --git a/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
similarity index 97%
rename from src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
rename to mockito-core/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
index 69a241bd9f..bbf7eb9890 100644
--- a/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
@@ -14,7 +14,6 @@
 import org.junit.Test;
 import org.mockitoutil.TestBase;
 
-
 public class SerializableMethodTest extends TestBase {
 
     private MockitoMethod method;
@@ -70,6 +69,6 @@ public void shouldNotBeEqualForSameMethodFromTwoDifferentClasses() throws Except
         assertFalse(new SerializableMethod(testBaseToStringMethod).equals(method));
     }
 
-    //TODO: add tests for generated equals() method
+    // TODO: add tests for generated equals() method
 
 }
diff --git a/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
similarity index 97%
rename from src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
rename to mockito-core/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
index 94b4a2346b..0a29cee3ae 100644
--- a/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
@@ -25,11 +25,9 @@ public class TypeSafeMatchingTest {
 
     private static final Object NOT_A_COMPARABLE = new Object();
 
-    @Rule
-    public MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
 
-    @Mock
-    public IMethods mock;
+    @Mock public IMethods mock;
 
     /**
      * Should not throw an {@link NullPointerException}
@@ -40,7 +38,6 @@ public class TypeSafeMatchingTest {
     public void compareNullArgument() {
         boolean match = matchesTypeSafe().apply(new LessOrEqual<Integer>(5), null);
         assertThat(match).isFalse();
-
     }
 
     /**
@@ -102,7 +99,6 @@ public boolean matches(Date arg) {
             public boolean matches(Integer arg, Void v) {
                 throw new UnsupportedOperationException();
             }
-
         }
 
         boolean match = matchesTypeSafe().apply(new TestMatcher(), 123);
@@ -111,8 +107,7 @@ public boolean matches(Integer arg, Void v) {
 
     @Test
     public void matchesWithSubTypeExtendingGenericClass() {
-        abstract class GenericMatcher<T> implements ArgumentMatcher<T> {
-        }
+        abstract class GenericMatcher<T> implements ArgumentMatcher<T> {}
         class TestMatcher extends GenericMatcher<Integer> {
             @Override
             public boolean matches(Integer argument) {
@@ -127,8 +122,7 @@ public boolean matches(Integer argument) {
     public void dontMatchesWithSubTypeExtendingGenericClass() {
         final AtomicBoolean wasCalled = new AtomicBoolean();
 
-        abstract class GenericMatcher<T> implements ArgumentMatcher<T> {
-        }
+        abstract class GenericMatcher<T> implements ArgumentMatcher<T> {}
         class TestMatcher extends GenericMatcher<Integer> {
             @Override
             public boolean matches(Integer argument) {
diff --git a/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java b/mockito-core/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
similarity index 94%
rename from src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
rename to mockito-core/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
index aa38dd4e97..5c31e5ac56 100644
--- a/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
@@ -15,9 +15,9 @@ public class MockWeakReferenceTest extends TestBase {
     @Test
     public void descriptive_exception_when_mock_was_collected() {
         try {
-            //when
+            // when
             new MockWeakReference(null).get();
-            //then
+            // then
             fail();
         } catch (Exception e) {
             Assertions.assertThat(e).hasMessageContaining("The mock object was garbage collected");
diff --git a/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java b/mockito-core/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
similarity index 75%
rename from src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
index d4fccc2732..265941269c 100644
--- a/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
@@ -22,109 +22,112 @@ public class ArgMismatchFinderTest extends TestBase {
 
     @Test
     public void no_interactions() throws Exception {
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(0, mismatches.size());
     }
 
     @Test
     public void no_mismatch_when_mock_different() throws Exception {
-        //given
+        // given
         when(mock1.simpleMethod(1)).thenReturn("1");
-        mock2.simpleMethod(2); //arg mismatch on different mock
+        mock2.simpleMethod(2); // arg mismatch on different mock
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(0, mismatches.size());
     }
 
     @Test
     public void no_mismatch_when_method_different() throws Exception {
-        //given
+        // given
         when(mock1.simpleMethod(1)).thenReturn("1");
         mock1.otherMethod();
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(0, mismatches.size());
     }
 
     @Test
     public void no_mismatch_when_stubbing_used() throws Exception {
-        //given
+        // given
         when(mock1.simpleMethod(1)).thenReturn("1");
         mock1.simpleMethod(1); // stub used
         mock1.simpleMethod(2); // no stubbing, but we don't want it to be reported, either
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(0, mismatches.size());
     }
 
     @Test
     public void stubbing_mismatch() throws Exception {
-        //given
+        // given
         when(mock1.simpleMethod(1)).thenReturn("1");
         mock1.simpleMethod(2);
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(1, mismatches.size());
     }
 
     @Test
     public void single_mismatch_with_multiple_invocations() throws Exception {
-        //given
+        // given
         when(mock1.simpleMethod(1)).thenReturn("1");
         mock1.simpleMethod(2);
         mock1.simpleMethod(3);
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(1, mismatches.size());
-        assertEquals("{mock1.simpleMethod(1);=[mock1.simpleMethod(2);, mock1.simpleMethod(3);]}", mismatches.toString());
+        assertEquals(
+                "{mock1.simpleMethod(1);=[mock1.simpleMethod(2);, mock1.simpleMethod(3);]}",
+                mismatches.toString());
     }
 
     @Test
     public void single_invocation_with_multiple_stubs() throws Exception {
-        //given
+        // given
         when(mock1.simpleMethod(1)).thenReturn("1");
         when(mock1.simpleMethod(2)).thenReturn("2");
         mock1.simpleMethod(3);
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(2, mismatches.size());
-        assertEquals("{mock1.simpleMethod(1);=[mock1.simpleMethod(3);], mock1.simpleMethod(2);=[mock1.simpleMethod(3);]}"
-                , mismatches.toString());
+        assertEquals(
+                "{mock1.simpleMethod(1);=[mock1.simpleMethod(3);], mock1.simpleMethod(2);=[mock1.simpleMethod(3);]}",
+                mismatches.toString());
     }
 
     @Test
     public void mismatch_reports_only_unstubbed_invocations() throws Exception {
-        //given
-        when(mock1.simpleMethod(1)).thenReturn("1"); //unused
-        when(mock1.simpleMethod(2)).thenReturn("2"); //used
-        mock1.simpleMethod(2); //stubbed
-        mock1.simpleMethod(3); //unstubbed
+        // given
+        when(mock1.simpleMethod(1)).thenReturn("1"); // unused
+        when(mock1.simpleMethod(2)).thenReturn("2"); // used
+        mock1.simpleMethod(2); // stubbed
+        mock1.simpleMethod(3); // unstubbed
 
-        //when
+        // when
         StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals("{mock1.simpleMethod(1);=[mock1.simpleMethod(3);]}", mismatches.toString());
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java b/mockito-core/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
new file mode 100644
index 0000000000..394d0fb391
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockitoutil.ClassLoaders.excludingClassLoader;
+
+import java.lang.reflect.Method;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.mockito.exceptions.verification.ArgumentsAreDifferent;
+
+public class ExceptionFactoryTest {
+
+    private static final ClassLoader classLoaderWithoutJUnitOrOpenTest =
+            excludingClassLoader()
+                    .withCodeSourceUrlOf(ExceptionFactory.class)
+                    .without("org.junit", "junit", "org.opentest4j")
+                    .build();
+    private static final ClassLoader currentClassLoader =
+            ExceptionFactoryTest.class.getClassLoader();
+
+    /** loaded by the current classloader */
+    private static Class<?> opentestComparisonFailure;
+
+    private static Class<?> opentestArgumentsAreDifferent;
+
+    /** loaded by the custom classloader {@value #classLoaderWithoutJUnitOrOpenTest}, which excludes JUnit and OpenTest4J classes */
+    private static Class<?> nonJunitArgumentsAreDifferent;
+
+    @BeforeClass
+    public static void init() throws ClassNotFoundException {
+        nonJunitArgumentsAreDifferent =
+                classLoaderWithoutJUnitOrOpenTest.loadClass(ArgumentsAreDifferent.class.getName());
+        opentestComparisonFailure = org.opentest4j.AssertionFailedError.class;
+        opentestArgumentsAreDifferent =
+                org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent.class;
+    }
+
+    @Test
+    public void createArgumentsAreDifferentException_withoutJUnitOrOpenTest() throws Exception {
+        AssertionError e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
+
+        assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
+    }
+
+    @Test
+    public void createArgumentsAreDifferentException_withOpenTest() throws Exception {
+        AssertionError e = invokeFactoryThroughLoader(currentClassLoader);
+
+        assertThat(e)
+                .isExactlyInstanceOf(opentestArgumentsAreDifferent)
+                .isInstanceOf(opentestComparisonFailure);
+    }
+
+    @Test
+    public void createArgumentsAreDifferentException_withoutJUnitOrOpenTest_2x() throws Exception {
+        AssertionError e;
+
+        e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
+        assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
+
+        e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
+        assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
+    }
+
+    @Test
+    public void createArgumentsAreDifferentException_withOpenTest_2x() throws Exception {
+        AssertionError e;
+
+        e = invokeFactoryThroughLoader(currentClassLoader);
+        assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent);
+
+        e = invokeFactoryThroughLoader(currentClassLoader);
+        assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent);
+    }
+
+    private static AssertionError invokeFactoryThroughLoader(ClassLoader loader) throws Exception {
+        Class<?> exceptionFactory = loader.loadClass(ExceptionFactory.class.getName());
+
+        Method m =
+                exceptionFactory.getDeclaredMethod(
+                        "createArgumentsAreDifferentException",
+                        String.class,
+                        String.class,
+                        String.class);
+        return (AssertionError) m.invoke(null, "message", "wanted", "actual");
+    }
+}
diff --git a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java b/mockito-core/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
similarity index 83%
rename from src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
rename to mockito-core/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
index 1f9a3183a0..f971893e4b 100644
--- a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
@@ -22,7 +22,8 @@ public class JUnitRuleTest {
     @Rule public SafeJUnitRule rule = new SafeJUnitRule(MockitoJUnit.rule());
     @Mock IMethods mock;
 
-    @Test public void injects_into_test_case() throws Throwable {
+    @Test
+    public void injects_into_test_case() throws Throwable {
         assertTrue(mockingDetails(mock).isMock());
     }
 
@@ -42,9 +43,9 @@ public void detects_invalid_mockito_usage_on_success() throws Throwable {
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void does_not_check_invalid_mockito_usage_on_failure() throws Throwable {
-        //This intended behavior is questionable
-        //However, it was like that since the beginning of JUnit rule support
-        //Users never questioned this behavior. Hence, let's stick to it unless we have more data
+        // This intended behavior is questionable
+        // However, it was like that since the beginning of JUnit rule support
+        // Users never questioned this behavior. Hence, let's stick to it unless we have more data
         rule.expectFailure(RuntimeException.class, "foo");
 
         Mockito.when(mock.simpleMethod()); // <--- unfinished stubbing
diff --git a/mockito-core/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java b/mockito-core/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
new file mode 100644
index 0000000000..53493648ed
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.invocation.Invocation;
+import org.mockitoutil.TestBase;
+
+public class StubbingArgMismatchesTest extends TestBase {
+
+    SimpleMockitoLogger logger = new SimpleMockitoLogger();
+    StubbingArgMismatches mismatches = new StubbingArgMismatches();
+
+    @Test
+    public void no_op_when_no_mismatches() throws Exception {
+        // when
+        mismatches.format("MyTest.myTestMethod", logger);
+
+        // then
+        assertTrue(logger.isEmpty());
+    }
+
+    @Test
+    public void logs_mismatch() throws Exception {
+        // given
+        mismatches.add(
+                new InvocationBuilder().args("a").location("-> at A.java").toInvocation(),
+                new InvocationBuilder().args("b").location("-> at B.java").toInvocation());
+
+        // when
+        mismatches.format("MyTest.myTestMethod", logger);
+
+        // then
+        assertEquals(
+                "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+                        + "[MockitoHint] 1. Unused... -> at B.java\n"
+                        + "[MockitoHint]  ...args ok? -> at A.java\n",
+                logger.getLoggedInfo());
+    }
+
+    @Test
+    public void multiple_matching_invocations_per_stub_plus_some_other_invocation()
+            throws Exception {
+        // given
+        Invocation stubbing =
+                new InvocationBuilder().args("a").location("-> at A.java").toInvocation();
+        mismatches.add(
+                new InvocationBuilder().args("x").location("-> at X.java").toInvocation(),
+                stubbing);
+        mismatches.add(
+                new InvocationBuilder().args("y").location("-> at Y.java").toInvocation(),
+                stubbing);
+
+        mismatches.add(
+                new InvocationBuilder()
+                        .method("differentMethod")
+                        .args("n")
+                        .location("-> at N.java")
+                        .toInvocation(),
+                new InvocationBuilder()
+                        .method("differentMethod")
+                        .args("m")
+                        .location("-> at M.java")
+                        .toInvocation());
+
+        // when
+        mismatches.format("MyTest.myTestMethod", logger);
+
+        // then
+        assertEquals(
+                "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+                        + "[MockitoHint] 1. Unused... -> at A.java\n"
+                        + "[MockitoHint]  ...args ok? -> at X.java\n"
+                        + "[MockitoHint]  ...args ok? -> at Y.java\n"
+                        + "[MockitoHint] 2. Unused... -> at M.java\n"
+                        + "[MockitoHint]  ...args ok? -> at N.java\n",
+                logger.getLoggedInfo());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java b/mockito-core/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
new file mode 100644
index 0000000000..67d816c5ae
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import org.junit.Test;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.stubbing.StubbedInvocationMatcher;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.stubbing.Stubbing;
+import org.mockitoutil.TestBase;
+
+public class UnusedStubbingsTest extends TestBase {
+
+    private SimpleMockitoLogger logger = new SimpleMockitoLogger();
+
+    @Test
+    public void no_unused_stubbings() throws Exception {
+        // given
+        UnusedStubbings stubbings = new UnusedStubbings(Collections.<Stubbing>emptyList());
+
+        // when
+        stubbings.format("MyTest.myTestMethod", logger);
+
+        // then
+        assertEquals("", logger.getLoggedInfo());
+    }
+
+    @Test
+    public void unused_stubbings() throws Exception {
+        // given
+        UnusedStubbings stubbings =
+                new UnusedStubbings(
+                        Arrays.asList(
+                                new StubbedInvocationMatcher(
+                                        doesNothing(),
+                                        new InvocationBuilder().toInvocationMatcher(),
+                                        null),
+                                new StubbedInvocationMatcher(
+                                        doesNothing(),
+                                        new InvocationBuilder().toInvocationMatcher(),
+                                        null)));
+
+        // when
+        stubbings.format("MyTest.myTestMethod", logger);
+
+        // then
+        assertThat(filterLineNo(logger.getLoggedInfo()))
+                .isIn(
+                        "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+                                + // Java <9
+                                "[MockitoHint] 1. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n"
+                                + "[MockitoHint] 2. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n",
+                        "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+                                + // Java 9
+                                "[MockitoHint] 1. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n"
+                                + "[MockitoHint] 2. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n",
+                        "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+                                + // Java 21
+                                "[MockitoHint] 1. Unused -> at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:0)\n"
+                                + "[MockitoHint] 2. Unused -> at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:0)\n");
+    }
+}
diff --git a/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java b/mockito-core/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
similarity index 90%
rename from src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
rename to mockito-core/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
index bfb275a1ad..6b2c77c693 100644
--- a/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
@@ -61,10 +61,10 @@ class EventArgumentMatcher implements ArgumentMatcher<StubbingLookupNotifier.Eve
 
         @Override
         public boolean matches(StubbingLookupNotifier.Event argument) {
-            return invocation == argument.getInvocation() &&
-                stubbingFound == argument.getStubbingFound() &&
-                allStubbings == argument.getAllStubbings() &&
-                creationSettings == argument.getMockSettings();
+            return invocation == argument.getInvocation()
+                    && stubbingFound == argument.getStubbingFound()
+                    && allStubbings == argument.getAllStubbings()
+                    && creationSettings == argument.getMockSettings();
         }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java b/mockito-core/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
new file mode 100644
index 0000000000..419fa7c56d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.listeners;
+
+import static java.util.Collections.emptyList;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.MockingDetails;
+import org.mockitoutil.TestBase;
+
+public class VerificationStartedNotifierTest extends TestBase {
+
+    MockingDetails mockingDetails = mockingDetails(mock(List.class));
+
+    @Test
+    public void does_not_do_anything_when_list_is_empty() throws Exception {
+        // expect nothing to happen
+        VerificationStartedNotifier.notifyVerificationStarted((List) emptyList(), mockingDetails);
+    }
+
+    @Test
+    public void decent_exception_when_setting_non_mock() throws Exception {
+        VerificationStartedNotifier.Event event =
+                new VerificationStartedNotifier.Event(mockingDetails);
+
+        try {
+            // when
+            event.setMock("not a mock");
+            fail();
+        } catch (Exception e) {
+            // then
+            assertEquals(
+                    "VerificationStartedEvent.setMock() does not accept parameter which is not a Mockito mock.\n"
+                            + "  Received parameter: \"not a mock\".\n"
+                            + "  See the Javadoc.",
+                    e.getMessage());
+        }
+    }
+
+    @Test
+    public void shows_clean_exception_message_when_illegal_null_arg_is_used() throws Exception {
+        VerificationStartedNotifier.Event event =
+                new VerificationStartedNotifier.Event(mockingDetails);
+
+        try {
+            // when
+            event.setMock(null);
+            fail();
+        } catch (Exception e) {
+            // then
+            assertEquals(
+                    "VerificationStartedEvent.setMock() does not accept null parameter. See the Javadoc.",
+                    e.getMessage());
+        }
+    }
+
+    @Test
+    public void decent_exception_when_setting_mock_of_wrong_type() throws Exception {
+        final Set differentTypeMock = mock(Set.class);
+        VerificationStartedNotifier.Event event =
+                new VerificationStartedNotifier.Event(mockingDetails);
+
+        try {
+            // when
+            event.setMock(differentTypeMock);
+            fail();
+        } catch (Exception e) {
+            // then
+            assertEquals(
+                    filterHashCode(
+                            "VerificationStartedEvent.setMock() does not accept parameter which is not the same type as the original mock.\n"
+                                    + "  Required type: java.util.List\n"
+                                    + "  Received parameter: Mock for Set, hashCode: xxx.\n"
+                                    + "  See the Javadoc."),
+                    filterHashCode(e.getMessage()));
+        }
+    }
+
+    @Test
+    public void decent_exception_when_setting_mock_that_does_not_implement_all_desired_interfaces()
+            throws Exception {
+        final Set mock = mock(Set.class, withSettings().extraInterfaces(List.class));
+        final Set missingExtraInterface = mock(Set.class);
+        VerificationStartedNotifier.Event event =
+                new VerificationStartedNotifier.Event(mockingDetails(mock));
+
+        try {
+            // when setting mock that does not have all necessary interfaces
+            event.setMock(missingExtraInterface);
+            fail();
+        } catch (Exception e) {
+            // then
+            assertEquals(
+                    filterHashCode(
+                            "VerificationStartedEvent.setMock() does not accept parameter which does not implement all extra interfaces of the original mock.\n"
+                                    + "  Required type: java.util.Set\n"
+                                    + "  Required extra interface: java.util.List\n"
+                                    + "  Received parameter: Mock for Set, hashCode: xxx.\n"
+                                    + "  See the Javadoc."),
+                    filterHashCode(e.getMessage()));
+        }
+    }
+
+    @Test
+    public void accepts_replacement_mock_if_all_types_are_compatible() throws Exception {
+        final Set mock = mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
+        final Set compatibleMock =
+                mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
+        VerificationStartedNotifier.Event event =
+                new VerificationStartedNotifier.Event(mockingDetails(mock));
+
+        // when
+        event.setMock(compatibleMock);
+
+        // then
+        assertEquals(compatibleMock, event.getMock());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/matchers/AndTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/AndTest.java
new file mode 100644
index 0000000000..3115576d9e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/AndTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+
+public class AndTest extends TestBase {
+
+    @Mock private ArgumentMatcher<?> m1;
+    @Mock private ArgumentMatcher<?> m2;
+    private And and;
+
+    @Before
+    public void setUp() throws Exception {
+        and = new And(m1, m2);
+    }
+
+    @Test
+    public void shouldReturnMatchingTypes() {
+        given(m1.type()).will(inv -> String.class);
+        given(m2.type()).will(inv -> String.class);
+
+        assertThat(and.type()).isEqualTo(String.class);
+    }
+
+    @Test
+    public void shouldDefaultMismatchingTypes() {
+        given(m1.type()).will(inv -> String.class);
+        given(m2.type()).will(inv -> Integer.class);
+
+        assertThat(and.type()).isEqualTo(Void.class);
+    }
+
+    @Test
+    public void shouldReturnLeftBaseType() {
+        given(m1.type()).will(inv -> BaseType.class);
+        given(m2.type()).will(inv -> SubType.class);
+
+        assertThat(and.type()).isEqualTo(BaseType.class);
+    }
+
+    @Test
+    public void shouldReturnRightBaseType() {
+        given(m1.type()).will(inv -> SubType.class);
+        given(m2.type()).will(inv -> BaseType.class);
+
+        assertThat(and.type()).isEqualTo(BaseType.class);
+    }
+
+    private interface BaseType {}
+
+    private interface SubType extends BaseType {}
+}
diff --git a/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
similarity index 77%
rename from src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
index f2685aaaf5..768d08d0b8 100644
--- a/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
@@ -18,56 +18,57 @@ public class CapturingMatcherTest extends TestBase {
 
     @Test
     public void should_capture_arguments() throws Exception {
-        //given
-        CapturingMatcher<String> m = new CapturingMatcher<String>();
+        // given
+        CapturingMatcher<String> m = new CapturingMatcher<String>(String.class);
 
-        //when
+        // when
         m.captureFrom("foo");
         m.captureFrom("bar");
 
-        //then
+        // then
         assertThat(m.getAllValues()).containsSequence("foo", "bar");
     }
 
     @Test
     public void should_know_last_captured_value() throws Exception {
-        //given
-        CapturingMatcher<String> m = new CapturingMatcher<String>();
+        // given
+        CapturingMatcher<String> m = new CapturingMatcher<String>(String.class);
 
-        //when
+        // when
         m.captureFrom("foo");
         m.captureFrom("bar");
 
-        //then
+        // then
         assertEquals("bar", m.getLastValue());
     }
 
     @Test
     public void should_scream_when_nothing_yet_captured() throws Exception {
-        //given
-        CapturingMatcher<String> m = new CapturingMatcher<String>();
+        // given
+        CapturingMatcher<String> m = new CapturingMatcher<String>(String.class);
 
         try {
-            //when
+            // when
             m.getLastValue();
-            //then
+            // then
             fail();
-        } catch (MockitoException e) {}
+        } catch (MockitoException e) {
+        }
     }
 
     @Test
     public void should_not_fail_when_used_in_concurrent_tests() throws Exception {
-        //given
-        final CapturingMatcher<String> m = new CapturingMatcher<String>();
+        // given
+        final CapturingMatcher<String> m = new CapturingMatcher<String>(String.class);
 
-        //when
+        // when
         m.captureFrom("concurrent access");
         Iterator<String> iterator = m.getAllValues().iterator();
         m.captureFrom("concurrent access");
 
-        //then
+        // then
         assertThat(iterator.hasNext()).isTrue();
-        assertThat(iterator.next()).isEqualTo("concurrent access"); // Potential ConcurrentModificationException
+        assertThat(iterator.next())
+                .isEqualTo("concurrent access"); // Potential ConcurrentModificationException
     }
-
 }
diff --git a/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
similarity index 89%
rename from src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
index 64236c4414..583a84839e 100644
--- a/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
@@ -43,8 +43,12 @@ public void testCompareEqual() {
         assertTrue(cmpEq.matches(new BigDecimal("5")));
     }
 
-    private void test(CompareTo<String> compareTo, boolean lower, boolean higher,
-            boolean equals, String name) {
+    private void test(
+            CompareTo<String> compareTo,
+            boolean lower,
+            boolean higher,
+            boolean equals,
+            String name) {
 
         assertEquals(lower, compareTo.matches("a"));
         assertEquals(equals, compareTo.matches("b"));
diff --git a/src/test/java/org/mockito/internal/matchers/EqualityTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/EqualityTest.java
similarity index 90%
rename from src/test/java/org/mockito/internal/matchers/EqualityTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/EqualityTest.java
index 6f0f71be20..81f1f6888f 100644
--- a/src/test/java/org/mockito/internal/matchers/EqualityTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/EqualityTest.java
@@ -23,14 +23,15 @@ public void shouldKnowIfObjectsAreEqual() throws Exception {
         assertTrue(areEqual(new Object[10], new Object[10]));
         assertTrue(areEqual(new int[] {1}, new Integer[] {1}));
         assertTrue(areEqual(new Object[] {"1"}, new String[] {"1"}));
-        Object badequals=new BadEquals();
-        assertTrue(areEqual(badequals,badequals));
+        Object badequals = new BadEquals();
+        assertTrue(areEqual(badequals, badequals));
 
         assertFalse(areEqual(new Object[9], new Object[10]));
         assertFalse(areEqual(new int[] {1, 2}, new int[] {1}));
         assertFalse(areEqual(new int[] {1}, new double[] {1.0}));
     }
 
+    @SuppressWarnings("EqualsHashCode")
     private final class BadEquals {
         @Override
         public boolean equals(Object oth) {
diff --git a/src/test/java/org/mockito/internal/matchers/EqualsTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/EqualsTest.java
similarity index 76%
rename from src/test/java/org/mockito/internal/matchers/EqualsTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/EqualsTest.java
index 072241459c..e56de2a9c2 100644
--- a/src/test/java/org/mockito/internal/matchers/EqualsTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/EqualsTest.java
@@ -4,12 +4,13 @@
  */
 package org.mockito.internal.matchers;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.*;
 
 import org.junit.Test;
+import org.mockito.ArgumentMatcher;
 import org.mockitoutil.TestBase;
 
-
 public class EqualsTest extends TestBase {
 
     @Test
@@ -29,21 +30,21 @@ public void shouldArraysBeEqual() {
 
     @Test
     public void shouldDescribeWithExtraTypeInfo() throws Exception {
-        String descStr = new Equals(100).toStringWithType();
+        String descStr = new Equals(100).toStringWithType(Integer.class.getSimpleName());
 
         assertEquals("(Integer) 100", descStr);
     }
 
     @Test
     public void shouldDescribeWithExtraTypeInfoOfLong() throws Exception {
-        String descStr = new Equals(100L).toStringWithType();
+        String descStr = new Equals(100L).toStringWithType(Long.class.getSimpleName());
 
         assertEquals("(Long) 100L", descStr);
     }
 
     @Test
     public void shouldDescribeWithTypeOfString() throws Exception {
-        String descStr = new Equals("x").toStringWithType();
+        String descStr = new Equals("x").toStringWithType(String.class.getSimpleName());
 
         assertEquals("(String) \"x\"", descStr);
     }
@@ -78,29 +79,40 @@ public void shouldDescribeNull() {
 
     @Test
     public void shouldMatchTypes() throws Exception {
-        //when
+        // when
         ContainsExtraTypeInfo equals = new Equals(10);
 
-        //then
+        // then
         assertTrue(equals.typeMatches(10));
         assertFalse(equals.typeMatches(10L));
     }
 
     @Test
     public void shouldMatchTypesSafelyWhenActualIsNull() throws Exception {
-        //when
+        // when
         ContainsExtraTypeInfo equals = new Equals(null);
 
-        //then
+        // then
         assertFalse(equals.typeMatches(10));
     }
 
     @Test
     public void shouldMatchTypesSafelyWhenGivenIsNull() throws Exception {
-        //when
+        // when
         ContainsExtraTypeInfo equals = new Equals(10);
 
-        //then
+        // then
         assertFalse(equals.typeMatches(null));
     }
+
+    @Test
+    public void shouldInferType() {
+        assertThat(new Equals("String").type()).isEqualTo(String.class);
+    }
+
+    @Test
+    public void shouldDefaultTypeOnNull() {
+        assertThat(new Equals(null).type())
+                .isEqualTo(((ArgumentMatcher<Object>) argument -> false).type());
+    }
 }
diff --git a/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
similarity index 81%
rename from src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
index bc3e37d3a8..7740d0b77d 100644
--- a/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
@@ -15,11 +15,10 @@ public class InstanceOfTest {
 
     @Test
     public void should_describe_the_matcher() {
-        assertThat(new InstanceOf(Object.class).toString()).contains("isA")
-                                                           .contains("Object");
-        assertThat(new InstanceOf(Object[].class).toString()).contains("isA")
-                                                           .contains("Object[]");
-        assertThat(new InstanceOf(Object.class, "matches something").toString()).isEqualTo("matches something");
+        assertThat(new InstanceOf(Object.class).toString()).contains("isA").contains("Object");
+        assertThat(new InstanceOf(Object[].class).toString()).contains("isA").contains("Object[]");
+        assertThat(new InstanceOf(Object.class, "matches something").toString())
+                .isEqualTo("matches something");
     }
 
     @Test
@@ -60,9 +59,8 @@ public void should_check_for_primitive_wrapper_types() {
 
     @Test
     public void can_be_vararg_aware() {
-        assertThat(new InstanceOf.VarArgAware(Number[].class)).isInstanceOf(VarargMatcher.class);
-        assertThat(new InstanceOf.VarArgAware(Number[].class).matches(new Integer[0])).isTrue();
-        assertThat(new InstanceOf.VarArgAware(Number[].class).matches(new Number[0])).isTrue();
-        assertThat(new InstanceOf.VarArgAware(Number[].class).matches(new Object[0])).isFalse();
+        assertThat(new InstanceOf(Number[].class).matches(new Integer[0])).isTrue();
+        assertThat(new InstanceOf(Number[].class).matches(new Number[0])).isTrue();
+        assertThat(new InstanceOf(Number[].class).matches(new Object[0])).isFalse();
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
new file mode 100644
index 0000000000..74cfd9dff7
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.internal.matchers.text.MatchersPrinter;
+import org.mockito.internal.reporting.PrintSettings;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class MatchersPrinterTest extends TestBase {
+
+    private final MatchersPrinter printer = new MatchersPrinter();
+
+    @Test
+    public void shouldGetArgumentsLine() {
+        String line =
+                printer.getArgumentsLine(
+                        (List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
+        assertEquals("(1, 2);", line);
+    }
+
+    @Test
+    public void shouldGetArgumentsBlock() {
+        String line =
+                printer.getArgumentsBlock(
+                        (List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
+        assertEquals("(\n    1,\n    2\n);", line);
+    }
+
+    @Test
+    public void shouldDescribeTypeInfoOnlyMarkedMatchers() {
+        // when
+        String line =
+                printer.getArgumentsLine(
+                        (List) Arrays.asList(new Equals(1L), new Equals(2)),
+                        PrintSettings.verboseMatchers(1));
+        // then
+        assertEquals("(1L, (Integer) 2);", line);
+    }
+
+    @Test
+    public void shouldDescribeStringMatcher() {
+        // when
+        String line =
+                printer.getArgumentsLine(
+                        (List) Arrays.asList(new Equals(1L), new Equals("x")),
+                        PrintSettings.verboseMatchers(1));
+        // then
+        assertEquals("(1L, (String) \"x\");", line);
+    }
+
+    @Test
+    public void shouldGetVerboseArgumentsInBlock() {
+        // when
+        String line =
+                printer.getArgumentsBlock(
+                        (List) Arrays.asList(new Equals(1L), new Equals(2)),
+                        PrintSettings.verboseMatchers(0, 1));
+        // then
+        assertEquals("(\n    (Long) 1L,\n    (Integer) 2\n);", line);
+    }
+
+    @Test
+    public void shouldGetVerboseArgumentsEvenIfSomeMatchersAreNotVerbose() {
+        // when
+        String line =
+                printer.getArgumentsLine(
+                        (List) Arrays.asList(new Equals(1L), NotNull.NOT_NULL),
+                        PrintSettings.verboseMatchers(0));
+        // then
+        assertEquals("((Long) 1L, notNull());", line);
+    }
+}
diff --git a/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
similarity index 76%
rename from src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
index 6c038079ae..6d243a0997 100644
--- a/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
@@ -41,19 +41,19 @@ public void sameToStringWithChar() {
 
     @Test
     public void sameToStringWithObject() {
-        Object o = new Object() {
-            @Override
-            public String toString() {
-                return "X";
-            }
-        };
+        Object o =
+                new Object() {
+                    @Override
+                    public String toString() {
+                        return "X";
+                    }
+                };
         assertEquals("same(X)", new Same(o).toString());
     }
 
     @Test
     public void equalsToStringWithString() {
         assertEquals("\"X\"", new Equals("X").toString());
-
     }
 
     @Test
@@ -63,20 +63,21 @@ public void equalsToStringWithChar() {
 
     @Test
     public void equalsToStringWithObject() {
-        Object o = new Object() {
-            @Override
-            public String toString() {
-                return "X";
-            }
-        };
+        Object o =
+                new Object() {
+                    @Override
+                    public String toString() {
+                        return "X";
+                    }
+                };
         assertEquals("X", new Equals(o).toString());
     }
 
     @Test
     public void orToString() {
-        ArgumentMatcher<?> m1=new Equals(1);
-        ArgumentMatcher<?> m2=new Equals(2);
-        assertEquals("or(1, 2)", new Or(m1,m2).toString());
+        ArgumentMatcher<?> m1 = new Equals(1);
+        ArgumentMatcher<?> m2 = new Equals(2);
+        assertEquals("or(1, 2)", new Or(m1, m2).toString());
     }
 
     @Test
@@ -86,9 +87,9 @@ public void notToString() {
 
     @Test
     public void andToString() {
-        ArgumentMatcher<?> m1=new Equals(1);
-        ArgumentMatcher<?> m2=new Equals(2);
-        assertEquals("and(1, 2)", new And(m1,m2).toString());
+        ArgumentMatcher<?> m1 = new Equals(1);
+        ArgumentMatcher<?> m2 = new Equals(2);
+        assertEquals("and(1, 2)", new And(m1, m2).toString());
     }
 
     @Test
@@ -116,5 +117,4 @@ public void matchesToString() {
         assertEquals("matches(\"\\\\s+\")", new Matches("\\s+").toString());
         assertEquals("matches(\"\\\\s+\")", new Matches(Pattern.compile("\\s+")).toString());
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/matchers/OrTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/OrTest.java
new file mode 100644
index 0000000000..6738d73507
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/OrTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+
+public class OrTest extends TestBase {
+
+    @Mock private ArgumentMatcher<?> m1;
+    @Mock private ArgumentMatcher<?> m2;
+    private Or or;
+
+    @Before
+    public void setUp() throws Exception {
+        or = new Or(m1, m2);
+    }
+
+    @Test
+    public void shouldReturnMatchingTypes() {
+        given(m1.type()).will(inv -> String.class);
+        given(m2.type()).will(inv -> String.class);
+
+        assertThat(or.type()).isEqualTo(String.class);
+    }
+
+    @Test
+    public void shouldDefaultMismatchingTypes() {
+        given(m1.type()).will(inv -> String.class);
+        given(m2.type()).will(inv -> Integer.class);
+
+        assertThat(or.type()).isEqualTo(Void.class);
+    }
+
+    @Test
+    public void shouldReturnLeftBaseType() {
+        given(m1.type()).will(inv -> BaseType.class);
+        given(m2.type()).will(inv -> SubType.class);
+
+        assertThat(or.type()).isEqualTo(BaseType.class);
+    }
+
+    @Test
+    public void shouldReturnRightBaseType() {
+        given(m1.type()).will(inv -> SubType.class);
+        given(m2.type()).will(inv -> BaseType.class);
+
+        assertThat(or.type()).isEqualTo(BaseType.class);
+    }
+
+    private interface BaseType {}
+
+    private interface SubType extends BaseType {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/matchers/SameTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/SameTest.java
new file mode 100644
index 0000000000..d5c6a1f9c8
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/SameTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers;
+
+import org.mockitoutil.TestBase;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SameTest extends TestBase {
+
+    @Test
+    public void shouldInferType() {
+        assertThat(new Same("String").type()).isEqualTo(String.class);
+    }
+
+    @Test
+    public void shouldDefaultTypeOnNull() {
+        assertThat(new Same(null).type())
+                .isEqualTo(((ArgumentMatcher<Object>) argument -> false).type());
+    }
+}
diff --git a/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
similarity index 99%
rename from src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
index 32dbc4f8f5..f3bd2ae3eb 100644
--- a/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
@@ -73,5 +73,4 @@ public void doesNotMatchRegex() {
     public void nullDoesNotMatchRegex() {
         assertFalse(new Find("eleph.nt").matches(null));
     }
-
 }
diff --git a/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
similarity index 79%
rename from src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
index 513092f220..53f34109ba 100644
--- a/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
@@ -23,20 +23,24 @@
 public class EqualsBuilderTest extends TestBase {
 
     @Test
-    public void testname() throws Exception {
-
-    }
+    public void testname() throws Exception {}
 
     static class TestObject {
         private int a;
-        public TestObject() {
-        }
+
+        public TestObject() {}
+
         public TestObject(int a) {
             this.a = a;
         }
+
         public boolean equals(Object o) {
-            if (o == null) { return false; }
-            if (o == this) { return true; }
+            if (o == null) {
+                return false;
+            }
+            if (o == this) {
+                return true;
+            }
             if (o.getClass() != getClass()) {
                 return false;
             }
@@ -44,6 +48,7 @@ public boolean equals(Object o) {
             TestObject rhs = (TestObject) o;
             return (a == rhs.a);
         }
+
         public int hashCode() {
             return super.hashCode();
         }
@@ -59,16 +64,23 @@ public int getA() {
 
     static class TestSubObject extends TestObject {
         private int b;
+
         public TestSubObject() {
             super(0);
         }
+
         public TestSubObject(int a, int b) {
             super(a);
             this.b = b;
         }
+
         public boolean equals(Object o) {
-            if (o == null) { return false; }
-            if (o == this) { return true; }
+            if (o == null) {
+                return false;
+            }
+            if (o == this) {
+                return true;
+            }
             if (o.getClass() != getClass()) {
                 return false;
             }
@@ -76,6 +88,7 @@ public boolean equals(Object o) {
             TestSubObject rhs = (TestSubObject) o;
             return super.equals(o) && (b == rhs.b);
         }
+
         public int hashCode() {
             return 1;
         }
@@ -98,6 +111,7 @@ public TestEmptySubObject(int a) {
     @SuppressWarnings("unused")
     static class TestTSubObject extends TestObject {
         private transient int t;
+
         public TestTSubObject(int a, int t) {
             super(a);
             this.t = t;
@@ -107,6 +121,7 @@ public TestTSubObject(int a, int t) {
     @SuppressWarnings("unused")
     static class TestTTSubObject extends TestTSubObject {
         private transient int tt;
+
         public TestTTSubObject(int a, int t, int tt) {
             super(a, t);
             this.tt = tt;
@@ -116,6 +131,7 @@ public TestTTSubObject(int a, int t, int tt) {
     @SuppressWarnings("unused")
     static class TestTTLeafObject extends TestTTSubObject {
         private int leafValue;
+
         public TestTTLeafObject(int a, int t, int tt, int leafValue) {
             super(a, t, tt);
             this.leafValue = leafValue;
@@ -124,18 +140,22 @@ public TestTTLeafObject(int a, int t, int tt, int leafValue) {
 
     static class TestTSubObject2 extends TestObject {
         private transient int t;
+
         public TestTSubObject2(int a, int t) {
             super(a);
         }
+
         public int getT() {
             return t;
         }
+
         public void setT(int t) {
             this.t = t;
         }
     }
 
-    @Test public void testReflectionEquals() {
+    @Test
+    public void testReflectionEquals() {
         TestObject o1 = new TestObject(4);
         TestObject o2 = new TestObject(5);
         assertTrue(EqualsBuilder.reflectionEquals(o1, o1));
@@ -150,18 +170,29 @@ public void setT(int t) {
         assertTrue(EqualsBuilder.reflectionEquals((Object) null, (Object) null));
     }
 
-    @Test public void testReflectionHierarchyEquals() {
+    @Test
+    public void testReflectionHierarchyEquals() {
         testReflectionHierarchyEquals(false);
         testReflectionHierarchyEquals(true);
         // Transients
-        assertTrue(EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
-        assertTrue(EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), false));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 0, 0, 4), new TestTTLeafObject(1, 2, 3, 4), true));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 0), true));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestTTLeafObject(0, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), false));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestTTLeafObject(1, 0, 0, 4), new TestTTLeafObject(1, 2, 3, 4), true));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 0), true));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestTTLeafObject(0, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
     }
 
-  private void testReflectionHierarchyEquals(boolean testTransients) {
+    private void testReflectionHierarchyEquals(boolean testTransients) {
         TestObject to1 = new TestObject(4);
         TestObject to1Bis = new TestObject(4);
         TestObject to1Ter = new TestObject(4);
@@ -175,43 +206,79 @@ private void testReflectionHierarchyEquals(boolean testTransients) {
         TestSubObject tso1ter = new TestSubObject(1, 4);
         TestSubObject tso2 = new TestSubObject(2, 5);
 
-        testReflectionEqualsEquivalenceRelationship(to1, to1Bis, to1Ter, to2, new TestObject(), testTransients);
-        testReflectionEqualsEquivalenceRelationship(tso1, tso1bis, tso1ter, tso2, new TestSubObject(), testTransients);
+        testReflectionEqualsEquivalenceRelationship(
+                to1, to1Bis, to1Ter, to2, new TestObject(), testTransients);
+        testReflectionEqualsEquivalenceRelationship(
+                tso1, tso1bis, tso1ter, tso2, new TestSubObject(), testTransients);
 
         // More sanity checks:
 
         // same values
         assertTrue(EqualsBuilder.reflectionEquals(ttlo, ttlo, testTransients));
-        assertTrue(EqualsBuilder.reflectionEquals(new TestSubObject(1, 10), new TestSubObject(1, 10), testTransients));
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        new TestSubObject(1, 10), new TestSubObject(1, 10), testTransients));
         // same super values, diff sub values
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(1, 10), new TestSubObject(1, 11), testTransients));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(1, 11), new TestSubObject(1, 10), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestSubObject(1, 10), new TestSubObject(1, 11), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestSubObject(1, 11), new TestSubObject(1, 10), testTransients));
         // diff super values, same sub values
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(0, 10), new TestSubObject(1, 10), testTransients));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(1, 10), new TestSubObject(0, 10), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestSubObject(0, 10), new TestSubObject(1, 10), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestSubObject(1, 10), new TestSubObject(0, 10), testTransients));
 
         // mix super and sub types: equals
         assertTrue(EqualsBuilder.reflectionEquals(to1, teso, testTransients));
         assertTrue(EqualsBuilder.reflectionEquals(teso, to1, testTransients));
 
-        assertTrue(EqualsBuilder.reflectionEquals(to1, ttso, false)); // Force testTransients = false for this assert
-        assertTrue(EqualsBuilder.reflectionEquals(ttso, to1, false)); // Force testTransients = false for this assert
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        to1, ttso, false)); // Force testTransients = false for this assert
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        ttso, to1, false)); // Force testTransients = false for this assert
 
-        assertTrue(EqualsBuilder.reflectionEquals(to1, tttso, false)); // Force testTransients = false for this assert
-        assertTrue(EqualsBuilder.reflectionEquals(tttso, to1, false)); // Force testTransients = false for this assert
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        to1, tttso, false)); // Force testTransients = false for this assert
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        tttso, to1, false)); // Force testTransients = false for this assert
 
-        assertTrue(EqualsBuilder.reflectionEquals(ttso, tttso, false)); // Force testTransients = false for this assert
-        assertTrue(EqualsBuilder.reflectionEquals(tttso, ttso, false)); // Force testTransients = false for this assert
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        ttso, tttso, false)); // Force testTransients = false for this assert
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        tttso, ttso, false)); // Force testTransients = false for this assert
 
         // mix super and sub types: NOT equals
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestObject(0), new TestEmptySubObject(1), testTransients));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestEmptySubObject(1), new TestObject(0), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestObject(0), new TestEmptySubObject(1), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestEmptySubObject(1), new TestObject(0), testTransients));
 
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestObject(0), new TestTSubObject(1, 1), testTransients));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestTSubObject(1, 1), new TestObject(0), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestObject(0), new TestTSubObject(1, 1), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestTSubObject(1, 1), new TestObject(0), testTransients));
 
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestObject(1), new TestSubObject(0, 10), testTransients));
-        assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(0, 10), new TestObject(1), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestObject(1), new TestSubObject(0, 10), testTransients));
+        assertTrue(
+                !EqualsBuilder.reflectionEquals(
+                        new TestSubObject(0, 10), new TestObject(1), testTransients));
 
         assertTrue(!EqualsBuilder.reflectionEquals(to1, ttlo));
         assertTrue(!EqualsBuilder.reflectionEquals(tso1, this));
@@ -233,25 +300,27 @@ private void testReflectionHierarchyEquals(boolean testTransients) {
      * @param oToChange a TestObject that will be changed
      */
     private void testReflectionEqualsEquivalenceRelationship(
-        TestObject to,
-        TestObject toBis,
-        TestObject toTer,
-        TestObject to2,
-        TestObject oToChange,
-        boolean testTransients) {
+            TestObject to,
+            TestObject toBis,
+            TestObject toTer,
+            TestObject to2,
+            TestObject oToChange,
+            boolean testTransients) {
 
         // reflection test
         assertTrue(EqualsBuilder.reflectionEquals(to, to, testTransients));
         assertTrue(EqualsBuilder.reflectionEquals(to2, to2, testTransients));
 
         // symmetry test
-        assertTrue(EqualsBuilder.reflectionEquals(to, toBis, testTransients) && EqualsBuilder.reflectionEquals(toBis, to, testTransients));
+        assertTrue(
+                EqualsBuilder.reflectionEquals(to, toBis, testTransients)
+                        && EqualsBuilder.reflectionEquals(toBis, to, testTransients));
 
         // transitive test
         assertTrue(
-            EqualsBuilder.reflectionEquals(to, toBis, testTransients)
-                && EqualsBuilder.reflectionEquals(toBis, toTer, testTransients)
-                && EqualsBuilder.reflectionEquals(to, toTer, testTransients));
+                EqualsBuilder.reflectionEquals(to, toBis, testTransients)
+                        && EqualsBuilder.reflectionEquals(toBis, toTer, testTransients)
+                        && EqualsBuilder.reflectionEquals(to, toTer, testTransients));
 
         // consistency test
         oToChange.setA(to.getA());
@@ -275,7 +344,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(EqualsBuilder.reflectionEquals((Object) null, (Object) null, testTransients));
     }
 
-    @Test public void testSuper() {
+    @Test
+    public void testSuper() {
         TestObject o1 = new TestObject(4);
         TestObject o2 = new TestObject(5);
         assertEquals(true, new EqualsBuilder().appendSuper(true).append(o1, o1).isEquals());
@@ -284,7 +354,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertEquals(false, new EqualsBuilder().appendSuper(false).append(o1, o2).isEquals());
     }
 
-    @Test public void testObject() {
+    @Test
+    public void testObject() {
         TestObject o1 = new TestObject(4);
         TestObject o2 = new TestObject(5);
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
@@ -299,70 +370,85 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append((Object) null, (Object) null).isEquals());
     }
 
-    @Test public void testLong() {
+    @Test
+    public void testLong() {
         long o1 = 1L;
         long o2 = 2L;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testInt() {
+    @Test
+    public void testInt() {
         int o1 = 1;
         int o2 = 2;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testShort() {
+    @Test
+    public void testShort() {
         short o1 = 1;
         short o2 = 2;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testChar() {
+    @Test
+    public void testChar() {
         char o1 = 1;
         char o2 = 2;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testByte() {
+    @Test
+    public void testByte() {
         byte o1 = 1;
         byte o2 = 2;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testDouble() {
+    @Test
+    public void testDouble() {
         double o1 = 1;
         double o2 = 2;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, Double.NaN).isEquals());
         assertTrue(new EqualsBuilder().append(Double.NaN, Double.NaN).isEquals());
-        assertTrue(new EqualsBuilder().append(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY).isEquals());
+        assertTrue(
+                new EqualsBuilder()
+                        .append(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)
+                        .isEquals());
     }
 
-    @Test public void testFloat() {
+    @Test
+    public void testFloat() {
         float o1 = 1;
         float o2 = 2;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, Float.NaN).isEquals());
         assertTrue(new EqualsBuilder().append(Float.NaN, Float.NaN).isEquals());
-        assertTrue(new EqualsBuilder().append(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY).isEquals());
+        assertTrue(
+                new EqualsBuilder()
+                        .append(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)
+                        .isEquals());
     }
 
     // https://issues.apache.org/jira/browse/LANG-393
-    @Test public void testBigDecimal() {
+    @Test
+    public void testBigDecimal() {
         BigDecimal o1 = new BigDecimal("2.0");
         BigDecimal o2 = new BigDecimal("2.00");
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testAccessors() {
+    @Test
+    public void testAccessors() {
         EqualsBuilder equalsBuilder = new EqualsBuilder();
         assertTrue(equalsBuilder.isEquals());
         equalsBuilder.setEquals(true);
@@ -371,14 +457,16 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertFalse(equalsBuilder.isEquals());
     }
 
-    @Test public void testBoolean() {
+    @Test
+    public void testBoolean() {
         boolean o1 = true;
         boolean o2 = false;
         assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
         assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
     }
 
-    @Test public void testObjectArray() {
+    @Test
+    public void testObjectArray() {
         TestObject[] obj1 = new TestObject[3];
         obj1[0] = new TestObject(4);
         obj1[1] = new TestObject(5);
@@ -406,7 +494,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testLongArray() {
+    @Test
+    public void testLongArray() {
         long[] obj1 = new long[2];
         obj1[0] = 5L;
         obj1[1] = 6L;
@@ -424,7 +513,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testIntArray() {
+    @Test
+    public void testIntArray() {
         int[] obj1 = new int[2];
         obj1[0] = 5;
         obj1[1] = 6;
@@ -442,7 +532,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testShortArray() {
+    @Test
+    public void testShortArray() {
         short[] obj1 = new short[2];
         obj1[0] = 5;
         obj1[1] = 6;
@@ -460,7 +551,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testCharArray() {
+    @Test
+    public void testCharArray() {
         char[] obj1 = new char[2];
         obj1[0] = 5;
         obj1[1] = 6;
@@ -478,7 +570,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testByteArray() {
+    @Test
+    public void testByteArray() {
         byte[] obj1 = new byte[2];
         obj1[0] = 5;
         obj1[1] = 6;
@@ -496,7 +589,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testDoubleArray() {
+    @Test
+    public void testDoubleArray() {
         double[] obj1 = new double[2];
         obj1[0] = 5;
         obj1[1] = 6;
@@ -514,7 +608,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testFloatArray() {
+    @Test
+    public void testFloatArray() {
         float[] obj1 = new float[2];
         obj1[0] = 5;
         obj1[1] = 6;
@@ -532,7 +627,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testBooleanArray() {
+    @Test
+    public void testBooleanArray() {
         boolean[] obj1 = new boolean[2];
         obj1[0] = true;
         obj1[1] = false;
@@ -550,7 +646,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testMultiLongArray() {
+    @Test
+    public void testMultiLongArray() {
         long[][] array1 = new long[2][2];
         long[][] array2 = new long[2][2];
         for (int i = 0; i < array1.length; ++i) {
@@ -565,7 +662,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMultiIntArray() {
+    @Test
+    public void testMultiIntArray() {
         int[][] array1 = new int[2][2];
         int[][] array2 = new int[2][2];
         for (int i = 0; i < array1.length; ++i) {
@@ -580,7 +678,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMultiShortArray() {
+    @Test
+    public void testMultiShortArray() {
         short[][] array1 = new short[2][2];
         short[][] array2 = new short[2][2];
         for (short i = 0; i < array1.length; ++i) {
@@ -595,7 +694,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMultiCharArray() {
+    @Test
+    public void testMultiCharArray() {
         char[][] array1 = new char[2][2];
         char[][] array2 = new char[2][2];
         for (char i = 0; i < array1.length; ++i) {
@@ -610,7 +710,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMultiByteArray() {
+    @Test
+    public void testMultiByteArray() {
         byte[][] array1 = new byte[2][2];
         byte[][] array2 = new byte[2][2];
         for (byte i = 0; i < array1.length; ++i) {
@@ -624,7 +725,9 @@ private void testReflectionEqualsEquivalenceRelationship(
         array1[1][1] = 0;
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
-    @Test public void testMultiFloatArray() {
+
+    @Test
+    public void testMultiFloatArray() {
         float[][] array1 = new float[2][2];
         float[][] array2 = new float[2][2];
         for (int i = 0; i < array1.length; ++i) {
@@ -639,7 +742,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMultiDoubleArray() {
+    @Test
+    public void testMultiDoubleArray() {
         double[][] array1 = new double[2][2];
         double[][] array2 = new double[2][2];
         for (int i = 0; i < array1.length; ++i) {
@@ -654,7 +758,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMultiBooleanArray() {
+    @Test
+    public void testMultiBooleanArray() {
         boolean[][] array1 = new boolean[2][2];
         boolean[][] array2 = new boolean[2][2];
         for (int i = 0; i < array1.length; ++i) {
@@ -669,14 +774,15 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
 
         // compare 1 dim to 2.
-        boolean[] array3 = new boolean[]{true, true};
+        boolean[] array3 = new boolean[] {true, true};
         assertFalse(new EqualsBuilder().append(array1, array3).isEquals());
         assertFalse(new EqualsBuilder().append(array3, array1).isEquals());
         assertFalse(new EqualsBuilder().append(array2, array3).isEquals());
         assertFalse(new EqualsBuilder().append(array3, array2).isEquals());
     }
 
-    @Test public void testRaggedArray() {
+    @Test
+    public void testRaggedArray() {
         long[][] array1 = new long[2][];
         long[][] array2 = new long[2][];
         for (int i = 0; i < array1.length; ++i) {
@@ -693,7 +799,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testMixedArray() {
+    @Test
+    public void testMixedArray() {
         Object[] array1 = new Object[2];
         Object[] array2 = new Object[2];
         for (int i = 0; i < array1.length; ++i) {
@@ -710,7 +817,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
     }
 
-    @Test public void testObjectArrayHiddenByObject() {
+    @Test
+    public void testObjectArrayHiddenByObject() {
         TestObject[] array1 = new TestObject[2];
         array1[0] = new TestObject(4);
         array1[1] = new TestObject(5);
@@ -727,7 +835,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testLongArrayHiddenByObject() {
+    @Test
+    public void testLongArrayHiddenByObject() {
         long[] array1 = new long[2];
         array1[0] = 5L;
         array1[1] = 6L;
@@ -744,7 +853,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testIntArrayHiddenByObject() {
+    @Test
+    public void testIntArrayHiddenByObject() {
         int[] array1 = new int[2];
         array1[0] = 5;
         array1[1] = 6;
@@ -761,7 +871,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testShortArrayHiddenByObject() {
+    @Test
+    public void testShortArrayHiddenByObject() {
         short[] array1 = new short[2];
         array1[0] = 5;
         array1[1] = 6;
@@ -778,7 +889,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testCharArrayHiddenByObject() {
+    @Test
+    public void testCharArrayHiddenByObject() {
         char[] array1 = new char[2];
         array1[0] = 5;
         array1[1] = 6;
@@ -795,7 +907,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testByteArrayHiddenByObject() {
+    @Test
+    public void testByteArrayHiddenByObject() {
         byte[] array1 = new byte[2];
         array1[0] = 5;
         array1[1] = 6;
@@ -812,7 +925,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testDoubleArrayHiddenByObject() {
+    @Test
+    public void testDoubleArrayHiddenByObject() {
         double[] array1 = new double[2];
         array1[0] = 5;
         array1[1] = 6;
@@ -829,7 +943,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testFloatArrayHiddenByObject() {
+    @Test
+    public void testFloatArrayHiddenByObject() {
         float[] array1 = new float[2];
         array1[0] = 5;
         array1[1] = 6;
@@ -846,7 +961,8 @@ private void testReflectionEqualsEquivalenceRelationship(
         assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
     }
 
-    @Test public void testBooleanArrayHiddenByObject() {
+    @Test
+    public void testBooleanArrayHiddenByObject() {
         boolean[] array1 = new boolean[2];
         array1[0] = true;
         array1[1] = false;
@@ -882,6 +998,7 @@ public boolean equals(Object o) {
             }
             return false;
         }
+
         public int hashCode() {
             return 1;
         }
@@ -910,6 +1027,7 @@ public boolean equals(Object o) {
             }
             return false;
         }
+
         public int hashCode() {
             return 1;
         }
@@ -924,9 +1042,10 @@ public int getB() {
      * of each other and do not share a parent aside from Object.
      * See http://issues.apache.org/bugzilla/show_bug.cgi?id=33069
      */
-    @Test public void testUnrelatedClasses() {
-        Object[] x = new Object[]{new TestACanEqualB(1)};
-        Object[] y = new Object[]{new TestBCanEqualA(1)};
+    @Test
+    public void testUnrelatedClasses() {
+        Object[] x = new Object[] {new TestACanEqualB(1)};
+        Object[] y = new Object[] {new TestBCanEqualA(1)};
 
         // sanity checks:
         assertTrue(Arrays.equals(x, x));
@@ -945,18 +1064,20 @@ public int getB() {
     }
 
     /**
-     * Test from http://issues.apache.org/bugzilla/show_bug.cgi?id=33067
+     * Test from https://issues.apache.org/jira/browse/LANG-42
      */
-    @Test public void testNpeForNullElement() {
-        Object[] x1 = new Object[] { new Integer(1), null, new Integer(3) };
-        Object[] x2 = new Object[] { new Integer(1), new Integer(2), new Integer(3) };
+    @Test
+    public void testNpeForNullElement() {
+        Object[] x1 = new Object[] {new Integer(1), null, new Integer(3)};
+        Object[] x2 = new Object[] {new Integer(1), new Integer(2), new Integer(3)};
 
         // causes an NPE in 2.0 according to:
-        // http://issues.apache.org/bugzilla/show_bug.cgi?id=33067
+        // https://issues.apache.org/jira/browse/LANG-42
         new EqualsBuilder().append(x1, x2);
     }
 
-    @Test public void testReflectionEqualsExcludeFields() throws Exception {
+    @Test
+    public void testReflectionEqualsExcludeFields() throws Exception {
         TestObjectWithMultipleFields x1 = new TestObjectWithMultipleFields(1, 2, 3);
         TestObjectWithMultipleFields x2 = new TestObjectWithMultipleFields(1, 3, 4);
 
@@ -977,7 +1098,9 @@ public int getB() {
 
         // still equal as long as both differing fields are among excluded
         assertTrue(EqualsBuilder.reflectionEquals(x1, x2, new String[] {"one", "two", "three"}));
-        assertTrue(EqualsBuilder.reflectionEquals(x1, x2, new String[] {"one", "two", "three", "xxx"}));
+        assertTrue(
+                EqualsBuilder.reflectionEquals(
+                        x1, x2, new String[] {"one", "two", "three", "xxx"}));
     }
 
     @SuppressWarnings("unused")
diff --git a/mockito-core/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
new file mode 100644
index 0000000000..746ee69ea3
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers.text;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockitoutil.TestBase;
+
+public class MatcherToStringTest extends TestBase {
+
+    static class MatcherWithoutDescription implements ArgumentMatcher<Object> {
+        @Override
+        public boolean matches(Object argument) {
+            return false;
+        }
+    }
+
+    static class MatcherWithDescription implements ArgumentMatcher<Object> {
+        @Override
+        public boolean matches(Object argument) {
+            return false;
+        }
+
+        @Override
+        public String toString() {
+            return "*my custom description*";
+        }
+    }
+
+    static class MatcherWithInheritedDescription extends MatcherWithDescription {
+        @Override
+        public boolean matches(Object argument) {
+            return false;
+        }
+    }
+
+    @Test
+    public void better_toString_for_matchers() {
+        assertEquals(
+                "<Matcher without description>",
+                MatcherToString.toString(new MatcherWithoutDescription()));
+        assertEquals(
+                "*my custom description*", MatcherToString.toString(new MatcherWithDescription()));
+        assertEquals(
+                "*my custom description*",
+                MatcherToString.toString(new MatcherWithInheritedDescription()));
+    }
+
+    @Test
+    public void default_name_for_anonymous_matchers() {
+        ArgumentMatcher<Object> anonymousMatcher =
+                new ArgumentMatcher<Object>() {
+                    @Override
+                    public boolean matches(Object argument) {
+                        return false;
+                    }
+                };
+        assertEquals("<custom argument matcher>", MatcherToString.toString(anonymousMatcher));
+
+        ArgumentMatcher<Object> anonymousDescriptiveMatcher =
+                new MatcherWithDescription() {
+                    @Override
+                    public boolean matches(Object argument) {
+                        return false;
+                    }
+                };
+        assertEquals(
+                "*my custom description*", MatcherToString.toString(anonymousDescriptiveMatcher));
+    }
+
+    @Test
+    public void default_name_for_synthetic_matchers() {
+        ArgumentMatcher<Object> lambdaMatcher = argument -> true;
+        assertEquals("<custom argument matcher>", MatcherToString.toString(lambdaMatcher));
+
+        ArgumentMatcher<Object> methodRefMatcher = lambdaMatcher::matches;
+        assertEquals("<custom argument matcher>", MatcherToString.toString(methodRefMatcher));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java b/mockito-core/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
new file mode 100644
index 0000000000..56b5e5fad0
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.matchers.text;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.internal.matchers.text.ValuePrinter.print;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.Test;
+
+public class ValuePrinterTest {
+
+    @Test
+    public void prints_values() {
+        assertThat(print(null)).isEqualTo("null");
+        assertThat(print("str")).isEqualTo("\"str\"");
+        assertThat(print("x\ny")).isEqualTo("\"x\ny\"");
+        assertThat(print(3)).isEqualTo("3");
+        assertThat(print(3L)).isEqualTo("3L");
+        assertThat(print(3.14d)).isEqualTo("3.14d");
+        assertThat(print(3.14f)).isEqualTo("3.14f");
+        assertThat(print(new int[] {1, 2})).isEqualTo("[1, 2]");
+
+        Map<String, Object> map1 = new LinkedHashMap<>();
+        map1.put("foo", 2L);
+        assertThat(print(map1)).isEqualTo("{\"foo\" = 2L}");
+
+        Map<String, Object> map2 = new LinkedHashMap<>();
+        map2.put("int passed as hex", 0x01);
+        map2.put("byte", (byte) 0x01);
+        map2.put("short", (short) 2);
+        map2.put("int", 3);
+        map2.put("long", 4L);
+        map2.put("float", 2.71f);
+        map2.put("double", 3.14d);
+        assertThat(print(map2))
+                .isEqualTo(
+                        "{\"int passed as hex\" = 1, \"byte\" = (byte) 0x01, \"short\" = (short) 2, \"int\" = 3, \"long\" = 4L, \"float\" = 2.71f, \"double\" = 3.14d}");
+
+        assertTrue(print(new UnsafeToString()).contains("UnsafeToString"));
+        assertThat(print(new ToString())).isEqualTo("ToString");
+        assertThat(print(new FormattedText("formatted"))).isEqualTo("formatted");
+    }
+
+    @Test
+    public void prints_chars() {
+        assertThat(print('a')).isEqualTo("'a'");
+        assertThat(print('\n')).isEqualTo("'\\n'");
+        assertThat(print('\t')).isEqualTo("'\\t'");
+        assertThat(print('\r')).isEqualTo("'\\r'");
+    }
+
+    static class ToString {
+        public String toString() {
+            return "ToString";
+        }
+    }
+
+    static class UnsafeToString {
+        public String toString() {
+            throw new RuntimeException("ka-boom!");
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/progress/AtLeastTest.java b/mockito-core/src/test/java/org/mockito/internal/progress/AtLeastTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/progress/AtLeastTest.java
rename to mockito-core/src/test/java/org/mockito/internal/progress/AtLeastTest.java
diff --git a/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java b/mockito-core/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
similarity index 81%
rename from src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
rename to mockito-core/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
index 8c0ab4a07f..4b812de6e5 100644
--- a/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
@@ -53,15 +53,16 @@ public void shouldCheckIfVerificationWasFinished() throws Exception {
         try {
             mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce());
             fail();
-        } catch (MockitoException e) {}
+        } catch (MockitoException e) {
+        }
     }
 
     @Test
     public void shouldNotifyListenerSafely() throws Exception {
-        //when
+        // when
         mockingProgress.addListener(null);
 
-        //then no exception is thrown:
+        // then no exception is thrown:
         mockingProgress.mockingStarted(null, null);
     }
 
@@ -72,36 +73,39 @@ public void should_not_allow_redundant_listeners() {
 
         final Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();
 
-        //when
+        // when
         MockingProgressImpl.addListener(listener1, listeners);
 
-        //then
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                MockingProgressImpl.addListener(listener2, listeners);
-            }
-        }).isInstanceOf(RedundantListenerException.class);
+        // then
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                MockingProgressImpl.addListener(listener2, listeners);
+                            }
+                        })
+                .isInstanceOf(RedundantListenerException.class);
     }
 
     @Test
     public void should_clean_up_listeners_automatically() {
         MockitoListener someListener = mock(MockitoListener.class);
         MyListener cleanListener = mock(MyListener.class);
-        MyListener dirtyListener = when(mock(MyListener.class).isListenerDirty()).thenReturn(true).getMock();
+        MyListener dirtyListener =
+                when(mock(MyListener.class).isListenerDirty()).thenReturn(true).getMock();
 
         Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();
 
-        //when
+        // when
         MockingProgressImpl.addListener(someListener, listeners);
         MockingProgressImpl.addListener(dirtyListener, listeners);
 
-        //then
+        // then
         Assertions.assertThat(listeners).containsExactlyInAnyOrder(someListener, dirtyListener);
 
-        //when
+        // when
         MockingProgressImpl.addListener(cleanListener, listeners);
 
-        //then dirty listener was removed automatically
+        // then dirty listener was removed automatically
         Assertions.assertThat(listeners).containsExactlyInAnyOrder(someListener, cleanListener);
     }
 
diff --git a/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java b/mockito-core/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
similarity index 94%
rename from src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
rename to mockito-core/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
index 183024126c..26ba1879d4 100644
--- a/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
@@ -25,11 +25,11 @@ public void after() {
 
     @Test
     public void shouldShareState() throws Exception {
-        //given
+        // given
         MockingProgress p = mockingProgress();
         p.verificationStarted(new DummyVerificationMode());
 
-        //then
+        // then
         p = mockingProgress();
         assertNotNull(p.pullVerificationMode());
     }
@@ -37,11 +37,11 @@ public void shouldShareState() throws Exception {
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldKnowWhenVerificationHasStarted() throws Exception {
-        //given
+        // given
         verify(mock(List.class));
         MockingProgress p = mockingProgress();
 
-        //then
+        // then
         assertNotNull(p.pullVerificationMode());
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/progress/TimesTest.java b/mockito-core/src/test/java/org/mockito/internal/progress/TimesTest.java
new file mode 100644
index 0000000000..1605d60e6f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/progress/TimesTest.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.progress;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.verification.VerificationModeFactory;
+
+public class TimesTest {
+
+    @Test
+    public void shouldNotAllowNegativeNumberOfInvocations() {
+        assertThatThrownBy(
+                        () -> {
+                            VerificationModeFactory.times(-50);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage("Negative value is not allowed here");
+    }
+}
diff --git a/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java b/mockito-core/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
similarity index 99%
rename from src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
rename to mockito-core/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
index 3620887ab6..07fedacb39 100644
--- a/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
+++ b/mockito-core/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
@@ -4,7 +4,6 @@
  */
 package org.mockito.internal.progress;
 
-
 import org.mockito.internal.verification.Times;
 import org.mockito.internal.verification.VerificationModeFactory;
 
diff --git a/src/test/java/org/mockito/internal/reporting/PluralizerTest.java b/mockito-core/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
similarity index 79%
rename from src/test/java/org/mockito/internal/reporting/PluralizerTest.java
rename to mockito-core/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
index 3e9a2fc28f..c1be4382c1 100644
--- a/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
@@ -25,11 +25,4 @@ public void pluralizes_interactions() {
         assertEquals("was exactly 1 interaction", Pluralizer.were_exactly_x_interactions(1));
         assertEquals("were exactly 100 interactions", Pluralizer.were_exactly_x_interactions(100));
     }
-
-    @Test
-    public void pluralizes_stubbings() {
-        assertEquals("stubbings", Pluralizer.stubbings(0));
-        assertEquals("stubbing", Pluralizer.stubbings(1));
-        assertEquals("stubbings", Pluralizer.stubbings(100));
-    }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java b/mockito-core/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
new file mode 100644
index 0000000000..0e4e40076e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.runners;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+import org.junit.Assume;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.Statement;
+import org.mockito.Mock;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.junit.MockitoTestListener;
+import org.mockito.internal.junit.TestFinishedEvent;
+import org.mockito.internal.util.Supplier;
+import org.mockito.plugins.InlineMockMaker;
+
+public class DefaultInternalRunnerTest {
+
+    private final RunListener runListener = mock(RunListener.class);
+    private final MockitoTestListener mockitoTestListener = mock(MockitoTestListener.class);
+    private final Supplier<MockitoTestListener> supplier =
+            new Supplier<MockitoTestListener>() {
+                public MockitoTestListener get() {
+                    return mockitoTestListener;
+                }
+            };
+
+    @Test
+    public void does_not_fail_when_tests_succeeds() throws Exception {
+        new DefaultInternalRunner(SuccessTest.class, supplier).run(newNotifier(runListener));
+
+        verifyTestFinishedSuccessfully();
+    }
+
+    @Test
+    public void does_not_fail_second_test_when_first_test_fail() throws Exception {
+        // The TestFailOnInitialization is initialized properly by inline mock maker
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
+        new DefaultInternalRunner(TestFailOnInitialization.class, supplier)
+                .run(newNotifier(runListener));
+
+        verify(runListener, times(1)).testFailure(any(Failure.class));
+        verify(runListener, times(1)).testFinished(any(Description.class));
+        verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
+
+        reset(runListener, mockitoTestListener);
+
+        new DefaultInternalRunner(SuccessTest.class, supplier).run(newNotifier(runListener));
+
+        verifyTestFinishedSuccessfully();
+    }
+
+    @Test
+    public void does_not_fail_when_rule_invokes_statement_multiple_times() throws Exception {
+        new DefaultInternalRunner(TestWithRepeatingRule.class, supplier)
+                .run(newNotifier(runListener));
+
+        verifyTestFinishedSuccessfully();
+    }
+
+    private void verifyTestFinishedSuccessfully() throws Exception {
+        verify(runListener, never()).testFailure(any(Failure.class));
+        verify(runListener, times(1)).testFinished(any(Description.class));
+        verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
+    }
+
+    private RunNotifier newNotifier(RunListener listener) {
+        RunNotifier notifier = new RunNotifier();
+        notifier.addListener(listener);
+        return notifier;
+    }
+
+    public static class SuccessTest {
+
+        @Test
+        public void this_test_is_NOT_supposed_to_fail() {
+            assertTrue(true);
+        }
+    }
+
+    public static final class TestFailOnInitialization {
+
+        @Mock private System system;
+
+        @Test
+        public void this_test_is_supposed_to_fail() {
+            assertNotNull(system);
+        }
+    }
+
+    public static final class TestWithRepeatingRule extends SuccessTest {
+
+        @Rule
+        public TestRule rule =
+                (base, description) ->
+                        new Statement() {
+                            @Override
+                            public void evaluate() throws Throwable {
+                                base.evaluate();
+                                base.evaluate();
+                            }
+                        };
+    }
+}
diff --git a/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java b/mockito-core/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
similarity index 76%
rename from src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
index 93b63228f9..da77bdc604 100644
--- a/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
@@ -15,11 +15,12 @@ public class RunnerProviderTest extends TestBase {
 
     @Test
     public void shouldCreateRunnerInstance() throws Throwable {
-        //given
+        // given
         RunnerProvider provider = new RunnerProvider();
-        //when
-        InternalRunner runner = provider.newInstance(DefaultInternalRunner.class.getName(), this.getClass(), null);
-        //then
+        // when
+        InternalRunner runner =
+                provider.newInstance(DefaultInternalRunner.class.getName(), this.getClass(), null);
+        // then
         assertNotNull(runner);
     }
 }
diff --git a/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java b/mockito-core/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
similarity index 93%
rename from src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
index c9b41c8dc2..18c5f6a5b3 100644
--- a/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
@@ -13,7 +13,8 @@
 public class TestMethodsFinderTest extends TestBase {
 
     public static class HasTests {
-        @Test public void someTest() {}
+        @Test
+        public void someTest() {}
     }
 
     static class DoesNotHaveTests {
diff --git a/mockito-core/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java b/mockito-core/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
new file mode 100644
index 0000000000..19f9f31d8d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.session;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.when;
+import static org.mockito.quality.Strictness.WARN;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoSession;
+import org.mockito.StateMaster;
+import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
+import org.mockito.quality.Strictness;
+import org.mockito.session.MockitoSessionLogger;
+import org.mockitoutil.ThrowableAssert;
+
+public class DefaultMockitoSessionBuilderTest {
+
+    @After
+    public void after() {
+        new StateMaster().clearMockitoListeners();
+    }
+
+    @Test
+    public void creates_sessions() {
+        // no configuration is legal
+        new DefaultMockitoSessionBuilder().startMocking().finishMocking();
+
+        // passing null to configuration is legal, default value will be used
+        new DefaultMockitoSessionBuilder().initMocks((Object) null).startMocking().finishMocking();
+        new DefaultMockitoSessionBuilder()
+                .initMocks((Object[]) null)
+                .startMocking()
+                .finishMocking();
+        new DefaultMockitoSessionBuilder()
+                .initMocks(null, null)
+                .strictness(null)
+                .startMocking()
+                .finishMocking();
+        new DefaultMockitoSessionBuilder().strictness(null).startMocking().finishMocking();
+
+        // happy path
+        new DefaultMockitoSessionBuilder().initMocks(this).startMocking().finishMocking();
+        new DefaultMockitoSessionBuilder().initMocks(new Object()).startMocking().finishMocking();
+        new DefaultMockitoSessionBuilder()
+                .strictness(Strictness.LENIENT)
+                .startMocking()
+                .finishMocking();
+    }
+
+    @Test
+    public void creates_sessions_for_multiple_test_class_instances_for_repeated_calls() {
+        TestClass testClass = new TestClass();
+        TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
+
+        new DefaultMockitoSessionBuilder()
+                .initMocks(testClass)
+                .initMocks(nestedTestClass)
+                .startMocking()
+                .finishMocking();
+
+        assertNotNull(testClass.set);
+        assertNotNull(nestedTestClass.list);
+    }
+
+    @Test
+    public void creates_sessions_for_multiple_test_class_instances_for_varargs_call() {
+        TestClass testClass = new TestClass();
+        TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
+
+        new DefaultMockitoSessionBuilder()
+                .initMocks(testClass, nestedTestClass)
+                .startMocking()
+                .finishMocking();
+
+        assertNotNull(testClass.set);
+        assertNotNull(nestedTestClass.list);
+    }
+
+    @Test
+    public void uses_logger_and_strictness() {
+        TestClass testClass = new TestClass();
+
+        final List<String> hints = new ArrayList<String>();
+        MockitoSession session =
+                new DefaultMockitoSessionBuilder()
+                        .initMocks(testClass)
+                        .strictness(WARN)
+                        .logger(
+                                new MockitoSessionLogger() {
+                                    @Override
+                                    public void log(String hint) {
+                                        hints.add(hint);
+                                    }
+                                })
+                        .startMocking();
+
+        when(testClass.set.add(1)).thenReturn(true);
+
+        session.finishMocking();
+
+        assertFalse(hints.isEmpty());
+    }
+
+    @Test
+    public void requires_finish_mocking() {
+        new DefaultMockitoSessionBuilder().startMocking();
+
+        ThrowableAssert.assertThat(
+                        new Runnable() {
+                            public void run() {
+                                new DefaultMockitoSessionBuilder().startMocking();
+                            }
+                        })
+                .throwsException(UnfinishedMockingSessionException.class);
+    }
+
+    @Test
+    public void auto_cleans_dirty_listeners() {
+        new DefaultMockitoSessionBuilder().startMocking();
+
+        ThrowableAssert.assertThat(
+                        new Runnable() {
+                            public void run() {
+                                new DefaultMockitoSessionBuilder().startMocking();
+                            }
+                        })
+                .throwsException(UnfinishedMockingSessionException.class);
+    }
+
+    class TestClass {
+
+        @Mock public Set<Object> set;
+
+        class NestedTestClass {
+            @Mock public List<Object> list;
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
similarity index 86%
rename from src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
rename to mockito-core/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
index 96599180ae..fafff6588f 100644
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
@@ -32,11 +32,13 @@ public void setup() {
         state = mockingProgress();
 
         invocationContainerImpl = new InvocationContainerImpl(new MockSettingsImpl());
-        invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
+        invocationContainerImpl.setInvocationForPotentialStubbing(
+                new InvocationBuilder().toInvocationMatcher());
 
         invocationContainerImplStubOnly =
-          new InvocationContainerImpl( new MockSettingsImpl().stubOnly());
-        invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
+                new InvocationContainerImpl(new MockSettingsImpl().stubOnly());
+        invocationContainerImplStubOnly.setInvocationForPotentialStubbing(
+                new InvocationBuilder().toInvocationMatcher());
 
         simpleMethod = new InvocationBuilder().simpleMethod().toInvocation();
     }
@@ -61,11 +63,13 @@ public void should_finish_stubbing_on_adding_return_value() throws Exception {
 
     @Test
     public void should_get_results_for_methods() throws Throwable {
-        invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
+        invocationContainerImpl.setInvocationForPotentialStubbing(
+                new InvocationMatcher(simpleMethod));
         invocationContainerImpl.addAnswer(new Returns("simpleMethod"), null);
 
         Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
-        invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
+        invocationContainerImpl.setInvocationForPotentialStubbing(
+                new InvocationMatcher(differentMethod));
         invocationContainerImpl.addAnswer(new ThrowsException(new MyException()), null);
 
         assertEquals("simpleMethod", invocationContainerImpl.answerTo(simpleMethod));
@@ -73,16 +77,19 @@ public void should_get_results_for_methods() throws Throwable {
         try {
             invocationContainerImpl.answerTo(differentMethod);
             fail();
-        } catch (MyException e) {}
+        } catch (MyException e) {
+        }
     }
 
     @Test
     public void should_get_results_for_methods_stub_only() throws Throwable {
-        invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
+        invocationContainerImplStubOnly.setInvocationForPotentialStubbing(
+                new InvocationMatcher(simpleMethod));
         invocationContainerImplStubOnly.addAnswer(new Returns("simpleMethod"), null);
 
         Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
-        invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
+        invocationContainerImplStubOnly.setInvocationForPotentialStubbing(
+                new InvocationMatcher(differentMethod));
         invocationContainerImplStubOnly.addAnswer(new ThrowsException(new MyException()), null);
 
         assertEquals("simpleMethod", invocationContainerImplStubOnly.answerTo(simpleMethod));
@@ -90,7 +97,8 @@ public void should_get_results_for_methods_stub_only() throws Throwable {
         try {
             invocationContainerImplStubOnly.answerTo(differentMethod);
             fail();
-        } catch (MyException e) {}
+        } catch (MyException e) {
+        }
     }
 
     @Test
@@ -98,7 +106,8 @@ public void should_validate_throwable() throws Throwable {
         try {
             invocationContainerImpl.addAnswer(new ThrowsException(null), null);
             fail();
-        } catch (MockitoException e) {}
+        } catch (MockitoException e) {
+        }
     }
 
     @SuppressWarnings("serial")
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
new file mode 100644
index 0000000000..6703009172
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import java.util.LinkedList;
+import java.util.concurrent.CountDownLatch;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues;
+import org.mockito.invocation.Invocation;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Author: Szczepan Faber
+ */
+public class InvocationContainerImplTest {
+
+    InvocationContainerImpl container = new InvocationContainerImpl(new MockSettingsImpl());
+    InvocationContainerImpl containerStubOnly =
+            new InvocationContainerImpl((MockCreationSettings) new MockSettingsImpl().stubOnly());
+    Invocation invocation = new InvocationBuilder().toInvocation();
+    LinkedList<Throwable> exceptions = new LinkedList<Throwable>();
+
+    @Test
+    public void should_be_thread_safe() throws Throwable {
+        doShouldBeThreadSafe(container);
+    }
+
+    @Test
+    public void should_be_thread_safe_stub_only() throws Throwable {
+        doShouldBeThreadSafe(containerStubOnly);
+    }
+
+    // works 50% of the time
+    private void doShouldBeThreadSafe(final InvocationContainerImpl c) throws Throwable {
+        // given
+        Thread[] t = new Thread[200];
+        final CountDownLatch starter = new CountDownLatch(200);
+        for (int i = 0; i < t.length; i++) {
+            t[i] =
+                    new Thread() {
+                        public void run() {
+                            try {
+                                starter.await(); // NOPMD
+                            } catch (InterruptedException e) {
+                                throw new RuntimeException(e);
+                            }
+                            c.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
+                            c.addAnswer(new Returns("foo"), null);
+                            c.findAnswerFor(invocation);
+                        }
+                    };
+            t[i].setUncaughtExceptionHandler(
+                    new Thread.UncaughtExceptionHandler() {
+                        public void uncaughtException(Thread t, Throwable e) {
+                            exceptions.add(e);
+                        }
+                    });
+            t[i].start();
+
+            starter.countDown();
+        }
+
+        // when
+        for (Thread aT : t) {
+            aT.join();
+        }
+
+        // then
+        if (exceptions.size() != 0) {
+            throw exceptions.getFirst();
+        }
+    }
+
+    @Test
+    public void should_return_invoked_mock() throws Exception {
+        container.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
+
+        assertEquals(invocation.getMock(), container.invokedMock());
+    }
+
+    @Test
+    public void should_return_invoked_mock_stub_only() throws Exception {
+        containerStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
+
+        assertEquals(invocation.getMock(), containerStubOnly.invokedMock());
+    }
+
+    @Test
+    public void should_tell_if_has_invocation_for_potential_stubbing() throws Exception {
+        container.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
+        assertTrue(container.hasInvocationForPotentialStubbing());
+
+        container.addAnswer(new ReturnsEmptyValues(), null);
+        assertFalse(container.hasInvocationForPotentialStubbing());
+    }
+
+    @Test
+    public void should_tell_if_has_invocation_for_potential_stubbing_stub_only() throws Exception {
+        containerStubOnly.setInvocationForPotentialStubbing(
+                new InvocationBuilder().toInvocationMatcher());
+        assertTrue(containerStubOnly.hasInvocationForPotentialStubbing());
+
+        containerStubOnly.addAnswer(new ReturnsEmptyValues(), null);
+        assertFalse(containerStubOnly.hasInvocationForPotentialStubbing());
+    }
+
+    @Test
+    public void should_return_answer_when_answer_exists() throws Throwable {
+        // Given: set an invocation for stubbing and add a matching answer
+        container.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
+        container.addAnswer(new Returns("Expected Answer"), null);
+
+        // When: invoking answerTo should return the answer
+        Object result = container.answerTo(invocation);
+
+        // Then: verify the expected answer is returned
+        assertEquals("Expected Answer", result);
+    }
+
+    @Test
+    public void should_throw_mockito_exception_when_no_answer_found() {
+        // Given: no answer added for the invocation
+        Invocation unmatchedInvocation = new InvocationBuilder().toInvocation();
+
+        // When and Then: invoking answerTo should throw MockitoException
+        MockitoException exception =
+                assertThrows(
+                        MockitoException.class,
+                        () -> {
+                            container.answerTo(unmatchedInvocation);
+                        });
+
+        // Verify the exception message
+        assertTrue(
+                exception
+                        .getMessage()
+                        .contains(
+                                "Unable to find answer for: "
+                                        + unmatchedInvocation
+                                        + "Did you configure a stubbing for this method?"));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/AbstractThrowsExceptionTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/AbstractThrowsExceptionTest.java
new file mode 100644
index 0000000000..c4fa7a1820
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/AbstractThrowsExceptionTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
+import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
+
+import java.io.IOException;
+import java.nio.charset.CharacterCodingException;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
+
+public class AbstractThrowsExceptionTest {
+
+    @Test
+    public void should_raise_wanted_throwable() {
+        Throwable expected = new Exception();
+        AbstractThrowsException ate = instantiateFixture(expected);
+
+        Throwable throwable = Assertions.catchThrowable(() -> ate.answer(createMethodInvocation()));
+        assertNotNull("Should have raised an exception.", throwable);
+        assertSame(expected, throwable);
+    }
+
+    @Test
+    public void should_throw_mock_exception_without_stacktrace() {
+        AbstractThrowsException ate = instantiateFixture(mock(Exception.class));
+
+        Throwable throwable = Assertions.catchThrowable(() -> ate.answer(createMethodInvocation()));
+        assertNotNull("Should have raised an exception.", throwable);
+        assertThat(throwable.getStackTrace()).describedAs("no stack trace, it's mock").isNull();
+    }
+
+    @Test
+    public void should_fill_in_exception_stacktrace() {
+        AbstractThrowsException ate = instantiateFixture(new Exception());
+
+        Throwable throwable = Assertions.catchThrowable(() -> ate.answer(createMethodInvocation()));
+        assertNotNull("Should have raised an exception.", throwable);
+        assertThat(throwable.getStackTrace()[0].getClassName())
+                .isEqualTo(AbstractThrowsException.class.getName());
+        assertThat(throwable.getStackTrace()[0].getMethodName()).isEqualTo("answer");
+    }
+
+    @Test
+    public void should_invalidate_null_throwable() {
+        AbstractThrowsException ate = instantiateFixture(null);
+
+        Throwable throwable =
+                Assertions.catchThrowableOfType(
+                        () -> ate.validateFor(createMethodInvocation()), MockitoException.class);
+        assertNotNull("Should have raised a MockitoException.", throwable);
+        assertEquals(cannotStubWithNullThrowable().getMessage(), throwable.getMessage());
+    }
+
+    @Test
+    public void should_throw_illegal_state_exception_if_null_answer() {
+        AbstractThrowsException ate = instantiateFixture(null);
+
+        Throwable throwable =
+                Assertions.catchThrowableOfType(
+                        () -> ate.answer(createMethodInvocation()), IllegalStateException.class);
+        assertNotNull("Should have raised a IllegalStateException.", throwable);
+        assertEquals(
+                "throwable is null: you shall not call #answer if #validateFor fails!",
+                throwable.getMessage());
+    }
+
+    @Test
+    public void should_pass_proper_checked_exception() {
+        instantiateFixture(new CharacterCodingException()).validateFor(createMethodInvocation());
+    }
+
+    @Test
+    public void should_fail_invalid_checked_exception() {
+        AbstractThrowsException ate = instantiateFixture(new IOException());
+        Throwable comparison = ate.getThrowable();
+
+        Throwable throwable =
+                Assertions.catchThrowableOfType(
+                        () -> ate.validateFor(createMethodInvocation()), MockitoException.class);
+        assertNotNull("Should have raised a MockitoException.", throwable);
+        assertEquals(checkedExceptionInvalid(comparison).getMessage(), throwable.getMessage());
+    }
+
+    @Test
+    public void should_pass_RuntimeException() {
+        instantiateFixture(new RuntimeException()).validateFor(createMethodInvocation());
+    }
+
+    @Test
+    public void should_pass_Error() {
+        instantiateFixture(new Error()).validateFor(createMethodInvocation());
+    }
+
+    /** Creates a fixture for AbstractThrowsException that returns the given Throwable. */
+    private static AbstractThrowsException instantiateFixture(Throwable throwable) {
+        return new AbstractThrowsException() {
+            @Override
+            protected Throwable getThrowable() {
+                return throwable;
+            }
+        };
+    }
+
+    /** Creates Invocation of a "canThrowException" method call. */
+    private static Invocation createMethodInvocation() {
+        return new InvocationBuilder().method("canThrowException").toInvocation();
+    }
+
+    @Test
+    public void fixture_should_return_expected_throwable() {
+        Throwable expected = new RuntimeException();
+        AbstractThrowsException ate = instantiateFixture(expected);
+
+        assertSame(expected, ate.getThrowable());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
new file mode 100644
index 0000000000..e507f2fd44
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.within;
+
+import java.util.Date;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.InvocationBuilder;
+
+public class AnswersWithDelayTest {
+    @Test
+    public void should_return_value() throws Throwable {
+        assertThat(
+                        new AnswersWithDelay(1, new Returns("value"))
+                                .answer(
+                                        new InvocationBuilder()
+                                                .method("oneArg")
+                                                .arg("A")
+                                                .toInvocation()))
+                .isEqualTo("value");
+    }
+
+    @Test
+    public void should_fail_when_contained_answer_should_fail() {
+        assertThatThrownBy(
+                        () -> {
+                            new AnswersWithDelay(1, new Returns("one"))
+                                    .validateFor(
+                                            new InvocationBuilder()
+                                                    .method("voidMethod")
+                                                    .toInvocation());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "'voidMethod' is a *void method* and it *cannot* be stubbed with a *return value*!",
+                        "Voids are usually stubbed with Throwables:",
+                        "    doThrow(exception).when(mock).someVoidMethod();",
+                        "If you need to set the void method to do nothing you can use:",
+                        "    doNothing().when(mock).someVoidMethod();",
+                        "For more information, check out the javadocs for Mockito.doNothing().");
+    }
+
+    @Test
+    public void should_succeed_when_contained_answer_should_succeed() {
+        new AnswersWithDelay(1, new Returns("one"))
+                .validateFor(new InvocationBuilder().simpleMethod().toInvocation());
+    }
+
+    @Test
+    public void should_delay() throws Throwable {
+        final long sleepyTime = 500L;
+
+        final AnswersWithDelay testSubject = new AnswersWithDelay(sleepyTime, new Returns("value"));
+
+        final Date before = new Date();
+        testSubject.answer(new InvocationBuilder().method("oneArg").arg("A").toInvocation());
+        final Date after = new Date();
+
+        final long timePassed = after.getTime() - before.getTime();
+        assertThat(timePassed).isCloseTo(sleepyTime, within(15L));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
new file mode 100644
index 0000000000..f8d904f2bb
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEFAULTS;
+import static org.mockito.Mockito.mock;
+
+import java.util.ArrayList;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.MockitoCore;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
+
+public class CallsRealMethodsTest {
+
+    @Test
+    public void should_delegate_to_returns_default_when_abstract_method() throws Throwable {
+        Invocation abstractMethod =
+                new InvocationBuilder().method("booleanReturningMethod").toInvocation();
+        assertThat(new CallsRealMethods().answer(abstractMethod))
+                .isEqualTo(RETURNS_DEFAULTS.answer(abstractMethod));
+    }
+
+    @Test
+    public void should_fail_when_calling_real_method_on_interface() throws Throwable {
+        // given
+        Invocation invocationOnInterface =
+                new InvocationBuilder().method("simpleMethod").toInvocation();
+        try {
+            // when
+            new CallsRealMethods().validateFor(invocationOnInterface);
+            // then
+            Assertions.fail("can not invoke interface");
+        } catch (MockitoException expected) {
+        }
+    }
+
+    @Test
+    public void should_be_OK_when_calling_real_method_on_concrete_class() throws Throwable {
+        // given
+        ArrayList<?> mock = mock(ArrayList.class);
+        mock.clear();
+        Invocation invocationOnClass = new MockitoCore().getLastInvocation();
+        // when
+        new CallsRealMethods().validateFor(invocationOnClass);
+        // then no exception is thrown
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DeepStubReturnsEnumJava11Test.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DeepStubReturnsEnumJava11Test.java
new file mode 100644
index 0000000000..70b7b54968
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DeepStubReturnsEnumJava11Test.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+
+public class DeepStubReturnsEnumJava11Test {
+    private static final String MOCK_VALUE = "Mock";
+
+    @Test
+    public void deep_stub_can_mock_enum_getter_Issue_2984() {
+        final var mock = mock(TestClass.class, RETURNS_DEEP_STUBS);
+        when(mock.getTestEnum()).thenReturn(TestEnum.B);
+        assertThat(mock.getTestEnum()).isEqualTo(TestEnum.B);
+    }
+
+    @Test
+    public void deep_stub_can_mock_enum_class_Issue_2984() {
+        final var mock = mock(TestEnum.class, RETURNS_DEEP_STUBS);
+        when(mock.getValue()).thenReturn(MOCK_VALUE);
+        assertThat(mock.getValue()).isEqualTo(MOCK_VALUE);
+    }
+
+    @Test
+    public void deep_stub_can_mock_enum_method_Issue_2984() {
+        final var mock = mock(TestClass.class, RETURNS_DEEP_STUBS);
+        assertThat(mock.getTestEnum().getValue()).isEqualTo(null);
+
+        when(mock.getTestEnum().getValue()).thenReturn(MOCK_VALUE);
+        assertThat(mock.getTestEnum().getValue()).isEqualTo(MOCK_VALUE);
+    }
+
+    @Test
+    public void mock_mocking_enum_getter_Issue_2984() {
+        final var mock = mock(TestClass.class);
+        when(mock.getTestEnum()).thenReturn(TestEnum.B);
+        assertThat(mock.getTestEnum()).isEqualTo(TestEnum.B);
+        assertThat(mock.getTestEnum().getValue()).isEqualTo("B");
+    }
+
+    static class TestClass {
+        TestEnum getTestEnum() {
+            return TestEnum.A;
+        }
+    }
+
+    enum TestEnum {
+        A {
+            @Override
+            String getValue() {
+                return this.name();
+            }
+        },
+        B {
+            @Override
+            String getValue() {
+                return this.name();
+            }
+        },
+        ;
+
+        abstract String getValue();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
new file mode 100644
index 0000000000..df78604bc7
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+import org.junit.Test;
+import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
+import org.mockito.internal.invocation.InvocationBuilder;
+
+public class DefaultAnswerValidatorTest {
+
+    @Test
+    public void should_fail_if_returned_value_of_answer_is_incompatible_with_return_type()
+            throws Throwable {
+        // given
+        class AWrongType {}
+        try {
+            // when
+            DefaultAnswerValidator.validateReturnValueFor(
+                    new InvocationBuilder().method("toString").toInvocation(), new AWrongType());
+            fail("expected validation to fail");
+        } catch (WrongTypeOfReturnValue e) {
+            // then
+            assertThat(e.getMessage())
+                    .containsIgnoringCase("Default answer returned a result with the wrong type")
+                    .containsIgnoringCase("AWrongType cannot be returned by toString()")
+                    .containsIgnoringCase("toString() should return String");
+        }
+    }
+
+    @Test
+    public void should_not_fail_if_returned_value_of_answer_is_null() throws Throwable {
+        DefaultAnswerValidator.validateReturnValueFor(
+                new InvocationBuilder().method("toString").toInvocation(), null);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
new file mode 100644
index 0000000000..ecdd6cb761
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
+import static org.mockitoutil.TestBase.getLastInvocation;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.invocation.Invocation;
+import org.mockitousage.IMethods;
+
+public class DoesNothingTest {
+
+    private IMethods mock;
+    private Invocation invocation_Void;
+    private Invocation invocation_void;
+    private Invocation invocation_String;
+
+    @Before
+    public void init() {
+        mock = mock(IMethods.class);
+
+        mock.voidMethod();
+        invocation_Void = getLastInvocation();
+
+        mock.voidReturningMethod();
+        invocation_void = getLastInvocation();
+
+        mock.simpleMethod();
+        invocation_String = getLastInvocation();
+    }
+
+    @Test
+    public void answer_returnsNull() {
+        assertThat(doesNothing().answer(invocation_Void)).isNull();
+        assertThat(doesNothing().answer(invocation_void)).isNull();
+        assertThat(doesNothing().answer(invocation_String)).isNull();
+    }
+
+    @Test
+    public void validateFor_nonVoidReturnType_shouldFail() {
+        assertThatThrownBy(
+                        () -> {
+                            doesNothing().validateFor(invocation_String);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Only void methods can doNothing()!");
+    }
+
+    @Test
+    public void validateFor_voidReturnType_shouldPass() {
+        doesNothing().validateFor(invocation_void);
+    }
+
+    @Test
+    public void validateFor_voidObjectReturnType() {
+        doesNothing().validateFor(invocation_Void);
+    }
+
+    @Test
+    public void answer_returns_null_for_generic_parameter() {
+        SubclassWithGenericParameter mock = mock(SubclassWithGenericParameter.class);
+        doNothing().when(mock).methodReturningT();
+    }
+
+    static class SuperClassWithGenericParameter<T> {
+        T methodReturningT() {
+            return null;
+        }
+    }
+
+    static class SubclassWithGenericParameter extends SuperClassWithGenericParameter<Void> {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoExceptionTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoExceptionTest.java
new file mode 100644
index 0000000000..21802c1f54
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoExceptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
+
+import java.nio.charset.CharacterCodingException;
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(Parameterized.class)
+public class InvocationInfoExceptionTest {
+
+    private final String methodName;
+
+    public InvocationInfoExceptionTest(final String methodName) {
+        this.methodName = methodName;
+    }
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        return Arrays.asList(
+                new Object[][] {
+                    {"throwException"},
+                    {"parentThrowsException"},
+                    {"grandParentThrowsException"},
+                    {"interfaceThrowsException"},
+                    {"grandInterfaceThrowsException"},
+                    {"interfaceOfParentThrowsException"}
+                });
+    }
+
+    @Test
+    public void should_know_valid_throwables() throws Exception {
+        // when
+        final Invocation invocation =
+                new InvocationBuilder()
+                        .method(methodName)
+                        .mockClass(CurrentClass.class)
+                        .toInvocation();
+        final InvocationInfo info = new InvocationInfo(invocation);
+
+        // then
+        assertThat(info.isValidException(new Exception())).isFalse();
+        assertThat(info.isValidException(new CharacterCodingException())).isTrue();
+    }
+
+    private abstract static class GrandParent {
+        public abstract void grandParentThrowsException() throws CharacterCodingException;
+    }
+
+    private interface InterfaceOfParent {
+        abstract void interfaceOfParentThrowsException() throws CharacterCodingException;
+    }
+
+    private abstract static class Parent extends GrandParent implements InterfaceOfParent {
+        public abstract void parentThrowsException() throws CharacterCodingException;
+    }
+
+    private interface GrandInterface {
+        void grandInterfaceThrowsException() throws CharacterCodingException;
+    }
+
+    private interface Interface extends GrandInterface {
+        void interfaceThrowsException() throws CharacterCodingException;
+    }
+
+    private static class CurrentClass extends Parent implements Interface {
+
+        public void throwException() throws CharacterCodingException {}
+
+        @Override
+        public void grandParentThrowsException() {}
+
+        @Override
+        public void parentThrowsException() {}
+
+        @Override
+        public void grandInterfaceThrowsException() {}
+
+        @Override
+        public void interfaceThrowsException() {}
+
+        @Override
+        public void interfaceOfParentThrowsException() {}
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
new file mode 100644
index 0000000000..fea0ec36eb
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockitoutil.TestBase.getLastInvocation;
+
+import java.lang.reflect.Method;
+
+import org.junit.Test;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockitousage.IMethods;
+
+public class InvocationInfoTest {
+
+    @Test
+    public void should_know_valid_return_types() throws Exception {
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("integerReturningMethod")
+                                                .toInvocation())
+                                .isValidReturnType(Integer.class))
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("integerReturningMethod")
+                                                .toInvocation())
+                                .isValidReturnType(int.class))
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("intReturningMethod")
+                                                .toInvocation())
+                                .isValidReturnType(Integer.class))
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("intReturningMethod")
+                                                .toInvocation())
+                                .isValidReturnType(int.class))
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("integerReturningMethod")
+                                                .toInvocation())
+                                .isValidReturnType(String.class))
+                .isFalse();
+    }
+
+    @Test
+    public void should_know_when_invocation_returns_primitive() {
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("intReturningMethod")
+                                                .toInvocation())
+                                .returnsPrimitive())
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("integerReturningMethod")
+                                                .toInvocation())
+                                .returnsPrimitive())
+                .isFalse();
+    }
+
+    @Test
+    public void should_know_when_invocation_returns_void() {
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder().method("voidMethod").toInvocation())
+                                .isVoid())
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("integerReturningMethod")
+                                                .toInvocation())
+                                .isVoid())
+                .isFalse();
+    }
+
+    @Test
+    public void should_read_the_method_name() {
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder().method("voidMethod").toInvocation())
+                                .getMethodName())
+                .isEqualTo("voidMethod");
+    }
+
+    @Test
+    public void should_read_the_method_return_name() {
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder().method("voidMethod").toInvocation())
+                                .printMethodReturnType())
+                .isEqualTo("void");
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("integerReturningMethod")
+                                                .toInvocation())
+                                .printMethodReturnType())
+                .isEqualTo("Integer");
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method("intReturningMethod")
+                                                .toInvocation())
+                                .printMethodReturnType())
+                .isEqualTo("int");
+    }
+
+    @Test
+    public void should_know_abstract_method() throws Exception { // To be extended with Java 8
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method(iAmAbstract())
+                                                .toInvocation())
+                                .isAbstract())
+                .isTrue();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method(iAmNotAbstract())
+                                                .toInvocation())
+                                .isAbstract())
+                .isFalse();
+    }
+
+    @Test
+    public void should_know_method_is_declared_on_interface() throws Exception {
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder()
+                                                .method(iAmAbstract())
+                                                .toInvocation())
+                                .isDeclaredOnInterface())
+                .isFalse();
+        assertThat(
+                        new InvocationInfo(
+                                        new InvocationBuilder().method("voidMethod").toInvocation())
+                                .isDeclaredOnInterface())
+                .isTrue();
+    }
+
+    @Test
+    public void isVoid_invocationOnVoidMethod_returnTrue() {
+        mock(IMethods.class).voidMethod();
+
+        InvocationInfo voidMethod = new InvocationInfo(getLastInvocation());
+
+        assertThat(voidMethod.isVoid()).isTrue();
+    }
+
+    @Test
+    public void isVoid_invocationOnVoidReturningMethod_returnTrue() {
+        mock(IMethods.class).voidReturningMethod();
+
+        InvocationInfo voidRetuningMethod = new InvocationInfo(getLastInvocation());
+
+        assertThat(voidRetuningMethod.isVoid()).isTrue();
+    }
+
+    @Test
+    public void isVoid_invocationNonVoidMethod_returnFalse() {
+        mock(IMethods.class).simpleMethod();
+
+        InvocationInfo stringReturningMethod = new InvocationInfo(getLastInvocation());
+
+        assertThat(stringReturningMethod.isVoid()).isFalse();
+    }
+
+    private Method iAmAbstract() throws NoSuchMethodException {
+        abstract class TheAbstract {
+            abstract void iAmAbstract();
+        }
+        return TheAbstract.class.getDeclaredMethod("iAmAbstract");
+    }
+
+    private Method iAmNotAbstract() throws NoSuchMethodException {
+        abstract class TheNotAbstract {
+            void iAmNotAbstract() {}
+        }
+        return TheNotAbstract.class.getDeclaredMethod("iAmNotAbstract");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
new file mode 100644
index 0000000000..be8b3159e2
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationOnMock;
+
+public class ReturnsArgumentAtTest {
+    @Test
+    public void should_be_able_to_return_the_first_parameter() throws Throwable {
+        assertThat(new ReturnsArgumentAt(0).answer(invocationWith("A", "B"))).isEqualTo("A");
+    }
+
+    @Test
+    public void should_be_able_to_return_the_second_parameter() throws Throwable {
+        assertThat(new ReturnsArgumentAt(1).answer(invocationWith("A", "B", "C"))).isEqualTo("B");
+    }
+
+    @Test
+    public void should_be_able_to_return_the_last_parameter() throws Throwable {
+        assertThat(new ReturnsArgumentAt(-1).answer(invocationWith("A"))).isEqualTo("A");
+        assertThat(new ReturnsArgumentAt(-1).answer(invocationWith("A", "B"))).isEqualTo("B");
+    }
+
+    @Test
+    public void should_be_able_to_return_the_specified_parameter() throws Throwable {
+        assertThat(new ReturnsArgumentAt(0).answer(invocationWith("A", "B", "C"))).isEqualTo("A");
+        assertThat(new ReturnsArgumentAt(1).answer(invocationWith("A", "B", "C"))).isEqualTo("B");
+        assertThat(new ReturnsArgumentAt(2).answer(invocationWith("A", "B", "C"))).isEqualTo("C");
+    }
+
+    @Test
+    public void should_identify_bad_parameter_type_for_invocation() throws Exception {
+        try {
+            new ReturnsArgumentAt(1)
+                    .validateFor(
+                            new InvocationBuilder()
+                                    .method("varargsReturningString")
+                                    .argTypes(Object[].class)
+                                    .args(new Object(), new Object(), new Object())
+                                    .toInvocation());
+            Assertions.fail("should scream");
+        } catch (WrongTypeOfReturnValue ignored) {
+        }
+        try {
+            new ReturnsArgumentAt(0)
+                    .validateFor(
+                            new InvocationBuilder()
+                                    .method("oneArray")
+                                    .argTypes(boolean[].class)
+                                    .args(true, false, false)
+                                    .toInvocation());
+            Assertions.fail("should scream");
+        } catch (WrongTypeOfReturnValue ignored) {
+        }
+        try {
+            new ReturnsArgumentAt(0)
+                    .validateFor(
+                            new InvocationBuilder()
+                                    .method("mixedVarargsReturningString")
+                                    .argTypes(Object.class, String[].class)
+                                    .args(new Object(), new String[] {"A", "B", "C"})
+                                    .toInvocation());
+            Assertions.fail("should scream");
+        } catch (WrongTypeOfReturnValue ignored) {
+        }
+    }
+
+    @Test
+    public void should_not_scream_when_mixed_vararg_parameter_is_compatible_with_invocation()
+            throws Exception {
+        new ReturnsArgumentAt(1)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("mixedVarargsReturningString")
+                                .argTypes(Object.class, String[].class)
+                                .args(new Object(), new String[] {"A", "B", "C"})
+                                .toInvocation());
+    }
+
+    @Test
+    public void should_handle_returning_vararg_as_array() throws Throwable {
+        Invocation mixedVarargsReturningStringArray =
+                new InvocationBuilder()
+                        .method("mixedVarargsReturningStringArray")
+                        .argTypes(Object.class, String[].class)
+                        .args(new Object(), new String[] {"A", "B", "C"})
+                        .toInvocation();
+        new ReturnsArgumentAt(1).validateFor(mixedVarargsReturningStringArray);
+        assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningStringArray))
+                .isEqualTo(new String[] {"A", "B", "C"});
+
+        Invocation mixedVarargsReturningObjectArray =
+                new InvocationBuilder()
+                        .method("mixedVarargsReturningStringArray")
+                        .argTypes(Object.class, String[].class)
+                        .args(new Object(), new String[] {"A", "B", "C"})
+                        .toInvocation();
+        new ReturnsArgumentAt(1).validateFor(mixedVarargsReturningObjectArray);
+        assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningObjectArray))
+                .isEqualTo(new String[] {"A", "B", "C"});
+    }
+
+    @Test
+    public void should_raise_an_exception_if_index_is_not_in_allowed_range_at_creation_time()
+            throws Throwable {
+        try {
+            new ReturnsArgumentAt(-30);
+            fail();
+        } catch (Exception e) {
+            assertThat(e.getMessage())
+                    .containsIgnoringCase("argument index")
+                    .containsIgnoringCase("positive number")
+                    .contains("1")
+                    .containsIgnoringCase("last argument");
+        }
+    }
+
+    @Test
+    public void should_allow_possible_argument_types() throws Exception {
+        new ReturnsArgumentAt(0)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("intArgumentReturningInt")
+                                .argTypes(int.class)
+                                .arg(1000)
+                                .toInvocation());
+        new ReturnsArgumentAt(0)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("toString")
+                                .argTypes(String.class)
+                                .arg("whatever")
+                                .toInvocation());
+        new ReturnsArgumentAt(2)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("varargsObject")
+                                .argTypes(int.class, Object[].class)
+                                .args(1000, "Object", "Object")
+                                .toInvocation());
+        new ReturnsArgumentAt(1)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("threeArgumentMethod")
+                                .argTypes(int.class, Object.class, String.class)
+                                .args(1000, "Object", "String")
+                                .toInvocation());
+    }
+
+    @Test
+    public void should_fail_if_index_is_not_in_range_for_one_arg_invocation() throws Throwable {
+        try {
+            new ReturnsArgumentAt(30)
+                    .validateFor(new InvocationBuilder().method("oneArg").arg("A").toInvocation());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage())
+                    .containsIgnoringCase("invalid argument index")
+                    .containsIgnoringCase("iMethods.oneArg")
+                    .containsIgnoringCase("[0] String")
+                    .containsIgnoringCase("position")
+                    .contains("30");
+        }
+    }
+
+    @Test
+    public void should_fail_if_index_is_not_in_range_for_example_with_no_arg_invocation()
+            throws Throwable {
+        try {
+            new ReturnsArgumentAt(ReturnsArgumentAt.LAST_ARGUMENT)
+                    .validateFor(new InvocationBuilder().simpleMethod().toInvocation());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage())
+                    .containsIgnoringCase("invalid argument index")
+                    .containsIgnoringCase("iMethods.simpleMethod")
+                    .containsIgnoringCase("no arguments")
+                    .containsIgnoringCase("last parameter wanted");
+        }
+    }
+
+    @Test
+    public void should_fail_if_argument_type_of_signature_is_incompatible_with_return_type()
+            throws Throwable {
+        try {
+            new ReturnsArgumentAt(2)
+                    .validateFor(
+                            new InvocationBuilder()
+                                    .method("varargsReturningString")
+                                    .argTypes(Object[].class)
+                                    .args("anyString", new Object(), "anyString")
+                                    .toInvocation());
+            fail();
+        } catch (WrongTypeOfReturnValue e) {
+            assertThat(e.getMessage())
+                    .containsIgnoringCase("argument of type")
+                    .containsIgnoringCase("Object")
+                    .containsIgnoringCase("varargsReturningString")
+                    .containsIgnoringCase("should return")
+                    .containsIgnoringCase("String")
+                    .containsIgnoringCase("possible argument indexes");
+        }
+    }
+
+    @Test
+    public void shouldNotFailWhenArgumentIsGenericAndCompatibleWithReturnType() throws Exception {
+        new ReturnsArgumentAt(0)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("genericToString")
+                                .argTypes(Object.class)
+                                .args("anyString")
+                                .toInvocation());
+    }
+
+    private static InvocationOnMock invocationWith(Object... parameters) {
+        return new InvocationBuilder()
+                .method("varargsReturningString")
+                .argTypes(Object[].class)
+                .args(new Object[] {parameters})
+                .toInvocation(); // one vararg param (sic!)
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
new file mode 100644
index 0000000000..b18bf5a0f4
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static java.lang.Boolean.TRUE;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.InvocationBuilder;
+
+public class ReturnsTest {
+    @Test
+    public void should_return_value() throws Throwable {
+        assertThat(
+                        new Returns("value")
+                                .answer(
+                                        new InvocationBuilder()
+                                                .method("oneArg")
+                                                .arg("A")
+                                                .toInvocation()))
+                .isEqualTo("value");
+    }
+
+    @Test
+    public void should_fail_when_return_Value_is_set_for_void_method() {
+        assertThatThrownBy(
+                        () -> {
+                            new Returns("one")
+                                    .validateFor(
+                                            new InvocationBuilder()
+                                                    .method("voidMethod")
+                                                    .toInvocation());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "'voidMethod' is a *void method* and it *cannot* be stubbed with a *return value*!");
+    }
+
+    @Test
+    public void should_allow_correct_type_of_return_value() {
+        new Returns("one").validateFor(new InvocationBuilder().simpleMethod().toInvocation());
+        new Returns(false)
+                .validateFor(
+                        new InvocationBuilder().method("booleanReturningMethod").toInvocation());
+        new Returns(TRUE)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("booleanObjectReturningMethod")
+                                .toInvocation());
+        new Returns(1)
+                .validateFor(
+                        new InvocationBuilder().method("integerReturningMethod").toInvocation());
+        new Returns(1L)
+                .validateFor(new InvocationBuilder().method("longReturningMethod").toInvocation());
+        new Returns(1L)
+                .validateFor(
+                        new InvocationBuilder().method("longObjectReturningMethod").toInvocation());
+        new Returns(null)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("objectReturningMethodNoArgs")
+                                .toInvocation());
+        new Returns(1)
+                .validateFor(
+                        new InvocationBuilder()
+                                .method("objectReturningMethodNoArgs")
+                                .toInvocation());
+    }
+
+    @Test
+    public void should_fail_on_return_type_mismatch() {
+        assertThatThrownBy(
+                        () -> {
+                            new Returns("String")
+                                    .validateFor(
+                                            new InvocationBuilder()
+                                                    .method("booleanReturningMethod")
+                                                    .toInvocation());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "String cannot be returned by booleanReturningMethod()",
+                        "booleanReturningMethod() should return boolean");
+    }
+
+    @Test
+    public void should_fail_on_wrong_primitive() {
+        assertThatThrownBy(
+                        () -> {
+                            new Returns(1)
+                                    .validateFor(
+                                            new InvocationBuilder()
+                                                    .method("doubleReturningMethod")
+                                                    .toInvocation());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Integer cannot be returned by doubleReturningMethod()",
+                        "doubleReturningMethod() should return double");
+    }
+
+    @Test
+    public void should_fail_on_null_with_primitive() {
+        assertThatThrownBy(
+                        () -> {
+                            new Returns(null)
+                                    .validateFor(
+                                            new InvocationBuilder()
+                                                    .method("booleanReturningMethod")
+                                                    .toInvocation());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "null cannot be returned by booleanReturningMethod()",
+                        "booleanReturningMethod() should return boolean");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassTypeTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassTypeTest.java
new file mode 100644
index 0000000000..ae1b8806c9
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassTypeTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+
+public class ThrowsExceptionForClassTypeTest {
+    @Test
+    public void should_return_throwable_of_expected_class() {
+        ThrowsExceptionForClassType throwsExceptionForClassType =
+                new ThrowsExceptionForClassType(Exception.class);
+
+        assertSame(Exception.class, throwsExceptionForClassType.getThrowable().getClass());
+    }
+
+    @Test
+    public void should_return_different_throwables() {
+        ThrowsExceptionForClassType throwsExceptionForClassType =
+                new ThrowsExceptionForClassType(Exception.class);
+
+        Throwable first = throwsExceptionForClassType.getThrowable();
+        Throwable second = throwsExceptionForClassType.getThrowable();
+        assertNotSame(first, second);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
new file mode 100644
index 0000000000..281018101b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static junit.framework.TestCase.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+
+import java.io.IOException;
+import java.nio.charset.CharacterCodingException;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
+
+public class ThrowsExceptionTest {
+    @Test
+    public void should_raise_wanted_throwable() {
+        try {
+            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");
+        }
+    }
+
+    @Test
+    public void should_throw_mock_exception_without_stacktrace() {
+        try {
+            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();
+        }
+    }
+
+    @Test
+    public void should_fill_in_exception_stacktrace() {
+        // given
+        Exception throwableToRaise = new Exception();
+        throwableToRaise.fillInStackTrace();
+        assertThat(throwableToRaise.getStackTrace()[0].getClassName())
+                .isEqualTo(this.getClass().getName());
+        assertThat(throwableToRaise.getStackTrace()[0].getMethodName())
+                .isEqualTo("should_fill_in_exception_stacktrace");
+        try {
+
+            // when
+            new ThrowsException(throwableToRaise).answer(createMethodInvocation());
+            Assertions.fail("should have raised wanted exception");
+        } catch (Throwable throwable) {
+            // then
+            throwable.printStackTrace();
+            assertThat(throwableToRaise.getStackTrace()[0].getClassName())
+                    .isEqualTo(AbstractThrowsException.class.getName());
+            assertThat(throwableToRaise.getStackTrace()[0].getMethodName()).isEqualTo("answer");
+        }
+    }
+
+    @Test
+    public void should_invalidate_null_throwable() {
+        try {
+            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() {
+        new ThrowsException(new CharacterCodingException()).validateFor(createMethodInvocation());
+    }
+
+    @Test
+    public void should_fail_invalid_checked_exception() {
+        assertThatThrownBy(
+                        () -> {
+                            new ThrowsException(new IOException())
+                                    .validateFor(createMethodInvocation());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Checked exception is invalid for this method!",
+                        "Invalid: java.io.IOException");
+    }
+
+    @Test
+    public void should_pass_RuntimeExceptions() {
+        new ThrowsException(new Error()).validateFor(createMethodInvocation());
+        new ThrowsException(new RuntimeException()).validateFor(createMethodInvocation());
+    }
+
+    @Test
+    public void should_return_expected_throwable() {
+        Throwable expected = new Exception();
+        ThrowsException throwsException = new ThrowsException(expected);
+
+        assertSame(expected, throwsException.getThrowable());
+    }
+
+    @Test
+    public void should_return_same_throwable() {
+        ThrowsException throwsException = new ThrowsException(new Exception());
+
+        Throwable first = throwsException.getThrowable();
+        Throwable second = throwsException.getThrowable();
+        assertSame(first, second);
+    }
+
+    /** 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/ForwardsInvocationsTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
similarity index 75%
rename from src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
rename to mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
index e19ea5b7bb..a2a28ef60a 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
@@ -25,12 +25,17 @@ public int bar(String baz, Object... args) {
     @Test
     public void should_call_method_with_varargs() throws Throwable {
         ForwardsInvocations forwardsInvocations = new ForwardsInvocations(new FooImpl());
-        assertEquals(4, forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {12, "3", 4.5})));
+        assertEquals(
+                4,
+                forwardsInvocations.answer(
+                        invocationOf(Foo.class, "bar", "b", new Object[] {12, "3", 4.5})));
     }
 
     @Test
     public void should_call_method_with_empty_varargs() throws Throwable {
         ForwardsInvocations forwardsInvocations = new ForwardsInvocations(new FooImpl());
-        assertEquals(1, forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {})));
+        assertEquals(
+                1,
+                forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {})));
     }
 }
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
similarity index 98%
rename from src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
rename to mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
index 9aaea02c06..77f3b64243 100755
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
@@ -7,11 +7,18 @@
 @SuppressWarnings("unused")
 interface HasPrimitiveMethods {
     boolean booleanMethod();
+
     char charMethod();
+
     byte byteMethod();
+
     short shortMethod();
+
     int intMethod();
+
     long longMethod();
+
     float floatMethod();
+
     double doubleMethod();
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubsConcurrentTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubsConcurrentTest.java
new file mode 100644
index 0000000000..b3658342ed
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubsConcurrentTest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.mockito.Mockito.mock;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+import org.mockito.Answers;
+
+public class ReturnsDeepStubsConcurrentTest {
+
+    @Test
+    public void
+            given_mock_with_returns_deep_stubs__when_called_concurrently__then_does_not_throw_concurrent_modification_exception() {
+        for (int i = 0; i < 1000; i++) {
+            Service mock = mock(Service.class, Answers.RETURNS_DEEP_STUBS);
+            IntStream.range(1, 100).parallel().forEach(index -> mock.doSomething());
+        }
+    }
+
+    interface Service {
+        List<String> doSomething();
+    }
+}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
similarity index 86%
rename from src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
rename to mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
index ab68102c55..c80c746e8c 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
@@ -66,25 +66,25 @@ public void should_return_non_zero_for_compareTo_method() {
         d.compareTo(new Date());
         Invocation compareTo = this.getLastInvocation();
 
-        //when
+        // when
         Object result = values.answer(compareTo);
 
-        //then
+        // then
         assertTrue(result != (Object) 0);
     }
 
     @SuppressWarnings("SelfComparison")
     @Test
     public void should_return_zero_if_mock_is_compared_to_itself() {
-        //given
+        // given
         Date d = mock(Date.class);
         d.compareTo(d);
         Invocation compareTo = this.getLastInvocation();
 
-        //when
+        // when
         Object result = values.answer(compareTo);
 
-        //then
+        // then
         assertEquals(0, result);
     }
 
@@ -95,7 +95,8 @@ public void should_return_empty_Optional() throws Exception {
 
     @Test
     public void should_return_empty_OptionalDouble() throws Exception {
-        verify_empty_Optional_is_returned("java.util.stream.DoubleStream", "java.util.OptionalDouble");
+        verify_empty_Optional_is_returned(
+                "java.util.stream.DoubleStream", "java.util.OptionalDouble");
     }
 
     @Test
@@ -108,10 +109,11 @@ public void should_return_empty_OptionalLong() throws Exception {
         verify_empty_Optional_is_returned("java.util.stream.LongStream", "java.util.OptionalLong");
     }
 
-    private void verify_empty_Optional_is_returned(String streamFqcn, String optionalFqcn) throws Exception {
+    private void verify_empty_Optional_is_returned(String streamFqcn, String optionalFqcn)
+            throws Exception {
         Class<?> streamType = getClassOrSkipTest(streamFqcn);
 
-        //given
+        // given
         Object stream = mock(streamType);
         Object optional = streamType.getMethod("findAny").invoke(stream);
         assertNotNull(optional);
@@ -119,10 +121,10 @@ private void verify_empty_Optional_is_returned(String streamFqcn, String optiona
 
         Invocation findAny = this.getLastInvocation();
 
-        //when
+        // when
         Object result = values.answer(findAny);
 
-        //then
+        // then
         assertEquals(optional, result);
     }
 
@@ -158,6 +160,22 @@ private void verify_empty_Stream_is_returned(String streamFqcn) throws Exception
         assertEquals("count of empty " + streamFqcn, 0L, count);
     }
 
+    @Test
+    public void should_return_empty_duration() throws Exception {
+        // given
+        final String fqcn = "java.time.Duration";
+        final Class<?> durationClass = getClassOrSkipTest(fqcn);
+
+        // when
+        final Object duration = values.returnValueFor(durationClass);
+        final int nano = (Integer) durationClass.getMethod("getNano").invoke(duration);
+        final long seconds = (Long) durationClass.getMethod("getSeconds").invoke(duration);
+
+        // then
+        assertEquals("nano of empty " + fqcn, 0, nano);
+        assertEquals("seconds of empty " + fqcn, 0L, seconds);
+    }
+
     /**
      * Tries to load the given class. If the class is not found, the complete test is skipped.
      */
@@ -169,5 +187,4 @@ private Class<?> getClassOrSkipTest(String className) {
             return null;
         }
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
new file mode 100644
index 0000000000..21f2e3e7c5
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.Closeable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+import org.junit.Test;
+import org.mockitousage.examples.use.Article;
+
+@SuppressWarnings("unused")
+public class ReturnsGenericDeepStubsTest {
+    interface ListOfInteger extends List<Integer> {}
+
+    interface AnotherListOfInteger extends ListOfInteger {}
+
+    interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {
+        Set<Number> remove(Object key); // override with fixed ParameterizedType
+
+        List<? super Number> returningWildcard();
+
+        Map<String, K> returningNonMockableNestedGeneric();
+
+        K returningK();
+
+        <O extends K> List<O> paramTypeWithTypeParams();
+
+        <S extends Appendable, T extends S> T twoTypeParams(S s);
+
+        <O extends K> O typeVarWithTypeParams();
+
+        Number returnsNormalType();
+    }
+
+    @Test
+    public void generic_deep_mock_frenzy__look_at_these_chained_calls() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        Set<? extends Map.Entry<? extends Cloneable, Set<Number>>> entries = mock.entrySet();
+        Iterator<? extends Map.Entry<? extends Cloneable, Set<Number>>> entriesIterator =
+                mock.entrySet().iterator();
+        Map.Entry<? extends Cloneable, Set<Number>> nextEntry = mock.entrySet().iterator().next();
+
+        Cloneable cloneableKey = mock.entrySet().iterator().next().getKey();
+        Comparable<?> comparableKey = mock.entrySet().iterator().next().getKey();
+
+        Set<Number> value = mock.entrySet().iterator().next().getValue();
+        Iterator<Number> numbersIterator = mock.entrySet().iterator().next().getValue().iterator();
+        Number number = mock.entrySet().iterator().next().getValue().iterator().next();
+    }
+
+    @Test
+    public void
+            can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_parameterizedType_that_is_referencing_a_typeVar_on_class() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        Cloneable
+                cloneable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
+                        mock.paramTypeWithTypeParams().get(0);
+        Comparable<?>
+                comparable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
+                        mock.paramTypeWithTypeParams().get(0);
+    }
+
+    @Test
+    public void
+            can_create_mock_from_multiple_type_variable_bounds_when_method_return_type_is_referencing_a_typeVar_on_class() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        Cloneable cloneable_bound_of_typevar_K = mock.returningK();
+        Comparable<?> comparable_bound_of_typevar_K = mock.returningK();
+    }
+
+    @Test
+    public void
+            can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_typeVar_that_is_referencing_a_typeVar_on_class() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        Cloneable cloneable_bound_of_typevar_K_referenced_by_typevar_O =
+                (Cloneable) mock.typeVarWithTypeParams();
+        Comparable<?> comparable_bound_of_typevar_K_referenced_by_typevar_O =
+                (Comparable<?>) mock.typeVarWithTypeParams();
+    }
+
+    @Test
+    public void can_create_mock_from_return_types_declared_with_a_bounded_wildcard() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        List<? super Integer> objects = mock.returningWildcard();
+        Number type_that_is_the_upper_bound_of_the_wildcard =
+                (Number) mock.returningWildcard().get(45);
+        type_that_is_the_upper_bound_of_the_wildcard.floatValue();
+    }
+
+    @Test
+    public void can_still_work_with_raw_type_in_the_return_type() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        Number the_raw_type_that_should_be_returned = mock.returnsNormalType();
+        the_raw_type_that_should_be_returned.floatValue();
+    }
+
+    @Test
+    public void will_return_default_value_on_non_mockable_nested_generic() {
+        GenericsNest<?> genericsNest = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+        ListOfInteger listOfInteger = mock(ListOfInteger.class, RETURNS_DEEP_STUBS);
+        AnotherListOfInteger anotherListOfInteger =
+                mock(AnotherListOfInteger.class, RETURNS_DEEP_STUBS);
+
+        assertThat(genericsNest.returningNonMockableNestedGeneric().keySet().iterator().next())
+                .isNull();
+        assertThat(listOfInteger.get(25)).isEqualTo(0);
+        assertThat(anotherListOfInteger.get(25)).isEqualTo(0);
+    }
+
+    @Test
+    public void
+            as_expected_fail_with_a_CCE_on_call_site_when_erasure_takes_place_for_example___StringBuilder_is_subject_to_erasure() {
+        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.twoTypeParams(new StringBuilder()).append(2).append(3);
+                        })
+                .isInstanceOf(ClassCastException.class);
+    }
+
+    class WithGenerics<T> {
+        T execute() {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    class SubClass<S> extends WithGenerics<S> {}
+
+    class UserOfSubClass {
+        SubClass<String> generate() {
+            return null;
+        }
+    }
+
+    @Test
+    public void can_handle_deep_stubs_with_generics_at_end_of_deep_invocation() {
+        UserOfSubClass mock = mock(UserOfSubClass.class, RETURNS_DEEP_STUBS);
+
+        when(mock.generate().execute()).thenReturn("sub");
+
+        assertThat(mock.generate().execute()).isEqualTo("sub");
+    }
+
+    public interface TopInterface<T> {
+        T generic();
+    }
+
+    public interface MiddleInterface<T> extends TopInterface<T> {}
+
+    public class OwningClassWithDeclaredUpperBounds<
+            T extends Iterable<Article> & Callable<Article> & Closeable> {
+        public abstract class AbstractInner implements MiddleInterface<T> {}
+    }
+
+    @Test
+    public void
+            cannot_handle_deep_stubs_with_generics_declared_upper_bounds_at_end_of_deep_invocation()
+                    throws Exception {
+        OwningClassWithDeclaredUpperBounds.AbstractInner mock =
+                mock(OwningClassWithDeclaredUpperBounds.AbstractInner.class, RETURNS_DEEP_STUBS);
+
+        // It seems that while the syntax used on OwningClassWithDeclaredUpperBounds.AbstractInner
+        // appear to be legal, the javac compiler does not follow through
+        // hence we need casting, this may also explain why GenericMetadataSupport has trouble to
+        // extract matching data as well.
+
+        assertThat(mock.generic())
+                .describedAs("mock should implement first bound : 'Iterable'")
+                .isInstanceOf(Iterable.class);
+        assertThat(((Iterable<Article>) mock.generic()).iterator())
+                .describedAs("Iterable returns Iterator")
+                .isInstanceOf(Iterator.class);
+        assertThat(((Iterable<Article>) mock.generic()).iterator().next())
+                .describedAs(
+                        "Cannot yet extract Type argument 'Article' so return null instead of a mock "
+                                + "of type Object (which would raise CCE on the call-site)")
+                .isNull();
+
+        assertThat(mock.generic())
+                .describedAs("mock should implement second interface bound : 'Callable'")
+                .isInstanceOf(Callable.class);
+        assertThat(((Callable<Article>) mock.generic()).call())
+                .describedAs(
+                        "Cannot yet extract Type argument 'Article' so return null instead of a mock "
+                                + "of type Object (which would raise CCE on the call-site)")
+                .isNull();
+
+        assertThat(mock.generic())
+                .describedAs("mock should implement third interface bound : 'Closeable'")
+                .isInstanceOf(Closeable.class);
+    }
+}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
similarity index 77%
rename from src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
rename to mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
index 758d7ea599..3691412e58 100755
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
@@ -19,19 +19,19 @@ public class ReturnsMocksTest extends TestBase {
 
     interface AllInterface {
         FooInterface getInterface();
+
         BarClass getNormalClass();
+
         Baz getFinalClass();
+
         WithGenerics<String> withGenerics();
     }
 
-    interface FooInterface {
-    }
+    interface FooInterface {}
 
-    class BarClass {
-    }
+    class BarClass {}
 
-    final class Baz {
-    }
+    final class Baz {}
 
     @Test
     public void should_return_mock_value_for_interface() throws Throwable {
@@ -48,7 +48,9 @@ public void should_return_mock_value_for_class() throws Throwable {
     @SuppressWarnings("unchecked")
     @Test
     public void should_return_mock_value_for_generic_class() throws Throwable {
-        WithGenerics<String> classMock = (WithGenerics<String>) values.answer(invocationOf(AllInterface.class, "withGenerics"));
+        WithGenerics<String> classMock =
+                (WithGenerics<String>)
+                        values.answer(invocationOf(AllInterface.class, "withGenerics"));
         assertTrue(MockUtil.isMock(classMock));
         when(classMock.execute()).thenReturn("return");
         assertEquals("return", classMock.execute());
@@ -63,10 +65,14 @@ public void should_return_null_for_final_class_if_unsupported() throws Throwable
     @Test
     public void should_return_the_usual_default_values_for_primitives() throws Throwable {
         ReturnsMocks answer = new ReturnsMocks();
-        assertEquals(false, answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
-        assertEquals((char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
-        assertEquals((byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
-        assertEquals((short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
+        assertEquals(
+                false, answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
+        assertEquals(
+                (char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
+        assertEquals(
+                (byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
+        assertEquals(
+                (short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
         assertEquals(0, answer.answer(invocationOf(HasPrimitiveMethods.class, "intMethod")));
         assertEquals(0L, answer.answer(invocationOf(HasPrimitiveMethods.class, "longMethod")));
         assertEquals(0f, answer.answer(invocationOf(HasPrimitiveMethods.class, "floatMethod")));
@@ -76,12 +82,14 @@ public void should_return_the_usual_default_values_for_primitives() throws Throw
     @SuppressWarnings("unused")
     interface StringMethods {
         String stringMethod();
+
         String[] stringArrayMethod();
     }
 
     @Test
     public void should_return_empty_array() throws Throwable {
-        String[] ret = (String[]) values.answer(invocationOf(StringMethods.class, "stringArrayMethod"));
+        String[] ret =
+                (String[]) values.answer(invocationOf(StringMethods.class, "stringArrayMethod"));
 
         assertTrue(ret.getClass().isArray());
         assertTrue(ret.length == 0);
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java
rename to mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsOptionalMocksTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsOptionalMocksTest.java
new file mode 100644
index 0000000000..3364b6d984
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsOptionalMocksTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import org.junit.Test;
+
+public class ReturnsOptionalMocksTest {
+    private interface Type {
+        Optional<String> getOptString();
+
+        OptionalLong getOptLong();
+
+        OptionalDouble getOptDouble();
+
+        OptionalInt getOptInt();
+    }
+
+    @Test
+    public void deepStubs_Optional_should_return_normal_optional_empty_Issue2865() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        assertThat(type.getOptString()).isEqualTo(Optional.empty());
+        assertIsNoMock(type.getOptString());
+    }
+
+    @Test
+    public void deepStubs_OptionalLong_should_return_normal_optional_empty() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        assertThat(type.getOptLong()).isEqualTo(OptionalLong.empty());
+        assertIsNoMock(type.getOptLong());
+    }
+
+    @Test
+    public void deepStubs_OptionalDouble_should_normal_optional_empty() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        assertThat(type.getOptDouble()).isEqualTo(OptionalDouble.empty());
+        assertIsNoMock(type.getOptDouble());
+    }
+
+    @Test
+    public void deepStubs_OptionalInt_should_normal_optional_empty() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        assertThat(type.getOptInt()).isEqualTo(OptionalInt.empty());
+        assertIsNoMock(type.getOptInt());
+    }
+
+    @Test
+    public void normal_mock_Optional_should_return_normal_optional_empty() {
+        final Type type = mock(Type.class);
+        assertThat(type.getOptString()).isEqualTo(Optional.empty());
+        assertIsNoMock(type.getOptString());
+    }
+
+    @Test
+    public void normal_mock_OptionalLong_should_return_normal_optional_empty() {
+        final Type type = mock(Type.class);
+        assertThat(type.getOptLong()).isEqualTo(OptionalLong.empty());
+    }
+
+    @Test
+    public void normal_mock_OptionalDouble_should_return_normal_optional_empty() {
+        final Type type = mock(Type.class);
+        assertThat(type.getOptDouble()).isEqualTo(OptionalDouble.empty());
+    }
+
+    @Test
+    public void normal_mock_OptionalInt_should_return_normal_optional_empty() {
+        final Type type = mock(Type.class);
+        assertThat(type.getOptInt()).isEqualTo(OptionalInt.empty());
+    }
+
+    @Test
+    public void deepStubs_Optional_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        Optional<String> opt = type.getOptString();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void deepStubs_OptionalLong_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        OptionalLong opt = type.getOptLong();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void deepStubs_OptionalDouble_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        OptionalDouble opt = type.getOptDouble();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void deepStubs_OptionalInt_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class, RETURNS_DEEP_STUBS);
+        OptionalInt opt = type.getOptInt();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void normal_mock_Optional_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class);
+
+        Optional<String> opt = type.getOptString();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void normal_mock_OptionalLong_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class);
+
+        OptionalLong opt = type.getOptLong();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void normal_mock_OptionalDouble_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class);
+
+        OptionalDouble opt = type.getOptDouble();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    @Test
+    public void normal_mock_OptionalInt_isPresent_isEmpty_Issue2865() {
+        final Type type = mock(Type.class);
+
+        OptionalInt opt = type.getOptInt();
+        assertThat(opt.isPresent()).isEqualTo(false);
+        assertThat(opt.isEmpty()).isEqualTo(true);
+    }
+
+    private void assertIsNoMock(Object mock) {
+        assertThat(mockingDetails(mock).isMock()).isFalse();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
new file mode 100644
index 0000000000..267c6d6966
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.exceptions.verification.SmartNullPointerException;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.invocation.InterceptedInvocation;
+import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.invocation.mockref.MockStrongReference;
+import org.mockito.stubbing.Answer;
+import org.mockitoutil.TestBase;
+
+public class ReturnsSmartNullsTest extends TestBase {
+
+    @Test
+    public void should_return_the_usual_default_values_for_primitives() throws Throwable {
+        Answer<Object> answer = new ReturnsSmartNulls();
+        assertEquals(
+                false, answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
+        assertEquals(
+                (char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
+        assertEquals(
+                (byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
+        assertEquals(
+                (short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
+        assertEquals(0, answer.answer(invocationOf(HasPrimitiveMethods.class, "intMethod")));
+        assertEquals(0L, answer.answer(invocationOf(HasPrimitiveMethods.class, "longMethod")));
+        assertEquals(0f, answer.answer(invocationOf(HasPrimitiveMethods.class, "floatMethod")));
+        assertEquals(0d, answer.answer(invocationOf(HasPrimitiveMethods.class, "doubleMethod")));
+    }
+
+    @SuppressWarnings("unused")
+    interface Foo {
+        Foo get();
+
+        Foo withArgs(String oneArg, String otherArg);
+    }
+
+    @Test
+    public void should_return_an_object_that_fails_on_any_method_invocation_for_non_primitives()
+            throws Throwable {
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "get"));
+
+        try {
+            smartNull.get();
+            fail();
+        } catch (SmartNullPointerException expected) {
+        }
+    }
+
+    @Test
+    public void should_return_an_object_that_allows_object_methods() throws Throwable {
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "get"));
+
+        assertThat(smartNull.toString()).contains("SmartNull returned by").contains("foo.get()");
+    }
+
+    @Test
+    public void should_print_the_parameters_when_calling_a_method_with_args() throws Throwable {
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "withArgs", "oompa", "lumpa"));
+
+        assertThat(smartNull.toString())
+                .contains("foo.withArgs")
+                .contains("oompa")
+                .contains("lumpa");
+    }
+
+    @Test
+    public void should_print_the_parameters_on_SmartNullPointerException_message()
+            throws Throwable {
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "withArgs", "oompa", "lumpa"));
+
+        try {
+            smartNull.get();
+            fail();
+        } catch (SmartNullPointerException e) {
+            assertThat(e).hasMessageContaining("oompa").hasMessageContaining("lumpa");
+        }
+    }
+
+    interface GenericFoo<T> {
+        T get();
+    }
+
+    interface GenericFooBar extends GenericFoo<Foo> {
+        <I> I method();
+
+        <I> I methodWithArgs(int firstArg, I secondArg);
+
+        <I> I methodWithVarArgs(int firstArg, I... secondArg);
+    }
+
+    @Test
+    public void should_return_an_object_that_has_been_defined_with_class_generic()
+            throws Throwable {
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Foo smartNull = (Foo) answer.answer(invocationOf(GenericFooBar.class, "get"));
+
+        assertThat(smartNull.toString())
+                .contains("SmartNull returned by")
+                .contains("genericFooBar.get()");
+    }
+
+    @Test
+    public void should_return_an_object_that_has_been_defined_with_method_generic()
+            throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        String smartNull = (String) answer.answer(invocationOf(GenericFooBar.class, "method"));
+
+        assertThat(smartNull).isNull();
+    }
+
+    private static <T> InterceptedInvocation invocationMethodWithArgs(final T obj)
+            throws NoSuchMethodException {
+        return new InterceptedInvocation(
+                new MockStrongReference<Object>(mock(GenericFooBar.class), false),
+                new SerializableMethod(
+                        GenericFooBar.class.getMethod("methodWithArgs", int.class, Object.class)),
+                new Object[] {1, obj},
+                InterceptedInvocation.NO_OP,
+                LocationFactory.create(),
+                1);
+    }
+
+    @Test
+    public void
+            should_return_a_String_that_has_been_defined_with_method_generic_and_provided_in_argument()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithArgs("secondArg"));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(String.class).asString().isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_empty_list_that_has_been_defined_with_method_generic_and_provided_in_argument()
+                    throws Throwable {
+
+        final List<String> list = Collections.singletonList("String");
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithArgs(list));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(List.class);
+        assertThat((List) smartNull).isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_empty_map_that_has_been_defined_with_method_generic_and_provided_in_argument()
+                    throws Throwable {
+
+        final Map<String, String> map = new HashMap<String, String>();
+        map.put("key-1", "value-1");
+        map.put("key-2", "value-2");
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithArgs(map));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(Map.class);
+        assertThat((Map) smartNull).isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_empty_set_that_has_been_defined_with_method_generic_and_provided_in_argument()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull =
+                answer.answer(
+                        invocationMethodWithArgs(
+                                new HashSet<String>(Arrays.asList("set-1", "set-2"))));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(Set.class);
+        assertThat((Set) smartNull).isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_new_mock_that_has_been_defined_with_method_generic_and_provided_in_argument()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+        final Foo mock = mock(Foo.class);
+
+        Object smartNull = answer.answer(invocationMethodWithArgs(mock));
+
+        assertThat(smartNull).isNotNull().isNotSameAs(mock);
+        assertThat(smartNull.toString())
+                .contains("SmartNull returned by")
+                .contains("genericFooBar.methodWithArgs(");
+    }
+
+    @Test
+    public void
+            should_return_an_Object_that_has_been_defined_with_method_generic_and_provided_in_argument()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithArgs(new Object() {}));
+
+        assertThat(smartNull.toString())
+                .contains("SmartNull returned by")
+                .contains("genericFooBar.methodWithArgs(");
+    }
+
+    @Test
+    public void should_throw_a_error_on_invocation_of_returned_mock() throws Throwable {
+
+        final Answer<Object> answer = new ReturnsSmartNulls();
+        final Foo mock = mock(Foo.class);
+
+        final Throwable throwable =
+                Assertions.catchThrowable(
+                        new ThrowableAssert.ThrowingCallable() {
+                            @Override
+                            public void call() throws Throwable {
+                                ((Foo) answer.answer(invocationMethodWithArgs(mock))).get();
+                            }
+                        });
+
+        Assertions.assertThat(throwable)
+                .isInstanceOf(SmartNullPointerException.class)
+                .hasMessageContaining("genericFooBar.methodWithArgs(")
+                .hasMessageContaining("1")
+                .hasMessageContaining(mock.toString());
+    }
+
+    private static <T> InterceptedInvocation invocationMethodWithVarArgs(final T[] obj)
+            throws NoSuchMethodException {
+        return new InterceptedInvocation(
+                new MockStrongReference<Object>(mock(GenericFooBar.class), false),
+                new SerializableMethod(
+                        GenericFooBar.class.getMethod(
+                                "methodWithVarArgs", int.class, Object[].class)),
+                new Object[] {1, obj},
+                InterceptedInvocation.NO_OP,
+                LocationFactory.create(),
+                1);
+    }
+
+    @Test
+    public void
+            should_return_a_String_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull =
+                answer.answer(invocationMethodWithVarArgs(new String[] {"varArg-1", "varArg-2"}));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(String.class).asString().isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_empty_list_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+                    throws Throwable {
+
+        final List<String> arg1 = Collections.singletonList("String");
+        final List<String> arg2 = Arrays.asList("str-1", "str-2");
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithVarArgs(new List[] {arg1, arg2}));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(List.class);
+        assertThat((List) smartNull).isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_empty_map_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+                    throws Throwable {
+
+        final Map<String, String> map1 = new HashMap<>();
+        map1.put("key-1", "value-1");
+        map1.put("key-2", "value-2");
+
+        final Map<String, String> map2 = new HashMap<>();
+        map2.put("key-3", "value-1");
+        map2.put("key-4", "value-2");
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithVarArgs(new Map[] {map1, map2}));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(Map.class);
+        assertThat((Map) smartNull).isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_empty_set_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+                    throws Throwable {
+
+        final HashSet<String> set1 = new HashSet<String>(Arrays.asList("set-1", "set-2"));
+        final HashSet<String> set2 = new HashSet<String>(Arrays.asList("set-1", "set-2"));
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull = answer.answer(invocationMethodWithVarArgs(new HashSet[] {set1, set2}));
+
+        assertThat(smartNull).isNotNull().isInstanceOf(Set.class);
+        assertThat((Set) smartNull).isEmpty();
+    }
+
+    @Test
+    public void
+            should_return_a_new_mock_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+        final Foo mock1 = mock(Foo.class);
+        final Foo mock2 = mock(Foo.class);
+
+        Object smartNull = answer.answer(invocationMethodWithVarArgs(new Foo[] {mock1, mock2}));
+
+        assertThat(smartNull).isNotNull().isNotSameAs(mock1).isNotSameAs(mock2);
+        assertThat(smartNull.toString())
+                .contains("SmartNull returned by")
+                .contains("genericFooBar.methodWithVarArgs(");
+    }
+
+    @Test
+    public void
+            should_return_an_Object_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+                    throws Throwable {
+
+        Answer<Object> answer = new ReturnsSmartNulls();
+
+        Object smartNull =
+                answer.answer(
+                        invocationMethodWithVarArgs(
+                                new Object[] {new Object() {}, new Object() {}}));
+
+        assertThat(smartNull.toString())
+                .contains("SmartNull returned by")
+                .contains("genericFooBar.methodWithVarArgs(");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/ChecksTest.java b/mockito-core/src/test/java/org/mockito/internal/util/ChecksTest.java
new file mode 100644
index 0000000000..6b640dbe01
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/ChecksTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class ChecksTest {
+
+    @Test
+    public void checkNotNull_not_null() {
+        assertEquals("abc", Checks.checkNotNull("abc", "someValue"));
+    }
+
+    @Test
+    public void checkNotNull_not_null_additional_message() {
+        assertEquals("abc", Checks.checkNotNull("abc", "someValue", "Oh no!"));
+    }
+
+    @Test
+    public void checkNotNull_null() {
+        assertThatThrownBy(
+                        () -> {
+                            Checks.checkNotNull(null, "someValue");
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("someValue should not be null");
+    }
+
+    @Test
+    public void checkNotNull_null_additonal_message() {
+        assertThatThrownBy(
+                        () -> {
+                            Checks.checkNotNull(null, "someValue", "Oh no!");
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("someValue should not be null. Oh no!");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java b/mockito-core/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
new file mode 100644
index 0000000000..1a126d6dd7
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.stubbing.Stubbing;
+import org.mockitousage.IMethods;
+
+@SuppressWarnings("unchecked")
+public class DefaultMockingDetailsTest {
+
+    @Mock private Foo foo;
+    @Mock private Bar bar;
+    @Mock private IMethods mock;
+    @Spy private Gork gork;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    public void should_provide_original_mock() throws Exception {
+        // expect
+        assertEquals(mockingDetails(foo).getMock(), foo);
+        assertEquals(mockingDetails(null).getMock(), null);
+    }
+
+    @Test
+    public void should_know_spy() {
+        assertTrue(mockingDetails(gork).isMock());
+        assertTrue(mockingDetails(spy(new Gork())).isMock());
+        assertTrue(mockingDetails(spy(Gork.class)).isMock());
+        assertTrue(
+                mockingDetails(
+                                mock(
+                                        Gork.class,
+                                        withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS)))
+                        .isMock());
+    }
+
+    @Test
+    public void should_know_mock() {
+        assertTrue(mockingDetails(foo).isMock());
+        assertTrue(mockingDetails(mock(Foo.class)).isMock());
+        assertFalse(mockingDetails(foo).isSpy());
+        assertFalse(mockingDetails(mock(Foo.class)).isSpy());
+    }
+
+    @Test
+    public void should_handle_non_mocks() {
+        assertFalse(mockingDetails("non mock").isSpy());
+        assertFalse(mockingDetails("non mock").isMock());
+
+        assertFalse(mockingDetails(null).isSpy());
+        assertFalse(mockingDetails(null).isMock());
+    }
+
+    @Test
+    public void should_check_that_a_spy_is_also_a_mock() throws Exception {
+        assertEquals(true, mockingDetails(gork).isMock());
+    }
+
+    @Test
+    public void provides_invocations() {
+        // when
+        mock.simpleMethod(10);
+        mock.otherMethod();
+
+        // then
+        assertEquals(0, mockingDetails(foo).getInvocations().size());
+        assertEquals(
+                "[mock.simpleMethod(10);, mock.otherMethod();]",
+                mockingDetails(mock).getInvocations().toString());
+    }
+
+    @Test
+    public void manipulating_invocations_is_safe() {
+        mock.simpleMethod();
+
+        // when we manipulate the invocations
+        mockingDetails(mock).getInvocations().clear();
+
+        // then we didn't actually changed the invocations
+        assertEquals(1, mockingDetails(mock).getInvocations().size());
+    }
+
+    @Test
+    public void provides_mock_creation_settings() {
+        // smoke test some creation settings
+        assertEquals(Foo.class, mockingDetails(foo).getMockCreationSettings().getTypeToMock());
+        assertEquals(Bar.class, mockingDetails(bar).getMockCreationSettings().getTypeToMock());
+        assertEquals(0, mockingDetails(mock).getMockCreationSettings().getExtraInterfaces().size());
+    }
+
+    @Test
+    public void fails_when_getting_creation_settings_for_incorrect_input() {
+        assertThatThrownBy(
+                        () -> {
+                            mockingDetails(null).getMockCreationSettings();
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage(
+                        "Argument passed to Mockito.mockingDetails() should be a mock, but is null!");
+    }
+
+    @Test
+    public void fails_when_getting_invocations_when_null() {
+        try {
+            // when
+            mockingDetails(null).getInvocations();
+            // then
+            fail();
+        } catch (NotAMockException e) {
+            assertEquals(
+                    "Argument passed to Mockito.mockingDetails() should be a mock, but is null!",
+                    e.getMessage());
+        }
+    }
+
+    @Test
+    public void fails_when_getting_invocations_when_not_mock() {
+        try {
+            // when
+            mockingDetails(new Object()).getInvocations();
+            // then
+            fail();
+        } catch (NotAMockException e) {
+            assertEquals(
+                    "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!",
+                    e.getMessage());
+        }
+    }
+
+    @Test
+    public void fails_when_getting_stubbings_from_non_mock() {
+        try {
+            // when
+            mockingDetails(new Object()).getStubbings();
+            // then
+            fail();
+        } catch (NotAMockException e) {
+            assertEquals(
+                    "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!",
+                    e.getMessage());
+        }
+    }
+
+    @Test
+    public void mock_with_no_stubbings() {
+        assertTrue(mockingDetails(mock).getStubbings().isEmpty());
+    }
+
+    @Test
+    public void provides_stubbings_of_mock_in_declaration_order() {
+        when(mock.simpleMethod(1)).thenReturn("1");
+        when(mock.otherMethod()).thenReturn("2");
+
+        // when
+        Collection<Stubbing> stubbings = mockingDetails(mock).getStubbings();
+
+        // then
+        assertEquals(2, stubbings.size());
+        assertEquals(
+                "[mock.simpleMethod(1); stubbed with: [Returns: 1], mock.otherMethod(); stubbed with: [Returns: 2]]",
+                stubbings.toString());
+    }
+
+    @Test
+    public void manipulating_stubbings_explicitly_is_safe() {
+        when(mock.simpleMethod(1)).thenReturn("1");
+
+        // when somebody manipulates stubbings directly
+        mockingDetails(mock).getStubbings().clear();
+
+        // then it does not affect stubbings of the mock
+        assertEquals(1, mockingDetails(mock).getStubbings().size());
+    }
+
+    @Test
+    public void prints_invocations() throws Exception {
+        // given
+        given(mock.simpleMethod("different arg")).willReturn("foo");
+        mock.simpleMethod("arg");
+
+        // when
+        String log = Mockito.mockingDetails(mock).printInvocations();
+
+        // then
+        assertThat(log).containsIgnoringCase("unused");
+        assertThat(log).containsIgnoringCase("mock.simpleMethod(\"arg\")");
+        assertThat(log).containsIgnoringCase("mock.simpleMethod(\"different arg\")");
+    }
+
+    @Test
+    public void fails_when_printin_invocations_from_non_mock() {
+        try {
+            // when
+            mockingDetails(new Object()).printInvocations();
+            // then
+            fail();
+        } catch (NotAMockException e) {
+            assertEquals(
+                    "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!",
+                    e.getMessage());
+        }
+    }
+
+    public class Foo {}
+
+    public interface Bar {}
+
+    public static class Gork {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java b/mockito-core/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
new file mode 100644
index 0000000000..7491a3f070
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+
+@SuppressWarnings("unchecked")
+public class MockCreationValidatorTest {
+
+    MockCreationValidator validator = new MockCreationValidator();
+
+    @Test
+    public void should_not_allow_extra_interface_that_is_the_same_as_the_mocked_type() {
+        try {
+            // when
+            validator.validateExtraInterfaces(IMethods.class, (Collection) asList(IMethods.class));
+            fail();
+        } catch (MockitoException e) {
+            // then
+            assertThat(e.getMessage()).contains("You mocked following type: IMethods");
+        }
+    }
+
+    @Test
+    public void should_not_allow_inconsistent_types() {
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            validator.validateMockedType(List.class, new ArrayList());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Mocked type must be the same as the type of your spied instance.",
+                        "Mocked type must be: ArrayList, but is: List");
+    }
+
+    @Test
+    public void should_allow_only_consistent_types() {
+        // when
+        validator.validateMockedType(ArrayList.class, new ArrayList());
+        // then no exception is thrown
+    }
+
+    @Test
+    public void should_validation_be_safe_when_nulls_passed() {
+        // when
+        validator.validateMockedType(null, new ArrayList());
+        // or
+        validator.validateMockedType(ArrayList.class, null);
+        // then no exception is thrown
+    }
+
+    @Test
+    public void should_fail_when_type_not_mockable() {
+        try {
+            validator.validateType(long.class, null);
+        } catch (MockitoException ex) {
+            assertThat(ex.getMessage()).contains("primitive");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/MockNameImplTest.java b/mockito-core/src/test/java/org/mockito/internal/util/MockNameImplTest.java
new file mode 100644
index 0000000000..28e8f96ed3
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/MockNameImplTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.mockito.mock.MockType;
+import org.mockitoutil.TestBase;
+
+public class MockNameImplTest extends TestBase {
+
+    @Test
+    public void shouldProvideTheNameForClass() throws Exception {
+        // when
+        String name = new MockNameImpl(null, SomeClass.class, MockType.INSTANCE).toString();
+        // then
+        assertEquals("someClass", name);
+    }
+
+    @Test
+    public void shouldProvideTheNameForClassOnStaticMock() throws Exception {
+        // when
+        String name = new MockNameImpl(null, SomeClass.class, MockType.STATIC).toString();
+        // then
+        assertEquals("SomeClass.class", name);
+    }
+
+    @Test
+    public void shouldProvideTheNameForAnonymousClass() throws Exception {
+        // given
+        SomeInterface anonymousInstance = new SomeInterface() {};
+        // when
+        String name =
+                new MockNameImpl(null, anonymousInstance.getClass(), MockType.INSTANCE).toString();
+        // then
+        assertEquals("someInterface", name);
+    }
+
+    @Test
+    public void shouldProvideTheNameForAnonymousClassOnStatic() throws Exception {
+        // given
+        SomeInterface anonymousInstance = new SomeInterface() {};
+        // when
+        String name =
+                new MockNameImpl(null, anonymousInstance.getClass(), MockType.STATIC).toString();
+        // then
+        assertEquals("SomeInterface$.class", name);
+    }
+
+    @Test
+    public void shouldProvideTheGivenName() throws Exception {
+        // when
+        String name = new MockNameImpl("The Hulk", SomeClass.class, MockType.INSTANCE).toString();
+        // then
+        assertEquals("The Hulk", name);
+    }
+
+    @Test
+    public void shouldProvideTheGivenNameOnStatic() throws Exception {
+        // when
+        String name = new MockNameImpl("The Hulk", SomeClass.class, MockType.STATIC).toString();
+        // then
+        assertEquals("The Hulk", name);
+    }
+
+    private class SomeClass {}
+
+    private class SomeInterface {}
+}
diff --git a/src/test/java/org/mockito/internal/util/MockSettingsTest.java b/mockito-core/src/test/java/org/mockito/internal/util/MockSettingsTest.java
similarity index 77%
rename from src/test/java/org/mockito/internal/util/MockSettingsTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/MockSettingsTest.java
index 5344937327..ab39828b10 100644
--- a/src/test/java/org/mockito/internal/util/MockSettingsTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/MockSettingsTest.java
@@ -18,22 +18,21 @@
 public class MockSettingsTest extends TestBase {
     @Test
     public void public_api_for_creating_settings() throws Exception {
-        //when
-        MockCreationSettings<List> settings = Mockito.withSettings()
-            .name("dummy")
-            .build(List.class);
+        // when
+        MockCreationSettings<List> settings =
+                Mockito.withSettings().name("dummy").build(List.class);
 
-        //then
+        // then
         assertEquals(List.class, settings.getTypeToMock());
         assertEquals("dummy", settings.getMockName().toString());
     }
+
     @Test
     public void test_without_annotations() throws Exception {
-        MockCreationSettings<List> settings = Mockito.withSettings()
-            .withoutAnnotations()
-            .build(List.class);
+        MockCreationSettings<List> settings =
+                Mockito.withSettings().withoutAnnotations().build(List.class);
 
-        CreationSettings copy = new CreationSettings((CreationSettings)settings);
+        CreationSettings copy = new CreationSettings((CreationSettings) settings);
 
         assertEquals(List.class, settings.getTypeToMock());
         assertEquals(List.class, copy.getTypeToMock());
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/MockUtilTest.java b/mockito-core/src/test/java/org/mockito/internal/util/MockUtilTest.java
new file mode 100644
index 0000000000..834178cdec
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/MockUtilTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class MockUtilTest extends TestBase {
+
+    @Test
+    public void should_get_handler() {
+        List<?> mock = Mockito.mock(List.class);
+        assertNotNull(MockUtil.getMockHandler(mock));
+    }
+
+    @Test
+    public void should_scream_when_not_a_mock_passed() {
+        assertThatThrownBy(
+                        () -> {
+                            MockUtil.getMockHandler("");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is: class java.lang.String");
+    }
+
+    @Test
+    public void should_scream_when_null_passed() {
+        assertThatThrownBy(
+                        () -> {
+                            MockUtil.getMockHandler(null);
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is null!");
+    }
+
+    @Test
+    public void should_get_mock_settings() {
+        List<?> mock = Mockito.mock(List.class);
+        assertNotNull(MockUtil.getMockSettings(mock));
+    }
+
+    @Test
+    public void should_validate_mock() {
+        assertFalse(MockUtil.isMock("i mock a mock"));
+        assertTrue(MockUtil.isMock(Mockito.mock(List.class)));
+    }
+
+    @Test
+    public void should_validate_spy() {
+        assertFalse(MockUtil.isSpy("i mock a mock"));
+        assertFalse(MockUtil.isSpy(Mockito.mock(List.class)));
+        assertFalse(MockUtil.isSpy(null));
+
+        assertTrue(MockUtil.isSpy(Mockito.spy(new ArrayList())));
+        assertTrue(MockUtil.isSpy(Mockito.spy(ArrayList.class)));
+        assertTrue(
+                MockUtil.isSpy(
+                        Mockito.mock(
+                                ArrayList.class,
+                                withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))));
+    }
+
+    @Test
+    public void should_redefine_MockName_if_default() {
+        List<?> mock = Mockito.mock(List.class);
+        MockUtil.maybeRedefineMockName(mock, "newName");
+
+        Assertions.assertThat(MockUtil.getMockName(mock).toString()).isEqualTo("newName");
+    }
+
+    @Test
+    public void should_not_redefine_MockName_if_default() {
+        List<?> mock = Mockito.mock(List.class, "original");
+        MockUtil.maybeRedefineMockName(mock, "newName");
+
+        Assertions.assertThat(MockUtil.getMockName(mock).toString()).isEqualTo("original");
+    }
+
+    final class FinalClass {}
+
+    class SomeClass {}
+
+    interface SomeInterface {}
+
+    @Test
+    public void should_know_if_type_is_mockable() throws Exception {
+        Assertions.assertThat(MockUtil.typeMockabilityOf(FinalClass.class, null).mockable())
+                .isEqualTo(Plugins.getMockMaker().isTypeMockable(FinalClass.class).mockable());
+
+        assertFalse(MockUtil.typeMockabilityOf(int.class, null).mockable());
+
+        assertTrue(MockUtil.typeMockabilityOf(SomeClass.class, null).mockable());
+        assertTrue(MockUtil.typeMockabilityOf(SomeInterface.class, null).mockable());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java b/mockito-core/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
new file mode 100644
index 0000000000..3f9c594a8d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Date;
+
+import org.junit.Test;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class ObjectMethodsGuruTest extends TestBase {
+
+    private interface HasCompareToButDoesNotImplementComparable {
+        int compareTo(HasCompareToButDoesNotImplementComparable other);
+    }
+
+    private interface HasCompare extends Comparable<HasCompare> {
+        int foo(HasCompare other);
+
+        int compareTo(HasCompare other, String redHerring);
+
+        int compareTo(String redHerring);
+
+        int compareTo(HasCompare redHerring);
+    }
+
+    @Test
+    public void shouldKnowToStringMethod() throws Exception {
+        assertFalse(
+                ObjectMethodsGuru.isToStringMethod(Object.class.getMethod("equals", Object.class)));
+        assertFalse(
+                ObjectMethodsGuru.isToStringMethod(
+                        IMethods.class.getMethod("toString", String.class)));
+        assertTrue(ObjectMethodsGuru.isToStringMethod(IMethods.class.getMethod("toString")));
+    }
+
+    @Test
+    public void shouldKnowCompareToMethod() throws Exception {
+        assertFalse(ObjectMethodsGuru.isCompareToMethod(Date.class.getMethod("toString")));
+        assertFalse(
+                ObjectMethodsGuru.isCompareToMethod(
+                        HasCompare.class.getMethod("foo", HasCompare.class)));
+        assertFalse(
+                ObjectMethodsGuru.isCompareToMethod(
+                        HasCompare.class.getMethod("compareTo", HasCompare.class, String.class)));
+        assertFalse(
+                ObjectMethodsGuru.isCompareToMethod(
+                        HasCompare.class.getMethod("compareTo", String.class)));
+        assertFalse(
+                ObjectMethodsGuru.isCompareToMethod(
+                        HasCompareToButDoesNotImplementComparable.class.getDeclaredMethod(
+                                "compareTo", HasCompareToButDoesNotImplementComparable.class)));
+
+        assertTrue(
+                ObjectMethodsGuru.isCompareToMethod(
+                        HasCompare.class.getMethod("compareTo", HasCompare.class)));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/PlatformTest.java b/mockito-core/src/test/java/org/mockito/internal/util/PlatformTest.java
new file mode 100644
index 0000000000..42f59a1bc6
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/PlatformTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+
+// Possible description on a IBM J9 VM (see #801)
+//
+// java.specification.version = 1.8
+// java.vm.vendor = IBM Corporation
+// java.vm.version = 2.8
+// java.vm.name = IBM J9 VM
+// java.runtime.version = pwa6480sr1fp10-20150711_01 (SR1 FP10)
+// java.vm.info =
+//   JRE 1.8.0 Windows 7 amd64-64 Compressed References 20150630_255633 (JIT enabled, AOT enabled)
+//   J9VM - R28_jvm.28_20150630_1742_B255633
+//   JIT  - tr.r14.java_20150625_95081.01
+//   GC   - R28_jvm.28_20150630_1742_B255633_CMPRSS
+//   J9CL - 20150630_255633
+// os.name = Windows 7
+// os.version = 6.1
+public class PlatformTest {
+    // TODO use ClassLoaders
+
+    @Test
+    public void const_are_initialized_from_system_properties() {
+        System.out.println(Platform.describe());
+
+        assertThat(Platform.JVM_VERSION).isEqualTo(System.getProperty("java.runtime.version"));
+        assertThat(Platform.JVM_INFO).isEqualTo(System.getProperty("java.vm.info"));
+        assertThat(Platform.JVM_NAME).isEqualTo(System.getProperty("java.vm.name"));
+        assertThat(Platform.JVM_VENDOR).isEqualTo(System.getProperty("java.vm.vendor"));
+        assertThat(Platform.JVM_VENDOR_VERSION).isEqualTo(System.getProperty("java.vm.version"));
+    }
+
+    @Test
+    public void should_warn_for_jvm() throws Exception {
+        assertThat(
+                        Platform.warnForVM(
+                                "Java HotSpot(TM) 64-Bit Server VM",
+                                "HotSpot",
+                                "hotspot warning",
+                                "IBM",
+                                "ibm warning"))
+                .isEqualTo("hotspot warning");
+        assertThat(
+                        Platform.warnForVM(
+                                "IBM J9 VM", "HotSpot", "hotspot warning", "IBM", "ibm warning"))
+                .isEqualTo("ibm warning");
+        assertThat(
+                        Platform.warnForVM(
+                                "whatever",
+                                null,
+                                "should not be returned",
+                                null,
+                                "should not be returned"))
+                .isEqualTo("");
+    }
+
+    @Test
+    public void should_parse_open_jdk9_string() {
+        // The tested method targets Java 8 but should be able to parse other Java version numbers
+        // including Java 9
+
+        // Given
+        // Sources :
+        //  - https://openjdk.java.net/jeps/223 (Java 9)
+        //
+        // System Property                 Existing      Proposed
+        // ------------------------------- ------------  --------
+        // Early Access
+        // java.runtime.version            1.9.0-ea-b73  9-ea+73
+        // java.vm.version                 1.9.0-ea-b73  9-ea+73
+        // java.specification.version      1.9           9
+        // java.vm.specification.version   1.9           9
+        //
+        // Major (GA)
+        // java.version                    1.9.0         9
+        // java.runtime.version            1.9.0-b100    9+100
+        // java.vm.version                 1.9.0-b100    9+100
+        // java.specification.version      1.9           9
+        // java.vm.specification.version   1.9           9
+        //
+        // Minor #1 (GA)
+        // java.version                    1.9.0_20      9.1.2
+        // java.runtime.version            1.9.0_20-b62  9.1.2+62
+        // java.vm.version                 1.9.0_20-b62  9.1.2+62
+        // java.specification.version      1.9           9
+        // java.vm.specification.version   1.9           9
+        //
+        // Security #1 (GA)
+        // java.version                    1.9.0_5       9.0.1
+        // java.runtime.version            1.9.0_5-b20   9.0.1+20
+        // java.vm.version                 1.9.0_5-b20   9.0.1+20
+        // java.specification.version      1.9           9
+        // java.vm.specification.version   1.9           9
+        //
+        Map<String, Boolean> versions = new HashMap<>();
+        versions.put("9-ea+73", false);
+        versions.put("9+100", false);
+        versions.put("9.1.2+62", false);
+        versions.put("9.0.1+20", false);
+
+        assertPlatformParsesCorrectlyVariousVersionScheme(versions);
+    }
+
+    private void assertPlatformParsesCorrectlyVariousVersionScheme(Map<String, Boolean> versions) {
+        for (Map.Entry<String, Boolean> version : versions.entrySet()) {
+            assertThat(version.getValue()).describedAs(version.getKey()).isEqualTo(false);
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/util/PrimitivesTest.java b/mockito-core/src/test/java/org/mockito/internal/util/PrimitivesTest.java
similarity index 99%
rename from src/test/java/org/mockito/internal/util/PrimitivesTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/PrimitivesTest.java
index b42bde8b07..214a7ec568 100644
--- a/src/test/java/org/mockito/internal/util/PrimitivesTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/PrimitivesTest.java
@@ -10,7 +10,6 @@
 
 import org.junit.Test;
 
-
 public class PrimitivesTest {
     @Test
     public void should_not_return_null_for_primitives_wrappers() throws Exception {
diff --git a/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java b/mockito-core/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
similarity index 85%
rename from src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
rename to mockito-core/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
index 2d6edae6fe..2c735fb3a0 100644
--- a/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
@@ -29,7 +29,8 @@ public SimpleMockitoLogger clear() {
 
     public void assertEmpty() {
         if (loggedInfo.length() != 0) {
-            throw new AssertionError("Expected the logger to be empty but it has:\n" + loggedInfo.toString());
+            throw new AssertionError(
+                    "Expected the logger to be empty but it has:\n" + loggedInfo.toString());
         }
     }
 }
diff --git a/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java b/mockito-core/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
similarity index 91%
rename from src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
index 03b024aa94..a12d4daef9 100644
--- a/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
@@ -13,11 +13,11 @@ public class SimpleMockitoLoggerTest extends TestBase {
 
     @Test
     public void shouldLog() throws Exception {
-        //given
+        // given
         SimpleMockitoLogger logger = new SimpleMockitoLogger();
-        //when
+        // when
         logger.log("foo");
-        //then
+        // then
         assertEquals("foo", logger.getLoggedInfo());
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/StringUtilTest.java b/mockito-core/src/test/java/org/mockito/internal/util/StringUtilTest.java
new file mode 100644
index 0000000000..526d399264
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/StringUtilTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class StringUtilTest {
+
+    @Test
+    public void decamelizes_matcher_name() throws Exception {
+        assertEquals(
+                "<Sentence with strong language>",
+                StringUtil.decamelizeMatcherName("SentenceWithStrongLanguage"));
+        assertEquals("<W e i r d o 1>", StringUtil.decamelizeMatcherName("WEIRDO1"));
+        assertEquals("<_>", StringUtil.decamelizeMatcherName("_"));
+        assertEquals(
+                "<Has exactly 3 elements>",
+                StringUtil.decamelizeMatcherName("HasExactly3Elements"));
+        assertEquals("<custom argument matcher>", StringUtil.decamelizeMatcherName(""));
+    }
+
+    @Test
+    public void joins_empty_list() throws Exception {
+        assertThat(StringUtil.join()).isEmpty();
+        assertThat(StringUtil.join("foo", emptyList())).isEmpty();
+    }
+
+    @Test
+    public void joins_single_line() throws Exception {
+        assertThat(StringUtil.join("line1")).hasLineCount(2);
+    }
+
+    @Test
+    public void joins_two_lines() throws Exception {
+        assertThat(StringUtil.join("line1", "line2")).hasLineCount(3);
+    }
+
+    @Test
+    public void join_has_preceding_linebreak() throws Exception {
+        assertThat(StringUtil.join("line1")).isEqualTo("\nline1");
+    }
+
+    @Test
+    public void removes_first_line() throws Exception {
+        assertThat(StringUtil.removeFirstLine("line1\nline2")).isEqualTo("line2");
+    }
+
+    @Test
+    public void joins_with_line_prefix() throws Exception {
+        assertEquals(
+                "Hey!\n" + " - a\n" + " - b", StringUtil.join("Hey!\n", " - ", asList("a", "b")));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/TimerTest.java b/mockito-core/src/test/java/org/mockito/internal/util/TimerTest.java
new file mode 100644
index 0000000000..b0da7cdae0
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/TimerTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.misusing.FriendlyReminderException;
+import org.mockitoutil.TestBase;
+
+public class TimerTest extends TestBase {
+
+    @Test
+    public void should_return_true_if_task_is_in_acceptable_time_bounds() {
+        // given
+        long duration = 10000L;
+        Timer timer = new Timer(duration);
+
+        // when
+        timer.start();
+
+        // then
+        Assertions.assertThat(timer.isCounting()).isTrue();
+    }
+
+    @Test
+    public void should_return_false_when_time_run_out() throws Exception {
+        // given
+        Timer timer = new Timer(0);
+        timer.start();
+
+        // when
+        oneMillisecondPasses();
+
+        // then
+        Assertions.assertThat(timer.isCounting()).isFalse();
+    }
+
+    @Test
+    public void should_throw_friendly_reminder_exception_when_duration_is_negative() {
+        assertThatThrownBy(
+                        () -> {
+                            new Timer(-1);
+                        })
+                .isInstanceOf(FriendlyReminderException.class)
+                .hasMessageContaining("Don't panic! I'm just a friendly reminder!");
+    }
+
+    private void oneMillisecondPasses() throws InterruptedException {
+        Thread.sleep(1);
+    }
+}
diff --git a/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java b/mockito-core/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
similarity index 83%
rename from src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
index 031a654dd1..0012a59cb4 100644
--- a/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
@@ -5,6 +5,7 @@
 package org.mockito.internal.util.collections;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
 
 import java.util.HashSet;
@@ -21,10 +22,8 @@
 
 public class HashCodeAndEqualsSafeSetTest {
 
-    @Rule
-    public MockitoRule r = MockitoJUnit.rule();
-    @Mock
-    private UnmockableHashCodeAndEquals mock1;
+    @Rule public MockitoRule r = MockitoJUnit.rule();
+    @Mock private UnmockableHashCodeAndEquals mock1;
 
     @Test
     public void can_add_mock_that_have_failing_hashCode_method() throws Exception {
@@ -57,12 +56,9 @@ public void can_remove() throws Exception {
         assertThat(mocks.isEmpty()).isTrue();
     }
 
-
     @Test
     public void can_add_a_collection() throws Exception {
-        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
-                mock1,
-                mock(Observer.class));
+        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
 
         HashCodeAndEqualsSafeSet workingSet = new HashCodeAndEqualsSafeSet();
 
@@ -73,9 +69,7 @@ public void can_add_a_collection() throws Exception {
 
     @Test
     public void can_retain_a_collection() throws Exception {
-        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
-                mock1,
-                mock(Observer.class));
+        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
 
         HashCodeAndEqualsSafeSet workingSet = new HashCodeAndEqualsSafeSet();
 
@@ -88,9 +82,7 @@ public void can_retain_a_collection() throws Exception {
 
     @Test
     public void can_remove_a_collection() throws Exception {
-        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
-                mock1,
-                mock(Observer.class));
+        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
 
         HashCodeAndEqualsSafeSet workingSet = new HashCodeAndEqualsSafeSet();
 
@@ -103,9 +95,7 @@ public void can_remove_a_collection() throws Exception {
 
     @Test
     public void can_iterate() throws Exception {
-        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
-                mock1,
-                mock(Observer.class));
+        HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
 
         LinkedList<Object> accumulator = new LinkedList<Object>();
         for (Object mock : mocks) {
@@ -123,13 +113,17 @@ public void toArray_just_work() throws Exception {
         assertThat(mocks.toArray(new UnmockableHashCodeAndEquals[0])[0]).isSameAs(mock1);
     }
 
-    @Test(expected=CloneNotSupportedException.class)
-    public void cloneIsNotSupported() throws CloneNotSupportedException{
-        HashCodeAndEqualsSafeSet.of().clone();
+    @Test
+    public void cloneIsNotSupported() {
+        assertThatThrownBy(
+                        () -> {
+                            HashCodeAndEqualsSafeSet.of().clone();
+                        })
+                .isInstanceOf(CloneNotSupportedException.class);
     }
 
     @Test
-    public void isEmptyAfterClear() throws Exception {
+    public void isEmptyAfterClear() {
         HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
         set.clear();
 
@@ -137,26 +131,26 @@ public void isEmptyAfterClear() throws Exception {
     }
 
     @Test
-    public void isEqualToItself(){
+    public void isEqualToItself() {
         HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
         assertThat(set).isEqualTo(set);
     }
 
     @Test
-    public void isNotEqualToAnOtherTypeOfSetWithSameContent(){
+    public void isNotEqualToAnOtherTypeOfSetWithSameContent() {
         HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of();
         assertThat(set).isNotEqualTo(new HashSet<Object>());
     }
 
     @Test
-    public void isNotEqualWhenContentIsDifferent(){
+    public void isNotEqualWhenContentIsDifferent() {
 
         HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
         assertThat(set).isNotEqualTo(HashCodeAndEqualsSafeSet.of());
     }
 
     @Test
-    public void hashCodeIsEqualIfContentIsEqual(){
+    public void hashCodeIsEqualIfContentIsEqual() {
         HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
         assertThat(set.hashCode()).isEqualTo(HashCodeAndEqualsSafeSet.of(mock1).hashCode());
     }
@@ -178,11 +172,13 @@ public void removeByIterator() throws Exception {
     }
 
     private static class UnmockableHashCodeAndEquals {
-        @Override public final int hashCode() {
+        @Override
+        public final int hashCode() {
             throw new NullPointerException("I'm failing on hashCode and I don't care");
         }
 
-        @Override public final boolean equals(Object obj) {
+        @Override
+        public final boolean equals(Object obj) {
             throw new NullPointerException("I'm failing on equals and I don't care");
         }
     }
diff --git a/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java b/mockito-core/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
similarity index 88%
rename from src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
index 462a6fc4d5..1a44ba6ee8 100644
--- a/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
@@ -8,22 +8,22 @@
 
 import org.junit.Test;
 
-
 public class IdentitySetTest {
 
     IdentitySet set = new IdentitySet();
 
     @Test
     public void shouldWork() throws Exception {
-        //when
+        // when
         Object o = new Object();
         set.add(o);
 
-        //then
+        // then
         assertTrue(set.contains(o));
         assertFalse(set.contains(new Object()));
     }
 
+    @SuppressWarnings("EqualsHashCode")
     class Fake {
         @Override
         public boolean equals(Object obj) {
@@ -33,16 +33,15 @@ public boolean equals(Object obj) {
 
     @Test
     public void shouldWorkEvenIfEqualsTheSame() throws Exception {
-        //given
+        // given
         assertEquals(new Fake(), new Fake());
         Fake fake = new Fake();
 
-        //when
+        // when
         set.add(fake);
 
-        //then
+        // then
         assertTrue(set.contains(fake));
         assertFalse(set.contains(new Fake()));
     }
-
 }
diff --git a/src/test/java/org/mockito/internal/util/io/IOUtilTest.java b/mockito-core/src/test/java/org/mockito/internal/util/io/IOUtilTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/util/io/IOUtilTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/io/IOUtilTest.java
diff --git a/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
similarity index 95%
rename from src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
index 1bdd7de107..66d25c2171 100644
--- a/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
@@ -14,7 +14,6 @@
 import org.assertj.core.api.Assertions;
 import org.junit.Test;
 
-
 public class BeanPropertySetterTest {
 
     @Test
@@ -34,7 +33,8 @@ public void use_the_correct_setter_on_the_target() throws Exception {
     }
 
     @Test
-    public void use_the_setter_on_the_target_when_field_name_begins_by_at_least_2_caps() throws Exception {
+    public void use_the_setter_on_the_target_when_field_name_begins_by_at_least_2_caps()
+            throws Exception {
         // given
         BeanWithWeirdFields someBean = new BeanWithWeirdFields();
         Field theField = someBean.getClass().getDeclaredField("UUID");
@@ -50,7 +50,8 @@ public void use_the_setter_on_the_target_when_field_name_begins_by_at_least_2_ca
     }
 
     @Test
-    public void should_not_fail_if_bean_class_declares_only_the_setter_for_the_property() throws Exception {
+    public void should_not_fail_if_bean_class_declares_only_the_setter_for_the_property()
+            throws Exception {
         // given
         SomeBeanWithJustASetter someBean = new SomeBeanWithJustASetter();
         Field theField = someBean.getClass().getDeclaredField("theField");
@@ -65,7 +66,8 @@ public void should_not_fail_if_bean_class_declares_only_the_setter_for_the_prope
     }
 
     @Test
-    public void should_fail_if_matching_setter_cannot_be_found_and_if_report_failure_is_true() throws Exception {
+    public void should_fail_if_matching_setter_cannot_be_found_and_if_report_failure_is_true()
+            throws Exception {
         // given
         SomeBeanWithNoSetterMatchingFieldType bean = new SomeBeanWithNoSetterMatchingFieldType();
         Field theField = bean.getClass().getDeclaredField("theField");
@@ -96,7 +98,8 @@ public void return_false_if_no_setter_was_found() throws Exception {
     }
 
     @Test
-    public void return_false_if_no_setter_was_found_and_if_reportNoSetterFound_is_false() throws Exception {
+    public void return_false_if_no_setter_was_found_and_if_reportNoSetterFound_is_false()
+            throws Exception {
         // given
         SomeBeanWithNoSetterMatchingFieldType bean = new SomeBeanWithNoSetterMatchingFieldType();
         Field theField = bean.getClass().getDeclaredField("theField");
@@ -132,6 +135,7 @@ public void setTheField(final File theField) {
             this.theField = theField;
         }
     }
+
     static class SomeBeanWithJustAGetter {
         private File theField;
 
@@ -158,5 +162,4 @@ public void setUUID(UUID UUID) {
             this.UUID = UUID;
         }
     }
-
 }
diff --git a/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
similarity index 97%
rename from src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
rename to mockito-core/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
index 17d71ad3fa..51cb5f938b 100644
--- a/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
@@ -4,6 +4,4 @@
  */
 package org.mockito.internal.util.reflection;
 
-public class DummyClassForTests extends DummyParentClassForTests {
-
-}
+public class DummyClassForTests extends DummyParentClassForTests {}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
new file mode 100644
index 0000000000..a701dc96e7
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+public class DummyParentClassForTests {
+
+    @SuppressWarnings("unused") // I know, I know. We're doing nasty reflection hacks here...
+    private String somePrivateField;
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
new file mode 100644
index 0000000000..3c9e489814
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
+
+public class FieldInitializerTest {
+
+    private StaticClass alreadyInstantiated = new StaticClass();
+    private StaticClass noConstructor;
+    private StaticClassWithDefaultConstructor defaultConstructor;
+    private StaticClassWithPrivateDefaultConstructor privateDefaultConstructor;
+    private StaticClassWithoutDefaultConstructor noDefaultConstructor;
+    private StaticClassThrowingExceptionDefaultConstructor throwingExDefaultConstructor;
+    private AbstractStaticClass abstractType;
+    private Interface interfaceType;
+    private InnerClassType innerClassType;
+    private AbstractStaticClass instantiatedAbstractType = new ConcreteStaticClass();
+    private Interface instantiatedInterfaceType = new ConcreteStaticClass();
+    private InnerClassType instantiatedInnerClassType = new InnerClassType();
+
+    @Test
+    public void should_keep_same_instance_if_field_initialized() throws Exception {
+        final StaticClass backupInstance = alreadyInstantiated;
+        FieldInitializer fieldInitializer =
+                new FieldInitializer(this, field("alreadyInstantiated"));
+        FieldInitializationReport report = fieldInitializer.initialize();
+
+        assertSame(backupInstance, report.fieldInstance());
+        assertFalse(report.fieldWasInitialized());
+        assertFalse(report.fieldWasInitializedUsingContructorArgs());
+    }
+
+    @Test
+    public void should_instantiate_field_when_type_has_no_constructor() throws Exception {
+        FieldInitializer fieldInitializer = new FieldInitializer(this, field("noConstructor"));
+        FieldInitializationReport report = fieldInitializer.initialize();
+
+        assertNotNull(report.fieldInstance());
+        assertTrue(report.fieldWasInitialized());
+        assertFalse(report.fieldWasInitializedUsingContructorArgs());
+    }
+
+    @Test
+    public void should_instantiate_field_with_default_constructor() throws Exception {
+        FieldInitializer fieldInitializer = new FieldInitializer(this, field("defaultConstructor"));
+        FieldInitializationReport report = fieldInitializer.initialize();
+
+        assertNotNull(report.fieldInstance());
+        assertTrue(report.fieldWasInitialized());
+        assertFalse(report.fieldWasInitializedUsingContructorArgs());
+    }
+
+    @Test
+    public void should_instantiate_field_with_private_default_constructor() throws Exception {
+        FieldInitializer fieldInitializer =
+                new FieldInitializer(this, field("privateDefaultConstructor"));
+        FieldInitializationReport report = fieldInitializer.initialize();
+
+        assertNotNull(report.fieldInstance());
+        assertTrue(report.fieldWasInitialized());
+        assertFalse(report.fieldWasInitializedUsingContructorArgs());
+    }
+
+    @Test
+    public void should_fail_to_instantiate_field_if_no_default_constructor() throws Exception {
+        FieldInitializer fieldInitializer =
+                new FieldInitializer(this, field("noDefaultConstructor"));
+
+        assertThatThrownBy(
+                        () -> {
+                            fieldInitializer.initialize();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage(
+                        "the type 'StaticClassWithoutDefaultConstructor' has no default constructor");
+    }
+
+    @Test
+    public void should_fail_to_instantiate_field_if_default_constructor_throws_exception()
+            throws Exception {
+        FieldInitializer fieldInitializer =
+                new FieldInitializer(this, field("throwingExDefaultConstructor"));
+        try {
+            fieldInitializer.initialize();
+            fail();
+        } catch (MockitoException e) {
+            InvocationTargetException ite = (InvocationTargetException) e.getCause();
+            assertTrue(ite.getTargetException() instanceof NullPointerException);
+            assertEquals("business logic failed", ite.getTargetException().getMessage());
+        }
+    }
+
+    @Test
+    public void should_fail_for_abstract_field() {
+        assertThatThrownBy(
+                        () -> {
+                            new FieldInitializer(this, field("abstractType"));
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage("the type 'AbstractStaticClass' is an abstract class.");
+    }
+
+    @Test
+    public void should_not_fail_if_abstract_field_is_instantiated() throws Exception {
+        new FieldInitializer(this, field("instantiatedAbstractType"));
+    }
+
+    @Test
+    public void should_fail_for_interface_field() {
+        assertThatThrownBy(
+                        () -> {
+                            new FieldInitializer(this, field("interfaceType"));
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage("the type 'Interface' is an interface.");
+    }
+
+    @Test
+    public void should_not_fail_if_interface_field_is_instantiated() throws Exception {
+        new FieldInitializer(this, field("instantiatedInterfaceType"));
+    }
+
+    @Test
+    public void should_fail_for_local_type_field() {
+        // given
+        class LocalType {}
+
+        class TheTestWithLocalType {
+            @InjectMocks LocalType field;
+        }
+
+        TheTestWithLocalType testWithLocalType = new TheTestWithLocalType();
+
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            new FieldInitializer(
+                                    testWithLocalType,
+                                    testWithLocalType.getClass().getDeclaredField("field"));
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage("the type 'LocalType' is a local class.");
+    }
+
+    @Test
+    public void should_not_fail_if_local_type_field_is_instantiated() throws Exception {
+        // when
+        class LocalType {}
+
+        class TheTestWithLocalType {
+            @InjectMocks LocalType field = new LocalType();
+        }
+
+        TheTestWithLocalType testWithLocalType = new TheTestWithLocalType();
+
+        // when
+        new FieldInitializer(
+                testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
+    }
+
+    @Test
+    public void should_fail_for_inner_class_field() {
+        assertThatThrownBy(
+                        () -> {
+                            new FieldInitializer(this, field("innerClassType"));
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage("the type 'InnerClassType' is an inner non static class.");
+    }
+
+    @Test
+    public void should_not_fail_if_inner_class_field_is_instantiated() throws Exception {
+        new FieldInitializer(this, field("instantiatedInnerClassType"));
+    }
+
+    @Test
+    public void can_instantiate_class_with_parameterized_constructor() throws Exception {
+        ConstructorArgumentResolver resolver =
+                given(
+                                mock(ConstructorArgumentResolver.class)
+                                        .resolveTypeInstances(any(Class.class)))
+                        .willReturn(new Object[] {null})
+                        .getMock();
+
+        new FieldInitializer(this, field("noDefaultConstructor"), resolver).initialize();
+
+        assertNotNull(noDefaultConstructor);
+    }
+
+    private Field field(String fieldName) throws NoSuchFieldException {
+        return this.getClass().getDeclaredField(fieldName);
+    }
+
+    static class StaticClass {}
+
+    static class StaticClassWithDefaultConstructor {
+        StaticClassWithDefaultConstructor() {}
+    }
+
+    static class StaticClassWithPrivateDefaultConstructor {
+        private StaticClassWithPrivateDefaultConstructor() {}
+    }
+
+    static class StaticClassWithoutDefaultConstructor {
+        private StaticClassWithoutDefaultConstructor(String param) {}
+    }
+
+    static class StaticClassThrowingExceptionDefaultConstructor {
+        StaticClassThrowingExceptionDefaultConstructor() {
+            throw new NullPointerException("business logic failed");
+        }
+    }
+
+    abstract static class AbstractStaticClass {
+        public AbstractStaticClass() {}
+    }
+
+    interface Interface {}
+
+    static class ConcreteStaticClass extends AbstractStaticClass implements Interface {}
+
+    class InnerClassType {
+        InnerClassType() {}
+    }
+}
diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
similarity index 93%
rename from src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
index 2eae0c34e9..2e9aeb82d6 100644
--- a/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
@@ -20,17 +20,17 @@ class Foo {
 
     @Test
     public void shouldKnowWhenNull() throws Exception {
-        //when
+        // when
         FieldReader reader = new FieldReader(new Foo(), Foo.class.getDeclaredField("isNull"));
-        //then
+        // then
         assertTrue(reader.isNull());
     }
 
     @Test
     public void shouldKnowWhenNotNull() throws Exception {
-        //when
+        // when
         FieldReader reader = new FieldReader(new Foo(), Foo.class.getDeclaredField("notNull"));
-        //then
+        // then
         assertFalse(reader.isNull());
     }
 }
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
similarity index 98%
rename from src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
index 42c15f3289..d5a7459be6 100644
--- a/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
@@ -16,7 +16,7 @@ public class GenericArrayReturnTypeTest {
     @Test
     public void toArrayTypedDoesNotWork() throws Exception {
         Container container = mock(Container.class, Answers.RETURNS_DEEP_STUBS);
-        container.getInnerContainer().getTheProblem().toArray(new String[]{});
+        container.getInnerContainer().getTheProblem().toArray(new String[] {});
     }
 
     class Container {
@@ -36,5 +36,4 @@ public Set<String> getTheProblem() {
             return theProblem;
         }
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
new file mode 100644
index 0000000000..9d742a6608
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import static org.junit.Assert.assertEquals;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Type;
+import java.util.*;
+
+import org.junit.Test;
+
+public class GenericMasterTest {
+
+    GenericMaster m = new GenericMaster();
+
+    List<String> one;
+    Set<Integer> two;
+    Map<Double, String> map;
+    String nonGeneric;
+    List<Set<String>> nested;
+    List<Set<Collection<String>>> multiNested;
+
+    public interface ListSet extends List<Set<?>> {}
+
+    public interface MapNumberString extends Map<Number, String> {}
+
+    public class HashMapNumberString<K extends Number> extends HashMap<K, String> {}
+
+    public List<Number> numberList() {
+        return null;
+    }
+
+    public Comparable<Number> numberComparable() {
+        return null;
+    }
+
+    @SuppressWarnings("rawtypes")
+    public List rawList() {
+        return null;
+    }
+
+    public List<? extends Type> typeList() {
+        return null;
+    }
+
+    @Test
+    public void should_find_generic_class() throws Exception {
+        assertEquals(String.class, m.getGenericType(field("one")));
+        assertEquals(Integer.class, m.getGenericType(field("two")));
+        assertEquals(Double.class, m.getGenericType(field("map")));
+    }
+
+    @Test
+    public void should_get_object_for_non_generic() throws Exception {
+        assertEquals(Object.class, m.getGenericType(field("nonGeneric")));
+    }
+
+    @Test
+    public void should_deal_with_nested_generics() throws Exception {
+        assertEquals(Set.class, m.getGenericType(field("nested")));
+        assertEquals(Set.class, m.getGenericType(field("multiNested")));
+    }
+
+    @Test
+    public void should_detect_generics() throws NoSuchMethodException {
+        // Given
+        Method method = ClassWithParameter.class.getMethod("process", List.class);
+        Parameter parameter = method.getParameters()[0];
+
+        // When
+        Class<?> genericType = m.getGenericType(parameter);
+
+        // Then
+        assertEquals(Integer.class, genericType);
+    }
+
+    private Field field(String fieldName) throws SecurityException, NoSuchFieldException {
+        return this.getClass().getDeclaredField(fieldName);
+    }
+
+    private static class ClassWithParameter {
+        public void process(List<Integer> integers) {}
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
new file mode 100644
index 0000000000..cb1d73ab49
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
@@ -0,0 +1,463 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.internal.util.reflection.GenericMetadataSupport.inferFrom;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Test;
+
+public class GenericMetadataSupportTest {
+
+    interface GenericsSelfReference<T extends GenericsSelfReference<T>> {
+        T self();
+    }
+
+    interface UpperBoundedTypeWithClass<E extends Number & Comparable<E>> {
+        E get();
+    }
+
+    interface UpperBoundedTypeWithInterfaces<E extends Comparable<E> & Cloneable> {
+        E get();
+    }
+
+    interface ListOfNumbers extends List<Number> {}
+
+    interface AnotherListOfNumbers extends ListOfNumbers {}
+
+    abstract class ListOfNumbersImpl implements ListOfNumbers {}
+
+    abstract class AnotherListOfNumbersImpl extends ListOfNumbersImpl {}
+
+    interface ListOfAnyNumbers<N extends Number & Cloneable> extends List<N> {}
+
+    interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {
+        Set<Number> remove(Object key); // override with fixed ParameterizedType
+
+        List<? super Integer> returning_wildcard_with_class_lower_bound();
+
+        List<? super K> returning_wildcard_with_typeVar_lower_bound();
+
+        List<? extends K> returning_wildcard_with_typeVar_upper_bound();
+
+        K returningK();
+
+        <O extends K> List<O> paramType_with_type_params();
+
+        <S, T extends S> T two_type_params();
+
+        <O extends K> O typeVar_with_type_params();
+    }
+
+    static class StringList extends ArrayList<String> {}
+
+    public interface TopInterface<T> {
+        T generic();
+    }
+
+    public interface MiddleInterface<T> extends TopInterface<T> {}
+
+    public class OwningClassWithDeclaredUpperBounds<
+            T extends List<String> & Comparable<String> & Cloneable> {
+        public abstract class AbstractInner implements MiddleInterface<T> {}
+    }
+
+    public class OwningClassWithNoDeclaredUpperBounds<T> {
+        public abstract class AbstractInner implements MiddleInterface<T> {}
+    }
+
+    @Test
+    public void typeVariable_of_self_type() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsSelfReference.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod("self", GenericsSelfReference.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(GenericsSelfReference.class);
+    }
+
+    @Test
+    public void can_get_raw_type_from_Class() {
+        assertThat(inferFrom(ListOfAnyNumbers.class).rawType()).isEqualTo(ListOfAnyNumbers.class);
+        assertThat(inferFrom(ListOfNumbers.class).rawType()).isEqualTo(ListOfNumbers.class);
+        assertThat(inferFrom(GenericsNest.class).rawType()).isEqualTo(GenericsNest.class);
+        assertThat(inferFrom(StringList.class).rawType()).isEqualTo(StringList.class);
+    }
+
+    @Test
+    public void can_get_raw_type_from_ParameterizedType() {
+        assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).rawType())
+                .isEqualTo(List.class);
+        assertThat(inferFrom(ListOfNumbers.class.getGenericInterfaces()[0]).rawType())
+                .isEqualTo(List.class);
+        assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).rawType())
+                .isEqualTo(Map.class);
+        assertThat(inferFrom(StringList.class.getGenericSuperclass()).rawType())
+                .isEqualTo(ArrayList.class);
+    }
+
+    @Test
+    public void can_get_type_variables_from_Class() {
+        assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet())
+                .hasSize(1)
+                .extracting(TypeVariable::getName)
+                .contains("K");
+        assertThat(inferFrom(ListOfNumbers.class).actualTypeArguments().keySet()).isEmpty();
+        assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet())
+                .hasSize(1)
+                .extracting(TypeVariable::getName)
+                .contains("N");
+        assertThat(inferFrom(Map.class).actualTypeArguments().keySet())
+                .hasSize(2)
+                .extracting(TypeVariable::getName)
+                .contains("K", "V");
+        assertThat(inferFrom(Serializable.class).actualTypeArguments().keySet()).isEmpty();
+        assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
+    }
+
+    @Test
+    public void can_resolve_type_variables_from_ancestors() throws Exception {
+        Method listGet = List.class.getMethod("get", int.class);
+        assertThat(
+                        inferFrom(AnotherListOfNumbers.class)
+                                .resolveGenericReturnType(listGet)
+                                .rawType())
+                .isEqualTo(Number.class);
+        assertThat(
+                        inferFrom(AnotherListOfNumbersImpl.class)
+                                .resolveGenericReturnType(listGet)
+                                .rawType())
+                .isEqualTo(Number.class);
+    }
+
+    @Test
+    public void can_get_type_variables_from_ParameterizedType() {
+        assertThat(
+                        inferFrom(GenericsNest.class.getGenericInterfaces()[0])
+                                .actualTypeArguments()
+                                .keySet())
+                .hasSize(2)
+                .extracting(TypeVariable::getName)
+                .contains("K", "V");
+        assertThat(
+                        inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0])
+                                .actualTypeArguments()
+                                .keySet())
+                .hasSize(1)
+                .extracting(TypeVariable::getName)
+                .contains("E");
+        assertThat(
+                        inferFrom(Integer.class.getGenericInterfaces()[0])
+                                .actualTypeArguments()
+                                .keySet())
+                .hasSize(1)
+                .extracting(TypeVariable::getName)
+                .contains("T");
+        assertThat(
+                        inferFrom(StringBuilder.class.getGenericInterfaces()[0])
+                                .actualTypeArguments()
+                                .keySet())
+                .isEmpty();
+        assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
+    }
+
+    @Test
+    public void
+            typeVariable_return_type_of____iterator____resolved_to_Iterator_and_type_argument_to_String() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(StringList.class)
+                        .resolveGenericReturnType(firstNamedMethod("iterator", StringList.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(Iterator.class);
+        assertThat(genericMetadata.actualTypeArguments().values()).contains(String.class);
+    }
+
+    @Test
+    public void
+            typeVariable_return_type_of____get____resolved_to_Set_and_type_argument_to_Number() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(firstNamedMethod("get", GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(Set.class);
+        assertThat(genericMetadata.actualTypeArguments().values()).contains(Number.class);
+    }
+
+    @Test
+    public void
+            bounded_typeVariable_return_type_of____returningK____resolved_to_Comparable_and_with_BoundedType() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod("returningK", GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(Comparable.class);
+        GenericMetadataSupport extraInterface_0 =
+                inferFrom(genericMetadata.extraInterfaces().get(0));
+        assertThat(extraInterface_0.rawType()).isEqualTo(Cloneable.class);
+    }
+
+    @Test
+    public void
+            fixed_ParamType_return_type_of____remove____resolved_to_Set_and_type_argument_to_Number() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(firstNamedMethod("remove", GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(Set.class);
+        assertThat(genericMetadata.actualTypeArguments().values()).contains(Number.class);
+    }
+
+    @Test
+    public void
+            paramType_return_type_of____values____resolved_to_Collection_and_type_argument_to_Parameterized_Set() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(firstNamedMethod("values", GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(Collection.class);
+        GenericMetadataSupport fromTypeVariableE =
+                inferFrom(typeVariableValue(genericMetadata.actualTypeArguments(), "E"));
+        assertThat(fromTypeVariableE.rawType()).isEqualTo(Set.class);
+        assertThat(fromTypeVariableE.actualTypeArguments().values()).contains(Number.class);
+    }
+
+    @Test
+    public void
+            paramType_with_type_parameters_return_type_of____paramType_with_type_params____resolved_to_Collection_and_type_argument_to_Parameterized_Set() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod("paramType_with_type_params", GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
+        Type firstBoundOfE =
+                ((GenericMetadataSupport.TypeVarBoundedType)
+                                typeVariableValue(genericMetadata.actualTypeArguments(), "E"))
+                        .firstBound();
+        assertThat(inferFrom(firstBoundOfE).rawType()).isEqualTo(Comparable.class);
+    }
+
+    @Test
+    public void
+            typeVariable_with_type_parameters_return_type_of____typeVar_with_type_params____resolved_K_hence_to_Comparable_and_with_BoundedType() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod("typeVar_with_type_params", GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(Comparable.class);
+        GenericMetadataSupport extraInterface_0 =
+                inferFrom(genericMetadata.extraInterfaces().get(0));
+        assertThat(extraInterface_0.rawType()).isEqualTo(Cloneable.class);
+    }
+
+    @Test
+    public void class_return_type_of____append____resolved_to_StringBuilder_and_type_arguments() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(StringBuilder.class)
+                        .resolveGenericReturnType(firstNamedMethod("append", StringBuilder.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(StringBuilder.class);
+        assertThat(genericMetadata.actualTypeArguments()).isEmpty();
+    }
+
+    @Test
+    public void
+            paramType_with_wildcard_return_type_of____returning_wildcard_with_class_lower_bound____resolved_to_List_and_type_argument_to_Integer() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod(
+                                        "returning_wildcard_with_class_lower_bound",
+                                        GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
+        GenericMetadataSupport.BoundedType boundedType =
+                (GenericMetadataSupport.BoundedType)
+                        typeVariableValue(genericMetadata.actualTypeArguments(), "E");
+        assertThat(boundedType.firstBound()).isEqualTo(Integer.class);
+        assertThat(boundedType.interfaceBounds()).isEmpty();
+    }
+
+    @Test
+    public void
+            paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_lower_bound____resolved_to_List_and_type_argument_to_Integer() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod(
+                                        "returning_wildcard_with_typeVar_lower_bound",
+                                        GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
+        GenericMetadataSupport.BoundedType boundedType =
+                (GenericMetadataSupport.BoundedType)
+                        typeVariableValue(genericMetadata.actualTypeArguments(), "E");
+
+        assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
+        assertThat(boundedType.interfaceBounds()).contains(Cloneable.class);
+    }
+
+    @Test
+    public void
+            paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_upper_bound____resolved_to_List_and_type_argument_to_Integer() {
+        GenericMetadataSupport genericMetadata =
+                inferFrom(GenericsNest.class)
+                        .resolveGenericReturnType(
+                                firstNamedMethod(
+                                        "returning_wildcard_with_typeVar_upper_bound",
+                                        GenericsNest.class));
+
+        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
+        GenericMetadataSupport.BoundedType boundedType =
+                (GenericMetadataSupport.BoundedType)
+                        typeVariableValue(genericMetadata.actualTypeArguments(), "E");
+
+        assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
+        assertThat(boundedType.interfaceBounds()).contains(Cloneable.class);
+    }
+
+    @Test
+    public void can_extract_raw_type_from_bounds_on_terminal_typeVariable() {
+        assertThat(
+                        inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
+                                .resolveGenericReturnType(
+                                        firstNamedMethod(
+                                                "generic",
+                                                OwningClassWithDeclaredUpperBounds.AbstractInner
+                                                        .class))
+                                .rawType())
+                .isEqualTo(List.class);
+        assertThat(
+                        inferFrom(OwningClassWithNoDeclaredUpperBounds.AbstractInner.class)
+                                .resolveGenericReturnType(
+                                        firstNamedMethod(
+                                                "generic",
+                                                OwningClassWithNoDeclaredUpperBounds.AbstractInner
+                                                        .class))
+                                .rawType())
+                .isEqualTo(Object.class);
+    }
+
+    @Test
+    public void can_extract_interface_type_from_bounds_on_terminal_typeVariable() {
+
+        assertThat(
+                        inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
+                                .resolveGenericReturnType(
+                                        firstNamedMethod(
+                                                "generic",
+                                                OwningClassWithDeclaredUpperBounds.AbstractInner
+                                                        .class))
+                                .rawExtraInterfaces())
+                .containsExactly(Comparable.class, Cloneable.class);
+        assertThat(
+                        inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
+                                .resolveGenericReturnType(
+                                        firstNamedMethod(
+                                                "generic",
+                                                OwningClassWithDeclaredUpperBounds.AbstractInner
+                                                        .class))
+                                .extraInterfaces())
+                .containsExactly(
+                        parameterizedTypeOf(Comparable.class, null, String.class), Cloneable.class);
+
+        assertThat(
+                        inferFrom(OwningClassWithNoDeclaredUpperBounds.AbstractInner.class)
+                                .resolveGenericReturnType(
+                                        firstNamedMethod(
+                                                "generic",
+                                                OwningClassWithNoDeclaredUpperBounds.AbstractInner
+                                                        .class))
+                                .extraInterfaces())
+                .isEmpty();
+    }
+
+    private ParameterizedType parameterizedTypeOf(
+            final Class<?> rawType, final Class<?> ownerType, final Type... actualTypeArguments) {
+        return new ParameterizedType() {
+            @Override
+            public Type[] getActualTypeArguments() {
+                return actualTypeArguments;
+            }
+
+            @Override
+            public Type getRawType() {
+                return rawType;
+            }
+
+            @Override
+            public Type getOwnerType() {
+                return ownerType;
+            }
+
+            @SuppressWarnings("EqualsHashCode")
+            public boolean equals(Object other) {
+                if (other instanceof ParameterizedType) {
+                    ParameterizedType otherParamType = (ParameterizedType) other;
+                    if (this == otherParamType) {
+                        return true;
+                    } else {
+                        return equals(ownerType, otherParamType.getOwnerType())
+                                && equals(rawType, otherParamType.getRawType())
+                                && Arrays.equals(
+                                        actualTypeArguments,
+                                        otherParamType.getActualTypeArguments());
+                    }
+                } else {
+                    return false;
+                }
+            }
+
+            private boolean equals(Object a, Object b) {
+                return (a == b) || (a != null && a.equals(b));
+            }
+        };
+    }
+
+    private Type typeVariableValue(
+            Map<TypeVariable<?>, Type> typeVariables, String typeVariableName) {
+        for (Map.Entry<TypeVariable<?>, Type> typeVariableTypeEntry : typeVariables.entrySet()) {
+            if (typeVariableTypeEntry.getKey().getName().equals(typeVariableName)) {
+                return typeVariableTypeEntry.getValue();
+            }
+        }
+
+        fail("'" + typeVariableName + "' was not found in " + typeVariables);
+        return null; // unreachable
+    }
+
+    private Method firstNamedMethod(String methodName, Class<?> clazz) {
+        for (Method method : clazz.getMethods()) {
+            boolean protect_against_different_jdk_ordering_avoiding_bridge_methods =
+                    !method.isBridge();
+            if (method.getName().contains(methodName)
+                    && protect_against_different_jdk_ordering_avoiding_bridge_methods) {
+                return method;
+            }
+        }
+        throw new IllegalStateException(
+                "The method : '"
+                        + methodName
+                        + "' do not exist in '"
+                        + clazz.getSimpleName()
+                        + "'");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
new file mode 100644
index 0000000000..94abf86121
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.util.reflection.GenericTypeExtractor.genericTypeOf;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+public class GenericTypeExtractorTest extends TestBase {
+
+    class Base<T> {}
+
+    static class StaticBase<T> {}
+
+    interface IBase<T> {}
+
+    interface StaticIBase<T> {}
+
+    class IntImpl extends Base<Integer> {}
+
+    static class StaticIntImpl extends StaticBase<Integer> {}
+
+    class NestedImpl extends Base<Base<String>> {}
+
+    class NonGeneric extends Base {}
+
+    class IIntImpl implements IBase<Integer> {}
+
+    class INestedImpl implements IBase<IBase<String>> {}
+
+    class INonGeneric implements IBase {}
+
+    class Mixed extends Base<Integer> implements IBase<String> {}
+
+    class Deeper extends IntImpl implements Serializable {}
+
+    class EvenDeeper extends Deeper implements Cloneable {}
+
+    interface Iface extends IBase<Integer> {}
+
+    interface IDeeper extends Serializable, Iface, Cloneable {}
+
+    interface Crazy extends Serializable, IDeeper, Cloneable {}
+
+    class Crazier extends EvenDeeper implements Crazy {}
+
+    class SecondGeneric implements Serializable, IBase<Integer> {}
+
+    @Test
+    public void finds_generic_type() {
+        assertEquals(Integer.class, genericTypeOf(IntImpl.class, Base.class, IBase.class));
+        assertEquals(
+                Integer.class, genericTypeOf(StaticIntImpl.class, StaticBase.class, IBase.class));
+
+        assertEquals(Object.class, genericTypeOf(NestedImpl.class, Base.class, IBase.class));
+        assertEquals(Object.class, genericTypeOf(NonGeneric.class, Base.class, IBase.class));
+        assertEquals(Object.class, genericTypeOf(String.class, Base.class, IBase.class));
+        assertEquals(Object.class, genericTypeOf(String.class, List.class, Map.class));
+
+        assertEquals(
+                String.class,
+                genericTypeOf(new Base<String>() {}.getClass(), Base.class, IBase.class));
+        assertEquals(
+                String.class,
+                genericTypeOf(new IBase<String>() {}.getClass(), Base.class, IBase.class));
+        assertEquals(
+                String.class,
+                genericTypeOf(
+                        new StaticBase<String>() {}.getClass(), StaticBase.class, IBase.class));
+        assertEquals(
+                String.class,
+                genericTypeOf(
+                        new StaticIBase<String>() {}.getClass(), Base.class, StaticIBase.class));
+
+        assertEquals(Integer.class, genericTypeOf(Mixed.class, Base.class, IBase.class));
+        assertEquals(Integer.class, genericTypeOf(IIntImpl.class, Base.class, IBase.class));
+        assertEquals(Object.class, genericTypeOf(INestedImpl.class, Base.class, IBase.class));
+        assertEquals(
+                Object.class, genericTypeOf(INonGeneric.class, IBase.class, INonGeneric.class));
+
+        assertEquals(Integer.class, genericTypeOf(Deeper.class, Base.class, IBase.class));
+        assertEquals(Integer.class, genericTypeOf(EvenDeeper.class, Base.class, IBase.class));
+        assertEquals(Integer.class, genericTypeOf(Iface.class, Base.class, IBase.class));
+        assertEquals(Integer.class, genericTypeOf(IDeeper.class, Base.class, IBase.class));
+        assertEquals(Integer.class, genericTypeOf(Crazy.class, Base.class, IBase.class));
+        assertEquals(Integer.class, genericTypeOf(Crazier.class, Base.class, IBase.class));
+
+        assertEquals(Integer.class, genericTypeOf(SecondGeneric.class, Base.class, IBase.class));
+    }
+}
diff --git a/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
similarity index 82%
rename from src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
rename to mockito-core/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
index c880e04bbc..310218a66f 100644
--- a/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
@@ -6,13 +6,13 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.Field;
 import java.util.LinkedList;
 
 import org.junit.Test;
+import org.mockito.plugins.MemberAccessor;
 import org.mockitoutil.TestBase;
 
 @SuppressWarnings("unchecked")
@@ -29,6 +29,7 @@ public static class SomeObject extends InheritMe {
         @SuppressWarnings("unused")
         // required because static fields needs to be excluded from copying
         private static int staticField = -100;
+
         private int privateField = -100;
         private transient int privateTransientField = -100;
         String defaultField = "-100";
@@ -41,8 +42,7 @@ public SomeObject(int finalField) {
         }
     }
 
-    public static class SomeOtherObject {
-    }
+    public static class SomeOtherObject {}
 
     private SomeObject from = new SomeObject(100);
     private SomeObject to = mock(SomeObject.class);
@@ -113,49 +113,37 @@ public void shouldShallowCopyFieldValuesIntoMock() throws Exception {
 
     @Test
     public void shouldCopyValuesOfInheritedFields() throws Exception {
-        //given
+        // given
         ((InheritMe) from).privateInherited = "foo";
         ((InheritMe) from).protectedInherited = "bar";
 
-        assertThat(((InheritMe) to).privateInherited).isNotEqualTo(((InheritMe) from).privateInherited);
+        assertThat(((InheritMe) to).privateInherited)
+                .isNotEqualTo(((InheritMe) from).privateInherited);
 
-        //when
+        // when
         tool.copyToMock(from, to);
 
-        //then
+        // then
         assertEquals(((InheritMe) from).privateInherited, ((InheritMe) to).privateInherited);
     }
 
-    @Test
-    public void shouldEnableAndThenDisableAccessibility() throws Exception {
-        //given
-        Field privateField = SomeObject.class.getDeclaredField("privateField");
-        assertFalse(privateField.isAccessible());
-
-        //when
-        tool.copyToMock(from, to);
-
-        //then
-        privateField = SomeObject.class.getDeclaredField("privateField");
-        assertFalse(privateField.isAccessible());
-    }
-
     @Test
     public void shouldContinueEvenIfThereAreProblemsCopyingSingleFieldValue() throws Exception {
-        //given
-        tool.fieldCopier = mock(FieldCopier.class);
+        // given
+        tool.accessor = mock(MemberAccessor.class);
 
-        doNothing().
-        doThrow(new IllegalAccessException()).
-        doNothing().
-        when(tool.fieldCopier).
-        copyValue(anyObject(), anyObject(), any(Field.class));
+        doNothing()
+                .doThrow(new IllegalStateException())
+                .doNothing()
+                .when(tool.accessor)
+                .set(any(Field.class), any(), any());
 
-        //when
+        // when
         tool.copyToMock(from, to);
 
-        //then
-        verify(tool.fieldCopier, atLeast(3)).copyValue(any(), any(), any(Field.class));
+        // then
+        verify(tool.accessor, atLeast(3)).get(any(Field.class), any());
+        verify(tool.accessor, atLeast(3)).set(any(Field.class), any(), any());
     }
 
     @Test
@@ -180,6 +168,5 @@ public void shouldBeAbleToCopyFromRealObjectToRealObject() throws Exception {
         assertEquals(from.privateTransientField, to.privateTransientField);
         assertEquals(from.protectedField, to.protectedField);
         assertEquals(from.protectedInherited, to.protectedInherited);
-
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/MemberAccessorTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/MemberAccessorTest.java
new file mode 100644
index 0000000000..ee390312ed
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/MemberAccessorTest.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@RunWith(Parameterized.class)
+public class MemberAccessorTest {
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        List<Object[]> data = new ArrayList<>();
+        data.add(new Object[] {new ReflectionMemberAccessor()});
+        data.add(new Object[] {new ModuleMemberAccessor()});
+        return data;
+    }
+
+    private final MemberAccessor accessor;
+
+    public MemberAccessorTest(MemberAccessor accessor) {
+        this.accessor = accessor;
+    }
+
+    @Test
+    public void test_read_field() throws Exception {
+        assertThat(accessor.get(Sample.class.getDeclaredField("field"), new Sample("foo")))
+                .isEqualTo("foo");
+    }
+
+    @Test
+    public void test_read_static_field() throws Exception {
+        Sample.staticField = "foo";
+        assertThat(accessor.get(Sample.class.getDeclaredField("staticField"), null))
+                .isEqualTo("foo");
+    }
+
+    @Test
+    public void test_write_field() throws Exception {
+        Sample sample = new Sample("foo");
+        accessor.set(Sample.class.getDeclaredField("field"), sample, "bar");
+        assertThat(sample.field).isEqualTo("bar");
+    }
+
+    @Test
+    public void test_write_static_field() throws Exception {
+        Sample.staticField = "foo";
+        accessor.set(Sample.class.getDeclaredField("staticField"), null, "bar");
+        assertThat(Sample.staticField).isEqualTo("bar");
+    }
+
+    @Test
+    public void test_invoke() throws Exception {
+        assertThat(
+                        accessor.invoke(
+                                Sample.class.getDeclaredMethod("test", String.class),
+                                new Sample(null),
+                                "foo"))
+                .isEqualTo("foo");
+    }
+
+    @Test
+    public void test_invoke_invocation_exception() {
+        assertThatThrownBy(
+                        () ->
+                                accessor.invoke(
+                                        Sample.class.getDeclaredMethod("test", String.class),
+                                        new Sample(null),
+                                        "exception"))
+                .isInstanceOf(InvocationTargetException.class);
+    }
+
+    @Test
+    public void test_invoke_illegal_arguments() {
+        assertThatThrownBy(
+                        () ->
+                                accessor.invoke(
+                                        Sample.class.getDeclaredMethod("test", String.class),
+                                        new Sample(null),
+                                        42))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void test_new_instance() throws Exception {
+        assertThat(accessor.newInstance(Sample.class.getDeclaredConstructor(String.class), "foo"))
+                .isInstanceOf(Sample.class);
+    }
+
+    @Test
+    public void test_new_instance_illegal_arguments() {
+        assertThatThrownBy(
+                        () ->
+                                accessor.newInstance(
+                                        Sample.class.getDeclaredConstructor(String.class), 42))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void test_new_instance_invocation_exception() {
+        assertThatThrownBy(
+                        () ->
+                                accessor.newInstance(
+                                        Sample.class.getDeclaredConstructor(String.class),
+                                        "exception"))
+                .isInstanceOf(InvocationTargetException.class);
+    }
+
+    @Test
+    public void test_new_instance_instantiation_exception() {
+        assertThatThrownBy(
+                        () -> accessor.newInstance(AbstractSample.class.getDeclaredConstructor()))
+                .isInstanceOf(InstantiationException.class);
+    }
+
+    @Test
+    public void test_set_final_field() throws Exception {
+        Sample sample = new Sample("foo");
+        accessor.set(Sample.class.getDeclaredField("finalField"), sample, "foo");
+        assertThat(sample.finalField).isEqualTo("foo");
+    }
+
+    private static class Sample {
+
+        private String field;
+
+        private final String finalField = null;
+
+        private static String staticField = "foo";
+
+        public Sample(String field) {
+            if ("exception".equals(field)) {
+                throw new RuntimeException();
+            }
+            this.field = field;
+        }
+
+        private String test(String value) {
+            if ("exception".equals(value)) {
+                throw new RuntimeException();
+            }
+            return value;
+        }
+    }
+
+    private abstract static class AbstractSample {}
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
new file mode 100644
index 0000000000..45ff5ea86f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.Observer;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
+import org.mockito.internal.util.reflection.FieldInitializer.ParameterizedConstructorInstantiator;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@SuppressWarnings("unchecked")
+@RunWith(MockitoJUnitRunner.class)
+public class ParameterizedConstructorInstantiatorTest {
+
+    private Set<?> whateverForNow;
+    private OneConstructor withOneConstructor;
+    private MultipleConstructor withMultipleConstructor;
+    private NoArgConstructor withNoArgConstructor;
+    private ThrowingConstructor withThrowingConstructor;
+    private VarargConstructor withVarargConstructor;
+
+    @After
+    public void ensure_instances_to_create_are_null() {
+        withMultipleConstructor = null;
+        withOneConstructor = null;
+        withNoArgConstructor = null;
+        withThrowingConstructor = null;
+        withVarargConstructor = null;
+    }
+
+    @Mock private ConstructorArgumentResolver resolver;
+
+    @Test
+    public void should_be_created_with_an_argument_resolver() throws Exception {
+        new ParameterizedConstructorInstantiator(this, field("whateverForNow"), resolver);
+    }
+
+    @Test
+    public void
+            should_fail_if_no_parameterized_constructor_found___excluding_inner_and_others_kind_of_types()
+                    throws Exception {
+        try {
+            new ParameterizedConstructorInstantiator(this, field("withNoArgConstructor"), resolver)
+                    .instantiate();
+            fail();
+        } catch (MockitoException me) {
+            assertThat(me.getMessage())
+                    .contains("no parameterized constructor")
+                    .contains("withNoArgConstructor")
+                    .contains("NoArgConstructor");
+        }
+    }
+
+    @Test
+    public void should_instantiate_type_if_resolver_provide_matching_types() throws Exception {
+        Observer observer = mock(Observer.class);
+        Map map = mock(Map.class);
+        given(resolver.resolveTypeInstances(ArgumentMatchers.any(Class[].class)))
+                .willReturn(new Object[] {observer, map});
+
+        new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver)
+                .instantiate();
+
+        assertNotNull(withMultipleConstructor);
+        assertNotNull(withMultipleConstructor.observer);
+        assertNotNull(withMultipleConstructor.map);
+    }
+
+    @Test
+    public void should_fail_if_an_argument_instance_type_do_not_match_wanted_type()
+            throws Exception {
+        Observer observer = mock(Observer.class);
+        Set<?> wrongArg = mock(Set.class);
+        given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>any()))
+                .willReturn(new Object[] {observer, wrongArg});
+
+        try {
+            new ParameterizedConstructorInstantiator(
+                            this, field("withMultipleConstructor"), resolver)
+                    .instantiate();
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage()).contains("argResolver").contains("incorrect types");
+        }
+    }
+
+    @Test
+    public void should_report_failure_if_constructor_throws_exception() throws Exception {
+        given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>any()))
+                .willReturn(new Object[] {null});
+
+        try {
+            new ParameterizedConstructorInstantiator(
+                            this, field("withThrowingConstructor"), resolver)
+                    .instantiate();
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage()).contains("constructor").contains("raised an exception");
+        }
+    }
+
+    @Test
+    public void should_instantiate_type_with_vararg_constructor() throws Exception {
+        Observer[] vararg = new Observer[] {};
+        given(resolver.resolveTypeInstances(ArgumentMatchers.any(Class[].class)))
+                .willReturn(new Object[] {"", vararg});
+
+        new ParameterizedConstructorInstantiator(this, field("withVarargConstructor"), resolver)
+                .instantiate();
+
+        assertNotNull(withVarargConstructor);
+    }
+
+    private Field field(String fieldName) throws NoSuchFieldException {
+        Field field = this.getClass().getDeclaredField(fieldName);
+        field.setAccessible(true);
+        return field;
+    }
+
+    private static class NoArgConstructor {
+        NoArgConstructor() {}
+    }
+
+    private static class OneConstructor {
+        public OneConstructor(Observer observer) {}
+    }
+
+    private static class ThrowingConstructor {
+        public ThrowingConstructor(Observer observer) throws IOException {
+            throw new IOException();
+        }
+    }
+
+    private static class MultipleConstructor extends OneConstructor {
+        Observer observer;
+        Map map;
+
+        public MultipleConstructor(Observer observer) {
+            this(observer, null);
+        }
+
+        public MultipleConstructor(Observer observer, Map map) {
+            super(observer);
+            this.observer = observer;
+            this.map = map;
+        }
+    }
+
+    private static class VarargConstructor {
+        VarargConstructor(String whatever, Observer... observers) {}
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java b/mockito-core/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
new file mode 100644
index 0000000000..ea50b4e2c1
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.internal.util.reflection.SuperTypesLastSorter.sortSuperTypesLast;
+
+import java.lang.reflect.Field;
+import java.util.*;
+
+import org.junit.Test;
+
+@SuppressWarnings("unused")
+public class SuperTypesLastSorterTest {
+    /**
+     * A Comparator that behaves like the old one, so the existing tests
+     * continue to work.
+     */
+    private static Comparator<Field> cmp =
+            new Comparator<Field>() {
+                public int compare(Field o1, Field o2) {
+                    if (o1.equals(o2)) {
+                        return 0;
+                    }
+
+                    List<Field> l = sortSuperTypesLast(Arrays.asList(o1, o2));
+
+                    if (l.get(0) == o1) {
+                        return -1;
+                    } else {
+                        return 1;
+                    }
+                }
+            };
+
+    private Object objectA;
+    private Object objectB;
+
+    private Number numberA;
+    private Number numberB;
+
+    private Integer integerA;
+    private Integer integerB;
+
+    private Iterable<?> iterableA;
+
+    private Number xNumber;
+    private Iterable<?> yIterable;
+    private Integer zInteger;
+
+    @Test
+    public void when_same_type_the_order_is_based_on_field_name() throws Exception {
+        assertThat(cmp.compare(field("objectA"), field("objectB"))).isEqualTo(-1);
+        assertThat(cmp.compare(field("objectB"), field("objectA"))).isEqualTo(1);
+        assertThat(cmp.compare(field("objectB"), field("objectB"))).isEqualTo(0);
+    }
+
+    @Test
+    public void when_type_is_different_the_supertype_comes_last() throws Exception {
+        assertThat(cmp.compare(field("numberA"), field("objectB"))).isEqualTo(-1);
+        assertThat(cmp.compare(field("objectB"), field("numberA"))).isEqualTo(1);
+    }
+
+    @Test
+    public void using_Collections_dot_sort() throws Exception {
+        List<Field> unsortedFields =
+                Arrays.asList(
+                        field("objectB"),
+                        field("integerB"),
+                        field("numberA"),
+                        field("numberB"),
+                        field("objectA"),
+                        field("integerA"));
+
+        List<Field> sortedFields = sortSuperTypesLast(unsortedFields);
+
+        assertThat(sortedFields)
+                .containsSequence(
+                        field("integerA"),
+                        field("integerB"),
+                        field("numberA"),
+                        field("numberB"),
+                        field("objectA"),
+                        field("objectB"));
+    }
+
+    @Test
+    public void issue_352_order_was_different_between_JDK6_and_JDK7() throws Exception {
+        List<Field> unsortedFields = Arrays.asList(field("objectB"), field("objectA"));
+
+        Collections.sort(unsortedFields, cmp);
+
+        assertThat(unsortedFields).containsSequence(field("objectA"), field("objectB"));
+    }
+
+    @Test
+    public void fields_sort_consistently_when_interfaces_are_included()
+            throws NoSuchFieldException {
+        assertSortConsistently(field("iterableA"), field("numberA"), field("integerA"));
+    }
+
+    @Test
+    public void fields_sort_consistently_when_names_and_type_indicate_different_order()
+            throws NoSuchFieldException {
+        assertSortConsistently(field("xNumber"), field("yIterable"), field("zInteger"));
+    }
+
+    /**
+     * Assert that these fields sort in the same order no matter which order
+     * they start in.
+     */
+    private static void assertSortConsistently(Field a, Field b, Field c) {
+        Field[][] initialOrderings = {
+            {a, b, c},
+            {a, c, b},
+            {b, a, c},
+            {b, c, a},
+            {c, a, b},
+            {c, b, a}
+        };
+
+        Set<List<Field>> results = new HashSet<List<Field>>();
+
+        for (Field[] o : initialOrderings) {
+            results.add(sortSuperTypesLast(Arrays.asList(o)));
+        }
+
+        assertThat(results).hasSize(1);
+    }
+
+    private Field field(String field) throws NoSuchFieldException {
+        return getClass().getDeclaredField(field);
+    }
+}
diff --git a/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java
similarity index 100%
rename from src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/DescriptionTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/DescriptionTest.java
new file mode 100644
index 0000000000..abf81cb677
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/DescriptionTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.openMocks;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.verification.VerificationMode;
+
+public class DescriptionTest {
+
+    @Mock private VerificationMode mockVerificationMode;
+
+    @Mock private VerificationData mockVerificationData;
+
+    @Before
+    public void setUp() {
+        openMocks(this);
+    }
+
+    /**
+     * Test of verify method, of class Description. This test validates that the custom message is prepended to the
+     * error message when verification fails.
+     */
+    @Test
+    public void verification_failure_should_prepend_expected_message() {
+        String failureMessage = "message should be prepended to the original message";
+        String exceptionMessage = "original error message";
+        String expectedResult = failureMessage + "\n" + exceptionMessage;
+        MockitoAssertionError error = new MockitoAssertionError(exceptionMessage);
+        doThrow(error).when(mockVerificationMode).verify(mockVerificationData);
+
+        Description instance = new Description(mockVerificationMode, failureMessage);
+
+        try {
+            instance.verify(mockVerificationData);
+            verify(mockVerificationMode).verify(mockVerificationData);
+            fail("Should not have made it this far");
+
+        } catch (MockitoAssertionError e) {
+            assertEquals(expectedResult, e.getMessage());
+        }
+    }
+
+    /**
+     * Test of verify method, of class Description. This test validates that the custom message is prepended to the
+     * error message when verification fails and throws a Throwable which is not a MockitoAssertionError.
+     */
+    @Test
+    public void verification_failure_throwing_AssertionError_should_prepend_expected_message() {
+        String failureMessage = "message should be prepended to the original message";
+        String exceptionMessage = "original error message";
+        String expectedResult = failureMessage + "\n" + exceptionMessage;
+        AssertionError error = new AssertionError(exceptionMessage);
+        doThrow(error).when(mockVerificationMode).verify(mockVerificationData);
+
+        Description instance = new Description(mockVerificationMode, failureMessage);
+
+        try {
+            instance.verify(mockVerificationData);
+            verify(mockVerificationMode).verify(mockVerificationData);
+            fail("Should not have made it this far");
+
+        } catch (MockitoAssertionError e) {
+            assertEquals(expectedResult, e.getMessage());
+        }
+    }
+}
diff --git a/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java b/mockito-core/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
similarity index 77%
rename from src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
index db8651192d..6b5f4c028f 100644
--- a/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
@@ -8,10 +8,14 @@
 import org.mockito.verification.VerificationMode;
 
 public class DummyVerificationMode implements VerificationMode {
-    public void verify(VerificationData data) {
-    }
+    public void verify(VerificationData data) {}
 
     public VerificationMode description(String description) {
         return new DummyVerificationMode();
     }
+
+    @Override
+    public String toString() {
+        return "Dummy verification mode";
+    }
 }
diff --git a/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
similarity index 88%
rename from src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
index 4c04a014a1..7c628cd8e8 100644
--- a/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
@@ -21,23 +21,21 @@ public class NoInteractionsTest extends TestBase {
 
     @Test
     public void noInteractionsExceptionMessageShouldDescribeMock() {
-        //given
+        // given
         NoInteractions n = new NoInteractions();
         IMethods mock = mock(IMethods.class, "a mock");
         InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher();
 
-        InvocationContainerImpl invocations =
-            new InvocationContainerImpl(new MockSettingsImpl());
+        InvocationContainerImpl invocations = new InvocationContainerImpl(new MockSettingsImpl());
         invocations.setInvocationForPotentialStubbing(i);
 
         try {
-            //when
+            // when
             n.verify(new VerificationDataImpl(invocations, null));
-            //then
+            // then
             fail();
         } catch (NoInteractionsWanted e) {
             Assertions.assertThat(e.toString()).contains(mock.toString());
         }
     }
-
 }
diff --git a/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
similarity index 86%
rename from src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
index d5d4a86f1a..e75898f62f 100644
--- a/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
@@ -28,75 +28,76 @@ public class NoMoreInteractionsTest extends TestBase {
 
     @Test
     public void shouldVerifyInOrder() {
-        //given
+        // given
         NoMoreInteractions n = new NoMoreInteractions();
         Invocation i = new InvocationBuilder().toInvocation();
         assertFalse(context.isVerified(i));
 
         try {
-            //when
+            // when
             n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null));
-            //then
+            // then
             fail();
-        } catch(VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
     public void shouldVerifyInOrderAndPass() {
-        //given
+        // given
         NoMoreInteractions n = new NoMoreInteractions();
         Invocation i = new InvocationBuilder().toInvocation();
         context.markVerified(i);
         assertTrue(context.isVerified(i));
 
-        //when
+        // when
         n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null));
-        //then no exception is thrown
+        // then no exception is thrown
     }
 
     @Test
     public void shouldVerifyInOrderMultipleInvoctions() {
-        //given
+        // given
         NoMoreInteractions n = new NoMoreInteractions();
         Invocation i = new InvocationBuilder().seq(1).toInvocation();
         Invocation i2 = new InvocationBuilder().seq(2).toInvocation();
 
-        //when
+        // when
         context.markVerified(i2);
 
-        //then no exception is thrown
+        // then no exception is thrown
         n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i, i2), null));
     }
 
     @Test
     public void shouldVerifyInOrderMultipleInvoctionsAndThrow() {
-        //given
+        // given
         NoMoreInteractions n = new NoMoreInteractions();
         Invocation i = new InvocationBuilder().seq(1).toInvocation();
         Invocation i2 = new InvocationBuilder().seq(2).toInvocation();
 
         try {
-            //when
+            // when
             n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i, i2), null));
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
     public void noMoreInteractionsExceptionMessageShouldDescribeMock() {
-        //given
+        // given
         NoMoreInteractions n = new NoMoreInteractions();
         IMethods mock = mock(IMethods.class, "a mock");
         InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher();
 
-        InvocationContainerImpl invocations =
-            new InvocationContainerImpl( new MockSettingsImpl());
+        InvocationContainerImpl invocations = new InvocationContainerImpl(new MockSettingsImpl());
         invocations.setInvocationForPotentialStubbing(i);
 
         try {
-            //when
+            // when
             n.verify(new VerificationDataImpl(invocations, null));
-            //then
+            // then
             fail();
         } catch (NoInteractionsWanted e) {
             Assertions.assertThat(e.toString()).contains(mock.toString());
@@ -105,15 +106,15 @@ public void noMoreInteractionsExceptionMessageShouldDescribeMock() {
 
     @Test
     public void noMoreInteractionsInOrderExceptionMessageShouldDescribeMock() {
-        //given
+        // given
         NoMoreInteractions n = new NoMoreInteractions();
         IMethods mock = mock(IMethods.class, "a mock");
         Invocation i = new InvocationBuilder().mock(mock).toInvocation();
 
         try {
-            //when
+            // when
             n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null));
-            //then
+            // then
             fail();
         } catch (VerificationInOrderFailure e) {
             Assertions.assertThat(e.toString()).contains(mock.toString());
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/OnlyTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/OnlyTest.java
new file mode 100644
index 0000000000..32050aa6c1
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/OnlyTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class OnlyTest extends TestBase {
+
+    @Mock IMethods mock;
+
+    Only only = new Only();
+
+    public static class VerificationDataStub implements VerificationData {
+        private final Invocation[] invocations;
+        private final InvocationMatcher wanted;
+
+        public VerificationDataStub(InvocationMatcher wanted, Invocation... invocations) {
+            this.invocations = invocations;
+            this.wanted = wanted;
+        }
+
+        public List<Invocation> getAllInvocations() {
+            return Arrays.asList(invocations);
+        }
+
+        @Override
+        public MatchableInvocation getTarget() {
+            return wanted;
+        }
+
+        public InvocationMatcher getWanted() {
+            return wanted;
+        }
+    }
+
+    @Test
+    public void shouldMarkAsVerifiedWhenAssertionSucceded() {
+        // given
+        Invocation invocation = new InvocationBuilder().toInvocation();
+        assertFalse(invocation.isVerified());
+
+        // when
+        only.verify(new VerificationDataStub(new InvocationMatcher(invocation), invocation));
+
+        // then
+        assertTrue(invocation.isVerified());
+    }
+
+    @Test
+    public void shouldNotMarkAsVerifiedWhenWantedButNotInvoked() {
+        // given
+        Invocation invocation = new InvocationBuilder().toInvocation();
+        assertFalse(invocation.isVerified());
+
+        // when
+        try {
+            only.verify(
+                    new VerificationDataStub(
+                            new InvocationBuilder().toInvocationMatcher(), invocation));
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+
+        // then
+        assertFalse(invocation.isVerified());
+    }
+
+    @Test
+    public void shouldMarkWantedOnlyAsVerified() {
+
+        // given
+        InvocationBuilder invocationBuilder = new InvocationBuilder();
+        Invocation wanted = invocationBuilder.mock(mock).simpleMethod().toInvocation();
+        Invocation different = new InvocationBuilder().mock(mock).differentMethod().toInvocation();
+
+        // when
+        try {
+            only.verify(
+                    new VerificationDataStub(
+                            invocationBuilder.toInvocationMatcher(), wanted, different));
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+
+        // then
+        assertTrue(wanted.isVerified());
+        assertFalse(different.isVerified());
+    }
+
+    @Test
+    public void shouldMarkMultipleInvocationAsVerified() {
+
+        // given
+        InvocationBuilder invocationBuilder = new InvocationBuilder();
+        Invocation wanted = invocationBuilder.mock(mock).simpleMethod().toInvocation();
+        Invocation different = invocationBuilder.mock(mock).differentMethod().toInvocation();
+
+        // when
+        try {
+            only.verify(
+                    new VerificationDataStub(
+                            invocationBuilder.toInvocationMatcher(), wanted, different));
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+
+        try {
+            only.verify(
+                    new VerificationDataStub(
+                            invocationBuilder.toInvocationMatcher(), different, wanted));
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+
+        // then
+        assertTrue(wanted.isVerified());
+        assertTrue(different.isVerified());
+    }
+}
diff --git a/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
similarity index 88%
rename from src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
index d786762a8d..645cb29d8a 100644
--- a/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
@@ -22,7 +22,10 @@ public class SmartPrinterTest extends TestBase {
 
     @Before
     public void setup() throws Exception {
-        mock.varargs("first very long argument", "second very long argument", "another very long argument");
+        mock.varargs(
+                "first very long argument",
+                "second very long argument",
+                "another very long argument");
         multi = new InvocationMatcher(getLastInvocation());
 
         mock.varargs("short arg");
@@ -31,10 +34,10 @@ public void setup() throws Exception {
 
     @Test
     public void shouldPrintBothInMultilinesWhenFirstIsMulti() {
-        //when
+        // when
         SmartPrinter printer = new SmartPrinter(multi, shortie.getInvocation());
 
-        //then
+        // then
         assertThat(printer.getWanted()).contains("\n");
         for (String actual : printer.getActuals()) {
             assertThat(actual).contains("\n");
@@ -43,10 +46,10 @@ public void shouldPrintBothInMultilinesWhenFirstIsMulti() {
 
     @Test
     public void shouldPrintBothInMultilinesWhenSecondIsMulti() {
-        //when
+        // when
         SmartPrinter printer = new SmartPrinter(shortie, multi.getInvocation());
 
-        //then
+        // then
         assertThat(printer.getWanted()).contains("\n");
         for (String actual : printer.getActuals()) {
             assertThat(actual).contains("\n");
@@ -55,10 +58,10 @@ public void shouldPrintBothInMultilinesWhenSecondIsMulti() {
 
     @Test
     public void shouldPrintBothInMultilinesWhenBothAreMulti() {
-        //when
+        // when
         SmartPrinter printer = new SmartPrinter(multi, multi.getInvocation());
 
-        //then
+        // then
         assertThat(printer.getWanted()).contains("\n");
         for (String actual : printer.getActuals()) {
             assertThat(actual).contains("\n");
@@ -67,10 +70,10 @@ public void shouldPrintBothInMultilinesWhenBothAreMulti() {
 
     @Test
     public void shouldPrintBothInSingleLineWhenBothAreShort() {
-        //when
+        // when
         SmartPrinter printer = new SmartPrinter(shortie, shortie.getInvocation());
 
-        //then
+        // then
         assertThat(printer.getWanted()).doesNotContain("\n");
         for (String actual : printer.getActuals()) {
             assertThat(actual).doesNotContain("\n");
diff --git a/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
similarity index 79%
rename from src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
index 1fb775a62d..2364102ffc 100644
--- a/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
@@ -16,10 +16,12 @@ public class VerificationDataImplTest extends TestBase {
 
     @Test
     public void shouldToStringBeNotVerifiable() throws Exception {
-        InvocationMatcher toString = new InvocationBuilder().method("toString").toInvocationMatcher();
+        InvocationMatcher toString =
+                new InvocationBuilder().method("toString").toInvocationMatcher();
         try {
             new VerificationDataImpl(null, toString);
             fail();
-        } catch (MockitoException e) {}
+        } catch (MockitoException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
new file mode 100644
index 0000000000..cc214b763b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.openMocks;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.verification.VerificationMode;
+
+public class VerificationOverTimeImplTest {
+    @Mock private VerificationMode delegate;
+    private VerificationOverTimeImpl impl;
+
+    @Before
+    public void setUp() {
+        openMocks(this);
+        impl = new VerificationOverTimeImpl(10, 1000, delegate, true);
+    }
+
+    @Test
+    public void should_return_on_success() {
+        impl.verify(null);
+        verify(delegate).verify(null);
+    }
+
+    @Test
+    public void should_throw_mockito_assertion_error() {
+        MockitoAssertionError toBeThrown = new MockitoAssertionError("message");
+
+        doThrow(toBeThrown).when(delegate).verify(null);
+        assertThatThrownBy(
+                        () -> {
+                            impl.verify(null);
+                        })
+                .isEqualTo(toBeThrown);
+    }
+
+    @Test
+    public void should_deal_with_junit_assertion_error() {
+        ArgumentsAreDifferent toBeThrown = new ArgumentsAreDifferent("message", "wanted", "actual");
+
+        doThrow(toBeThrown).when(delegate).verify(null);
+        assertThatThrownBy(
+                        () -> {
+                            impl.verify(null);
+                        })
+                .isEqualTo(toBeThrown);
+    }
+
+    @Test
+    public void should_not_wrap_other_exceptions() {
+        RuntimeException toBeThrown = new RuntimeException();
+
+        doThrow(toBeThrown).when(delegate).verify(null);
+        assertThatThrownBy(
+                        () -> {
+                            impl.verify(null);
+                        })
+                .isEqualTo(toBeThrown);
+    }
+}
diff --git a/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
similarity index 92%
rename from src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
rename to mockito-core/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
index ced6a5b226..36c7aacee1 100644
--- a/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
@@ -19,12 +19,11 @@
 
 public class VerificationWithDescriptionTest {
 
-    @Mock
-    private List<?> mock;
+    @Mock private List<?> mock;
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
+        MockitoAnnotations.openMocks(this);
     }
 
     @Test
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java
new file mode 100644
index 0000000000..27c986f43f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.argumentmatching;
+
+import static java.util.Collections.singletonList;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.ContainsExtraTypeInfo;
+import org.mockito.internal.matchers.Equals;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings({"rawtypes", "unchecked", "serial"})
+public class ArgumentMatchingToolTest extends TestBase {
+
+    @Test
+    public void shouldNotFindAnySuspiciousMatchersWhenNumberOfArgumentsDoesntMatch() {
+        // given
+        List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(1));
+
+        // when
+        Integer[] suspicious =
+                ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+                        matchers, new Object[] {10, 20});
+
+        // then
+        assertEquals(0, suspicious.length);
+    }
+
+    @Test
+    public void shouldNotFindAnySuspiciousMatchersWhenArgumentsMatch() {
+        // given
+        List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(10), new Equals(20));
+
+        // when
+        Integer[] suspicious =
+                ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+                        matchers, new Object[] {10, 20});
+
+        // then
+        assertEquals(0, suspicious.length);
+    }
+
+    @Test
+    public void shouldFindSuspiciousMatchers() {
+        // given
+        Equals matcherInt20 = new Equals(20);
+        Long longPretendingAnInt = 20L;
+
+        // when
+        List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(10), matcherInt20);
+        Integer[] suspicious =
+                ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+                        matchers, new Object[] {10, longPretendingAnInt});
+
+        // then
+        assertEquals(1, suspicious.length);
+        assertEquals(new Integer(1), suspicious[0]);
+    }
+
+    @Test
+    public void shouldNotFindSuspiciousMatchersWhenTypesAreTheSame() {
+        // given
+        Equals matcherWithBadDescription =
+                new Equals(20) {
+                    public String toString() {
+                        return "10";
+                    }
+                };
+        Integer argument = 10;
+
+        // when
+        Integer[] suspicious =
+                ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+                        (List) Arrays.asList(matcherWithBadDescription), new Object[] {argument});
+
+        // then
+        assertEquals(0, suspicious.length);
+    }
+
+    @Test
+    public void shouldWorkFineWhenGivenArgIsNull() {
+        // when
+        Integer[] suspicious =
+                ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+                        (List) Arrays.asList(new Equals(20)), new Object[] {null});
+
+        // then
+        assertEquals(0, suspicious.length);
+    }
+
+    @Test
+    public void shouldUseMatchersSafely() {
+        // This matcher is evil cause typeMatches(Object) returns true for every passed type but
+        // matches(T)
+        // method accepts only Strings. When a Integer is passed (thru the matches(Object) bridge
+        // method )  a
+        // ClassCastException will be thrown.
+        class StringMatcher implements ArgumentMatcher<String>, ContainsExtraTypeInfo {
+            @Override
+            public boolean matches(String item) {
+                return true; // in this test we never get here
+            }
+
+            @Override
+            public String toStringWithType(String className) {
+                return "";
+            }
+
+            @Override
+            public boolean typeMatches(Object target) {
+                return true;
+            }
+
+            @Override
+            public Object getWanted() {
+                return "";
+            }
+        }
+
+        // given
+        List<ArgumentMatcher> matchers = (List) singletonList(new StringMatcher());
+
+        // when
+        Integer[] suspicious =
+                ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+                        matchers, new Object[] {10});
+
+        // then
+        assertEquals(0, suspicious.length);
+    }
+
+    @Test
+    public void shouldNotFindNonMatchingIndexesWhenEveryArgsMatch() {
+        String arg1Value = "arg1";
+        Integer arg2Value = 2222;
+
+        Equals arg1 = new Equals(arg1Value);
+        Equals arg2 = new Equals(arg2Value);
+
+        List<Integer> indexes =
+                ArgumentMatchingTool.getNotMatchingArgsIndexes(
+                        Arrays.asList(arg1, arg2), new Object[] {arg1Value, arg2Value});
+
+        assertEquals(Arrays.asList(), indexes);
+    }
+
+    @Test
+    public void shouldFindNonMatchingIndexesWhenSingleArgDoesNotMatch() {
+        String arg1Value = "arg1";
+        Integer arg2Value = 2222;
+
+        Equals arg1 = new Equals(arg1Value);
+        Equals arg2 = new Equals(1111);
+
+        List<Integer> indexes =
+                ArgumentMatchingTool.getNotMatchingArgsIndexes(
+                        Arrays.asList(arg1, arg2), new Object[] {arg1Value, arg2Value});
+
+        assertEquals(Arrays.asList(1), indexes);
+    }
+
+    @Test
+    public void shouldFindNonMatchingIndexesWhenMultiArgsDoNotMatch() {
+        String arg1Value = "arg1";
+        Integer arg2Value = 2222;
+
+        Equals arg1 = new Equals("differs");
+        Equals arg2 = new Equals(1111);
+
+        List<Integer> indexes =
+                ArgumentMatchingTool.getNotMatchingArgsIndexes(
+                        Arrays.asList(arg1, arg2), new Object[] {arg1Value, arg2Value});
+
+        assertEquals(Arrays.asList(0, 1), indexes);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
new file mode 100644
index 0000000000..3087003712
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.checkers;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.internal.verification.checkers.AtLeastXNumberOfInvocationsChecker.checkAtLeastNumberOfInvocations;
+
+import org.junit.Test;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.verification.InOrderContextImpl;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+
+public class AtLeastXNumberOfInvocationsCheckerTest {
+
+    @Test
+    public void shouldMarkActualInvocationsAsVerifiedInOrder() {
+        InOrderContext context = new InOrderContextImpl();
+        // given
+        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
+        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
+
+        // when
+        checkAtLeastNumberOfInvocations(
+                asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1, context);
+
+        // then
+        assertThat(invocation.isVerified()).isTrue();
+    }
+
+    @Test
+    public void shouldReportTooFewInvocationsInOrder() {
+        InOrderContext context = new InOrderContextImpl();
+        // given
+        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
+        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
+
+        // when
+        assertThatThrownBy(
+                        () ->
+                                checkAtLeastNumberOfInvocations(
+                                        asList(invocation, invocationTwo),
+                                        new InvocationMatcher(invocation),
+                                        2,
+                                        context))
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "iMethods.simpleMethod();", "Wanted *at least* 2 times", "But was 1 time");
+    }
+
+    @Test
+    public void shouldMarkActualInvocationsAsVerified() {
+        // given
+        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
+        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
+
+        // when
+        checkAtLeastNumberOfInvocations(
+                asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1);
+
+        // then
+        assertThat(invocation.isVerified()).isTrue();
+    }
+
+    @Test
+    public void shouldReportTooFewInvocations() {
+        // given
+        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
+        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
+
+        // when
+        assertThatThrownBy(
+                        () -> {
+                            checkAtLeastNumberOfInvocations(
+                                    asList(invocation, invocationTwo),
+                                    new InvocationMatcher(invocation),
+                                    2);
+                        })
+                .isInstanceOf(TooFewActualInvocations.class)
+                .hasMessageContainingAll(
+                        "iMethods.simpleMethod();", "Wanted *at least* 2 times", "But was 1 time");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
new file mode 100644
index 0000000000..cd7da33ca2
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.checkers;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.internal.invocation.InterceptedInvocation;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.invocation.MockitoMethod;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.internal.invocation.mockref.MockReference;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class MissingInvocationCheckerTest extends TestBase {
+
+    private InvocationMatcher wanted;
+    private List<Invocation> invocations;
+
+    @Mock private IMethods mock;
+
+    @Test
+    public void shouldPassBecauseActualInvocationFound() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations = asList(buildSimpleMethod().toInvocation());
+
+        MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+    }
+
+    @Test
+    public void shouldReportWantedButNotInvoked() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations = asList(buildDifferentMethod().toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll(
+                        "Wanted but not invoked:",
+                        "mock.simpleMethod()",
+                        "However, there was exactly 1 interaction with this mock:",
+                        "mock.differentMethod();");
+    }
+
+    @Test
+    public void shouldReportWantedInvocationDiffersFromActual() {
+        wanted = buildIntArgMethod(new InvocationBuilder()).arg(2222).toInvocationMatcher();
+        invocations = asList(buildIntArgMethod(new InvocationBuilder()).arg(1111).toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.intArgumentMethod(2222);",
+                        "Actual invocations have different arguments:",
+                        "mock.intArgumentMethod(1111);");
+    }
+
+    @Test
+    public void shouldReportUsingInvocationDescription() {
+        wanted = buildIntArgMethod(new CustomInvocationBuilder()).arg(2222).toInvocationMatcher();
+        invocations =
+                singletonList(
+                        buildIntArgMethod(new CustomInvocationBuilder()).arg(1111).toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.intArgumentMethod(MyCoolPrint(2222));",
+                        "Actual invocations have different arguments:",
+                        "mock.intArgumentMethod(MyCoolPrint(1111));");
+    }
+
+    @Test
+    public void shouldSpecifyPosition0WhenWantedInvocationDiffersFromActual() {
+        wanted = buildMultiArgsMethod().args("arg1", 2222).toInvocationMatcher();
+        invocations = singletonList(buildMultiArgsMethod().args("differs", 2222).toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.simpleMethod(\"arg1\", 2222);",
+                        "Actual invocations have different arguments at position [0]:",
+                        "mock.simpleMethod(\"differs\", 2222);");
+    }
+
+    @Test
+    public void shouldSpecifyPosition1WhenWantedInvocationDiffersFromActual() {
+        wanted = buildMultiArgsMethod().args("arg1", 2222).toInvocationMatcher();
+        invocations = singletonList(buildMultiArgsMethod().args("arg1", 1111).toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.simpleMethod(\"arg1\", 2222);",
+                        "Actual invocations have different arguments at position [1]:",
+                        "mock.simpleMethod(\"arg1\", 1111);");
+    }
+
+    @Test
+    public void shouldSpecifyPosition0And1WhenWantedInvocationDiffersFromActual() {
+        wanted = buildMultiArgsMethod().args("arg1", 2222).toInvocationMatcher();
+        invocations = singletonList(buildMultiArgsMethod().args("differs", 1111).toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.simpleMethod(\"arg1\", 2222);",
+                        "Actual invocations have different arguments at positions [0, 1]:",
+                        "mock.simpleMethod(\"differs\", 1111);");
+    }
+
+    @Test
+    public void shouldNotSpecifyPositionWhenWantedSingleArgInvocationSiffersFromActual() {
+        wanted = buildIntArgMethod(new CustomInvocationBuilder()).arg(2222).toInvocationMatcher();
+        invocations =
+                singletonList(
+                        buildIntArgMethod(new CustomInvocationBuilder()).arg(1111).toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.intArgumentMethod(MyCoolPrint(2222));",
+                        "Actual invocations have different arguments:",
+                        "mock.intArgumentMethod(MyCoolPrint(1111));");
+    }
+
+    private InvocationBuilder buildIntArgMethod(InvocationBuilder invocationBuilder) {
+        return invocationBuilder.mock(mock).method("intArgumentMethod").argTypes(int.class);
+    }
+
+    private InvocationBuilder buildSimpleMethod() {
+        return new InvocationBuilder().mock(mock).simpleMethod();
+    }
+
+    private InvocationBuilder buildDifferentMethod() {
+        return new InvocationBuilder().mock(mock).differentMethod();
+    }
+
+    private InvocationBuilder buildMultiArgsMethod() {
+        return new InvocationBuilder()
+                .mock(mock)
+                .method("simpleMethod")
+                .argTypes(String.class, Integer.class);
+    }
+
+    static class CustomInvocationBuilder extends InvocationBuilder {
+        @Override
+        protected Invocation createInvocation(
+                MockReference<Object> mockRef,
+                MockitoMethod mockitoMethod,
+                final Object[] arguments,
+                RealMethod realMethod,
+                Location location,
+                int sequenceNumber) {
+            return new InterceptedInvocation(
+                    mockRef, mockitoMethod, arguments, realMethod, location, sequenceNumber) {
+                @Override
+                public List<ArgumentMatcher> getArgumentsAsMatchers() {
+                    List<ArgumentMatcher> matchers = new ArrayList<>();
+                    for (final Object argument : getRawArguments()) {
+                        matchers.add(
+                                new ArgumentMatcher() {
+                                    @Override
+                                    public boolean matches(Object a) {
+                                        return a == argument;
+                                    }
+
+                                    @Override
+                                    public String toString() {
+                                        return "MyCoolPrint(" + argument + ")";
+                                    }
+                                });
+                    }
+                    return matchers;
+                }
+            };
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
new file mode 100644
index 0000000000..899d0d3bc8
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification.checkers;
+
+import static java.util.Arrays.asList;
+
+import static org.mockito.internal.verification.checkers.MissingInvocationChecker.checkMissingInvocation;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.verification.InOrderContextImpl;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockitousage.IMethods;
+
+public class MissingInvocationInOrderCheckerTest {
+
+    private InvocationMatcher wanted;
+    private List<Invocation> invocations;
+
+    @Mock private IMethods mock;
+
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    private InOrderContext context = new InOrderContextImpl();
+
+    @Before
+    public void setup() {}
+
+    @Test
+    public void shouldPassWhenMatchingInteractionFound() throws Exception {
+
+        invocations = asList(buildSimpleMethod().toInvocation());
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        checkMissingInvocation(invocations, wanted, context);
+    }
+
+    @Test
+    public void shouldReportWantedButNotInvoked() throws Exception {
+        invocations = asList(buildDifferentMethod().toInvocation());
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            checkMissingInvocation(invocations, wanted, context);
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll("Wanted but not invoked:", "mock.simpleMethod()");
+    }
+
+    @Test
+    public void shouldReportArgumentsAreDifferent() throws Exception {
+        invocations = asList(buildIntArgMethod().arg(1111).toInvocation());
+        wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            checkMissingInvocation(invocations, wanted, context);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.intArgumentMethod(2222);",
+                        "Actual invocations have different arguments:",
+                        "mock.intArgumentMethod(1111);");
+    }
+
+    @Test
+    public void shouldReportWantedDiffersFromActual() throws Exception {
+
+        Invocation invocation1 = buildIntArgMethod().arg(1111).toInvocation();
+        Invocation invocation2 = buildIntArgMethod().arg(2222).toInvocation();
+
+        context.markVerified(invocation2);
+        invocations = asList(invocation1, invocation2);
+        wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            checkMissingInvocation(invocations, wanted, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure",
+                        "Wanted but not invoked:",
+                        "mock.intArgumentMethod(2222);",
+                        "Wanted anywhere AFTER following interaction:",
+                        "mock.intArgumentMethod(2222);");
+    }
+
+    private InvocationBuilder buildIntArgMethod() {
+        return new InvocationBuilder().mock(mock).method("intArgumentMethod").argTypes(int.class);
+    }
+
+    private InvocationBuilder buildSimpleMethod() {
+        return new InvocationBuilder().mock(mock).simpleMethod();
+    }
+
+    private InvocationBuilder buildDifferentMethod() {
+        return new InvocationBuilder().mock(mock).differentMethod();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
new file mode 100644
index 0000000000..1c9bc6df87
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+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.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.assertj.core.api.Condition;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.NeverWantedButInvoked;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.exceptions.verification.TooManyActualInvocations;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.invocation.Invocation;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+
+@RunWith(MockitoJUnitRunner.class)
+public class NumberOfInvocationsCheckerTest {
+
+    private InvocationMatcher wanted;
+
+    private List<Invocation> invocations;
+
+    @Mock private IMethods mock;
+
+    @Rule public TestName testName = new TestName();
+
+    @Test
+    public void shouldReportTooFewActual() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations =
+                asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 100);
+                        })
+                .isInstanceOf(TooFewActualInvocations.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 100 times", "But was 2 times");
+    }
+
+    @Test
+    public void shouldReportAllInvocationsStackTrace() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations =
+                asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 100);
+                        })
+                .isInstanceOf(TooFewActualInvocations.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 100 times", "But was 2 times")
+                .has(messageContaining("-> at", 3));
+    }
+
+    @Test
+    public void shouldNotReportWithLastInvocationStackTraceIfNoInvocationsFound() {
+        invocations = emptyList();
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 100);
+                        })
+                .isInstanceOf(TooFewActualInvocations.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 100 times", "But was 0 times")
+                .has(messageContaining("-> at", 1));
+    }
+
+    @Test
+    public void shouldReportWithAllInvocationsStackTrace() {
+        Invocation first = buildSimpleMethod().toInvocation();
+        Invocation second = buildSimpleMethod().toInvocation();
+        Invocation third = buildSimpleMethod().toInvocation();
+
+        invocations = asList(first, second, third);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 2);
+                        })
+                .isInstanceOf(TooManyActualInvocations.class)
+                .hasMessageContainingAll(
+                        "" + first.getLocation(),
+                        "" + second.getLocation(),
+                        "" + third.getLocation());
+    }
+
+    @Test
+    public void shouldReportTooManyActual() {
+        Invocation first = buildSimpleMethod().toInvocation();
+        Invocation second = buildSimpleMethod().toInvocation();
+
+        invocations = asList(first, second);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 1);
+                        })
+                .hasMessageContainingAll("Wanted 1 time", "But was 2 times");
+    }
+
+    @Test
+    public void shouldReportNeverWantedButInvokedWithArgs() {
+        Invocation invocation = buildSimpleMethodWithArgs("arg1").toInvocation();
+
+        invocations = Collections.singletonList(invocation);
+        wanted = buildSimpleMethodWithArgs("arg1").toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 0);
+                        })
+                .isInstanceOf(NeverWantedButInvoked.class)
+                .hasMessageContainingAll(
+                        "Never wanted here",
+                        "But invoked here",
+                        "" + invocation.getLocation() + " with arguments: [arg1]");
+    }
+
+    @Test
+    public void shouldReportNeverWantedButInvokedWithArgs_multipleInvocations() {
+        Invocation first = buildSimpleMethodWithArgs("arg1").toInvocation();
+        Invocation second = buildSimpleMethodWithArgs("arg1").toInvocation();
+
+        invocations = asList(first, second);
+        wanted = buildSimpleMethodWithArgs("arg1").toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 0);
+                        })
+                .isInstanceOf(NeverWantedButInvoked.class)
+                .hasMessageContainingAll(
+                        "Never wanted here",
+                        "But invoked here",
+                        "" + first.getLocation() + " with arguments: [arg1]",
+                        "" + second.getLocation() + " with arguments: [arg1]");
+    }
+
+    @Test
+    public void shouldMarkInvocationsAsVerified() {
+        Invocation invocation = buildSimpleMethod().toInvocation();
+        assertThat(invocation.isVerified()).isFalse();
+
+        invocations = asList(invocation);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1);
+        assertThat(invocation.isVerified()).isTrue();
+    }
+
+    private InvocationBuilder buildSimpleMethod() {
+        return new InvocationBuilder().mock(mock).simpleMethod();
+    }
+
+    private InvocationBuilder buildSimpleMethodWithArgs(String arg) {
+        return new InvocationBuilder().mock(mock).simpleMethod().args(arg);
+    }
+
+    private static Condition<? super Throwable> messageContaining(
+            String value, int amountOfOccurrences) {
+        return new ThrowableMessageContainsOccurrencesCondition(value, amountOfOccurrences);
+    }
+
+    private static class ThrowableMessageContainsOccurrencesCondition extends Condition<Throwable> {
+
+        private final String value;
+        private final int expectedOccurrences;
+
+        public ThrowableMessageContainsOccurrencesCondition(String value, int expectedOccurrences) {
+            this.value = value;
+            this.expectedOccurrences = expectedOccurrences;
+
+            as("exactly %s occurrences of \"%s\"", expectedOccurrences, value);
+        }
+
+        @Override
+        public boolean matches(Throwable ex) {
+            int lastIndex = 0;
+            int count = 0;
+            while (lastIndex != -1) {
+                lastIndex = ex.getMessage().indexOf(value, lastIndex);
+                if (lastIndex != -1) {
+                    count++;
+                    lastIndex += value.length();
+                }
+            }
+            return count == expectedOccurrences;
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
new file mode 100644
index 0000000000..06b36c4d5f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+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.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+
+import java.util.List;
+
+import org.assertj.core.api.Condition;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.verification.InOrderContextImpl;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockitousage.IMethods;
+
+public class NumberOfInvocationsInOrderCheckerTest {
+
+    private InvocationMatcher wanted;
+    private List<Invocation> invocations;
+    private InOrderContext context;
+
+    private IMethods mock;
+
+    @Before
+    public void setup() {
+        context = new InOrderContextImpl();
+        mock = mock(IMethods.class, "mock");
+    }
+
+    @Test
+    public void shouldPassIfWantedIsZeroAndMatchingChunkIsEmpty() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations = emptyList();
+
+        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0, context);
+    }
+
+    @Test
+    public void shouldPassIfChunkMatches() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations = asList(buildSimpleMethod().toInvocation());
+        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
+    }
+
+    @Test
+    public void shouldReportTooFewInvocations() {
+        Invocation first = buildSimpleMethod().toInvocation();
+        Invocation second = buildSimpleMethod().toInvocation();
+
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations = asList(first, second);
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 4, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 4 times", "But was 2 times");
+    }
+
+    @Test
+    public void shouldMarkAsVerifiedInOrder() {
+        Invocation invocation = buildSimpleMethod().toInvocation();
+
+        invocations = asList(invocation);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThat(context.isVerified(invocation)).isFalse();
+        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
+        assertThat(context.isVerified(invocation)).isTrue();
+    }
+
+    @Test
+    public void shouldReportTooFewActual() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations =
+                asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 100, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 100 times", "But was 2 times");
+    }
+
+    @Test
+    public void shouldReportWithAllInvocationsStackTrace() {
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        invocations =
+                asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 100, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 100 times", "But was 2 times")
+                .has(messageContaining("-> at", 3));
+    }
+
+    @Test
+    public void shouldNotReportWithLastInvocationStackTraceIfNoInvocationsFound() {
+        invocations = emptyList();
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 100, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()", "Wanted 100 times", "But was 0 times")
+                .has(messageContaining("-> at", 1));
+    }
+
+    @Test
+    public void shouldReportWithFirstUndesiredInvocationStackTrace() {
+        Invocation first = buildSimpleMethod().toInvocation();
+        Invocation second = buildSimpleMethod().toInvocation();
+        Invocation third = buildSimpleMethod().toInvocation();
+
+        invocations = asList(first, second, third);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 2, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("" + third.getLocation());
+    }
+
+    @Test
+    public void shouldReportTooManyActual() {
+        Invocation first = buildSimpleMethod().toInvocation();
+        Invocation second = buildSimpleMethod().toInvocation();
+
+        invocations = asList(first, second);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 1, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll("Wanted 1 time", "But was 2 times");
+    }
+
+    @Test
+    public void shouldReportNeverWantedButInvoked() {
+        Invocation first = buildSimpleMethod().toInvocation();
+
+        invocations = asList(first);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+
+        assertThatThrownBy(
+                        () -> {
+                            NumberOfInvocationsChecker.checkNumberOfInvocations(
+                                    invocations, wanted, 0, context);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "mock.simpleMethod()",
+                        "Wanted 0 times",
+                        "But was 1 time:",
+                        "" + first.getLocation());
+    }
+
+    @Test
+    public void shouldMarkInvocationsAsVerified() {
+        Invocation invocation = buildSimpleMethod().toInvocation();
+        assertThat(invocation.isVerified()).isFalse();
+
+        invocations = asList(invocation);
+        wanted = buildSimpleMethod().toInvocationMatcher();
+        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
+        assertThat(invocation.isVerified()).isTrue();
+    }
+
+    private static Condition<? super Throwable> messageContaining(
+            String value, int amountOfOccurrences) {
+        return new ThrowableMessageContainsOccurrencesCondition(value, amountOfOccurrences);
+    }
+
+    private static class ThrowableMessageContainsOccurrencesCondition extends Condition<Throwable> {
+
+        private final String value;
+        private final int expectedOccurrences;
+
+        public ThrowableMessageContainsOccurrencesCondition(String value, int expectedOccurrences) {
+            this.value = value;
+            this.expectedOccurrences = expectedOccurrences;
+
+            as("exactly %s occurrences of \"%s\"", expectedOccurrences, value);
+        }
+
+        @Override
+        public boolean matches(Throwable ex) {
+            int lastIndex = 0;
+            int count = 0;
+            while (lastIndex != -1) {
+                lastIndex = ex.getMessage().indexOf(value, lastIndex);
+                if (lastIndex != -1) {
+                    count++;
+                    lastIndex += value.length();
+                }
+            }
+            return count == expectedOccurrences;
+        }
+    }
+
+    private InvocationBuilder buildSimpleMethod() {
+        return new InvocationBuilder().mock(mock).simpleMethod();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/junit/TestableJUnitRunner.java b/mockito-core/src/test/java/org/mockito/junit/TestableJUnitRunner.java
new file mode 100644
index 0000000000..a8b04f099d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/junit/TestableJUnitRunner.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.junit.runners.model.InitializationError;
+import org.mockito.internal.junit.MismatchReportingTestListener;
+import org.mockito.internal.junit.MockitoTestListener;
+import org.mockito.internal.runners.RunnerFactory;
+import org.mockito.internal.runners.StrictRunner;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.internal.util.Supplier;
+
+public class TestableJUnitRunner extends MockitoJUnitRunner {
+
+    private static final ThreadLocal<SimpleMockitoLogger> LOGGER =
+            new ThreadLocal<SimpleMockitoLogger>() {
+                protected SimpleMockitoLogger initialValue() {
+                    return new SimpleMockitoLogger();
+                }
+            };
+
+    public TestableJUnitRunner(Class<?> klass)
+            throws InvocationTargetException, InitializationError {
+        super(
+                new StrictRunner(
+                        new RunnerFactory()
+                                .create(
+                                        klass,
+                                        new Supplier<MockitoTestListener>() {
+                                            public MockitoTestListener get() {
+                                                return new MismatchReportingTestListener(
+                                                        LOGGER.get());
+                                            }
+                                        }),
+                        klass));
+    }
+
+    public static SimpleMockitoLogger refreshedLogger() {
+        return LOGGER.get().clear();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockito/verification/NegativeDurationTest.java b/mockito-core/src/test/java/org/mockito/verification/NegativeDurationTest.java
new file mode 100644
index 0000000000..06b3cb4788
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockito/verification/NegativeDurationTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.misusing.FriendlyReminderException;
+
+public class NegativeDurationTest {
+
+    @Test
+    public void should_throw_exception_when_duration_is_negative_for_timeout_method() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.timeout(-1);
+                        })
+                .isInstanceOf(FriendlyReminderException.class)
+                .hasMessageContaining("Don't panic! I'm just a friendly reminder!");
+    }
+
+    @Test
+    public void should_throw_exception_when_duration_is_negative_for_after_method() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.after(-1);
+                        })
+                .isInstanceOf(FriendlyReminderException.class)
+                .hasMessageContaining("Don't panic! I'm just a friendly reminder!");
+    }
+}
diff --git a/src/test/java/org/mockito/verification/TimeoutTest.java b/mockito-core/src/test/java/org/mockito/verification/TimeoutTest.java
similarity index 82%
rename from src/test/java/org/mockito/verification/TimeoutTest.java
rename to mockito-core/src/test/java/org/mockito/verification/TimeoutTest.java
index ae6e5d2e84..b4c1ada177 100644
--- a/src/test/java/org/mockito/verification/TimeoutTest.java
+++ b/mockito-core/src/test/java/org/mockito/verification/TimeoutTest.java
@@ -17,12 +17,9 @@
 
 public class TimeoutTest extends TestBase {
 
-    @Mock
-    VerificationMode mode;
-    @Mock
-    VerificationDataImpl data;
-    @Mock
-    Timer timer;
+    @Mock VerificationMode mode;
+    @Mock VerificationDataImpl data;
+    @Mock Timer timer;
 
     private final MockitoAssertionError error = new MockitoAssertionError("");
 
@@ -45,15 +42,13 @@ public void should_fail_because_verification_fails() {
         Timeout t = new Timeout(1, mode, timer);
 
         when(timer.isCounting()).thenReturn(true, true, true, false);
-        doThrow(error).
-        doThrow(error).
-        doThrow(error).
-        when(mode).verify(data);
+        doThrow(error).doThrow(error).doThrow(error).when(mode).verify(data);
 
         try {
             t.verify(data);
             fail();
-        } catch (MockitoAssertionError e) {}
+        } catch (MockitoAssertionError e) {
+        }
 
         verify(timer, times(4)).isCounting();
     }
@@ -63,10 +58,7 @@ public void should_pass_even_if_first_verification_fails() {
         Timeout t = new Timeout(1, mode, timer);
 
         when(timer.isCounting()).thenReturn(true, true, true, false);
-        doThrow(error).
-        doThrow(error).
-        doNothing().
-        when(mode).verify(data);
+        doThrow(error).doThrow(error).doNothing().when(mode).verify(data);
 
         t.verify(data);
         verify(timer, times(3)).isCounting();
@@ -82,9 +74,9 @@ public void should_try_to_verify_correct_number_of_times() {
         try {
             t.verify(data);
             fail();
-        } catch (MockitoAssertionError e) {}
+        } catch (MockitoAssertionError e) {
+        }
 
         verify(mode, times(5)).verify(data);
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockitointegration/ClassLoadabilityChecker.java b/mockito-core/src/test/java/org/mockitointegration/ClassLoadabilityChecker.java
new file mode 100644
index 0000000000..d19c51fb74
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitointegration/ClassLoadabilityChecker.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitointegration;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Check that classes can be loaded and initialized on a provided classloader. Used
+ * for checking that Mockito has no dependency on libraries like JUnit.
+ * <p>
+ * Some classes are excluded from this checking - namely, classes that fail due to
+ * the absence of Java classes. It's assumed that this is due to a specific optional
+ * dependency on APIs available in certain Java versions and so other elements of the
+ * test Matrix will check that those classes do not depend on JUnit or ByteBuddy. We
+ * exclude based on the failure of a ClassNotFoundException, or a NoClassDefFoundError
+ * caused by the failing to load of a failing parent class.
+ */
+public final class ClassLoadabilityChecker {
+    private static final boolean INITIALIZE_CLASSES = true;
+    private final Set<String> excludedClasses = new HashSet<>();
+    private final ClassLoader classLoader;
+    private final String purpose;
+
+    public ClassLoadabilityChecker(ClassLoader classLoader, String purpose) {
+        this.classLoader = classLoader;
+        this.purpose = purpose;
+    }
+
+    public void checkLoadability(String className) {
+        try {
+            Class.forName(className, INITIALIZE_CLASSES, classLoader);
+        } catch (ClassNotFoundException | LinkageError e) {
+            if (isFailureExcluded(className, e)) {
+                return;
+            }
+            e.printStackTrace();
+            throw new AssertionError(
+                    String.format("'%s' has some dependency to %s", className, purpose));
+        }
+    }
+
+    private boolean isFailureExcluded(String loadedClass, Throwable thrown) {
+        if (thrown == null) {
+            return false;
+        }
+        if (thrown instanceof ClassNotFoundException) {
+            ClassNotFoundException cnf = (ClassNotFoundException) thrown;
+            if (cnf.getMessage().startsWith("java.")) {
+                excludedClasses.add(loadedClass);
+                return true;
+            }
+        } else if (thrown instanceof NoClassDefFoundError) {
+            NoClassDefFoundError ncdf = (NoClassDefFoundError) thrown;
+            // if Foo fails due to depending on a Java class, Foo$Bar will fail with a NCDFE
+            int lastInnerClass = loadedClass.lastIndexOf('$');
+            if (lastInnerClass != -1) {
+                String parent = loadedClass.substring(0, lastInnerClass);
+                if (excludedClasses.contains(parent) && ncdf.getMessage().contains(parent)) {
+                    excludedClasses.add(loadedClass);
+                    return true;
+                }
+            }
+        }
+
+        return isFailureExcluded(loadedClass, thrown.getCause());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitointegration/DeferMockMakersClassLoadingTest.java b/mockito-core/src/test/java/org/mockitointegration/DeferMockMakersClassLoadingTest.java
new file mode 100644
index 0000000000..63c0d761bd
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitointegration/DeferMockMakersClassLoadingTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitointegration;
+
+import static org.mockito.Mockito.withSettings;
+import static org.mockitoutil.ClassLoaders.coverageTool;
+
+import java.lang.reflect.Method;
+
+import org.assertj.core.api.Assertions;
+import org.hamcrest.Matcher;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker;
+import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker;
+import org.mockito.internal.creation.proxy.ProxyMockMaker;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockMaker;
+import org.mockitoutil.ClassLoaders;
+
+public class DeferMockMakersClassLoadingTest {
+    private static final Object MY_MOCK = new Object();
+
+    @Test
+    public void mockito_should_not_load_mock_makers_it_does_not_need() throws Exception {
+        ClassLoader classLoader_without_mockMakers =
+                ClassLoaders.excludingClassLoader()
+                        .withCodeSourceUrlOf(
+                                Mockito.class,
+                                Matcher.class,
+                                CustomMockMaker.class,
+                                Assertions.class)
+                        .withCodeSourceUrlOf(coverageTool())
+                        .without(
+                                ByteBuddyMockMaker.class.getName(),
+                                SubclassByteBuddyMockMaker.class.getName(),
+                                InlineByteBuddyMockMaker.class.getName(),
+                                ProxyMockMaker.class.getName())
+                        .build();
+
+        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(classLoader_without_mockMakers);
+        try {
+            Class<?> self = classLoader_without_mockMakers.loadClass(getClass().getName());
+            Method createMock = self.getMethod("createMock");
+            createMock.invoke(null);
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextClassLoader);
+        }
+    }
+
+    // Called by reflection from the test method
+    public static void createMock() {
+        Assertions.assertThat(
+                        Mockito.mock(
+                                Object.class,
+                                withSettings().mockMaker(CustomMockMaker.class.getName())))
+                .isSameAs(MY_MOCK);
+    }
+
+    public static class CustomMockMaker implements MockMaker {
+        @Override
+        public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+            return settings.getTypeToMock().cast(MY_MOCK);
+        }
+
+        @Override
+        public MockHandler getHandler(Object mock) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public TypeMockability isTypeMockable(Class<?> type) {
+            return new TypeMockability() {
+                @Override
+                public boolean mockable() {
+                    return type.equals(Object.class);
+                }
+
+                @Override
+                public String nonMockableReason() {
+                    return mockable() ? "" : "type != Object.class";
+                }
+            };
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java b/mockito-core/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java
new file mode 100644
index 0000000000..bec0710c40
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitointegration;
+
+import static org.mockitoutil.ClassLoaders.coverageTool;
+
+import java.util.Set;
+
+import org.hamcrest.Matcher;
+import org.junit.*;
+import org.mockito.Mockito;
+import org.mockitoutil.ClassLoaders;
+
+public class NoByteCodeDependenciesTest {
+
+    @Test
+    public void pure_mockito_should_not_depend_bytecode_libraries() throws Exception {
+
+        ClassLoader classLoader_without_bytecode_libraries =
+                ClassLoaders.excludingClassLoader()
+                        .withCodeSourceUrlOf(Mockito.class, Matcher.class)
+                        .withCodeSourceUrlOf(coverageTool())
+                        .without("net.bytebuddy", "org.objenesis")
+                        .build();
+
+        Set<String> pureMockitoAPIClasses =
+                ClassLoaders.in(classLoader_without_bytecode_libraries)
+                        .omit("bytebuddy", "runners", "junit", "JUnit", "opentest4j")
+                        .listOwnedClasses();
+        pureMockitoAPIClasses.remove(
+                "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
+        pureMockitoAPIClasses.remove(
+                "org.mockito.internal.creation.instance.ObjenesisInstantiator");
+
+        // Remove classes that trigger plugin-loading, since bytebuddy plugins are the default.
+        pureMockitoAPIClasses.remove("org.mockito.internal.debugging.LocationImpl");
+        pureMockitoAPIClasses.remove("org.mockito.internal.exceptions.stacktrace.StackTraceFilter");
+        pureMockitoAPIClasses.remove("org.mockito.internal.util.MockUtil");
+
+        // Remove instrumentation-based member accessor which is optional.
+        pureMockitoAPIClasses.remove(
+                "org.mockito.internal.util.reflection.InstrumentationMemberAccessor");
+
+        // Remove modules-info class which declares these as static (optional)
+        pureMockitoAPIClasses.remove("module-info");
+
+        ClassLoadabilityChecker checker =
+                new ClassLoadabilityChecker(
+                        classLoader_without_bytecode_libraries, "ByteBuddy or Objenesis");
+        for (String pureMockitoAPIClass : pureMockitoAPIClasses) {
+            checker.checkLoadability(pureMockitoAPIClass);
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java b/mockito-core/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
new file mode 100644
index 0000000000..503d859617
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitointegration;
+
+import static org.mockitoutil.ClassLoaders.coverageTool;
+
+import java.util.Set;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.agent.ByteBuddyAgent;
+import org.hamcrest.Matcher;
+import org.junit.Assume;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockitoutil.ClassLoaders;
+import org.objenesis.Objenesis;
+
+public class NoJUnitDependenciesTest {
+
+    @Test
+    public void pure_mockito_should_not_depend_JUnit___ByteBuddy() throws Exception {
+        Assume.assumeTrue(
+                "ByteBuddyMockMaker".equals(Plugins.getMockMaker().getClass().getSimpleName()));
+
+        ClassLoader classLoader_without_JUnit =
+                ClassLoaders.excludingClassLoader()
+                        .withCodeSourceUrlOf(
+                                Mockito.class,
+                                Matcher.class,
+                                ByteBuddy.class,
+                                ByteBuddyAgent.class,
+                                Objenesis.class)
+                        .withCodeSourceUrlOf(coverageTool())
+                        .without("junit", "org.junit", "org.opentest4j")
+                        .build();
+
+        Set<String> pureMockitoAPIClasses =
+                ClassLoaders.in(classLoader_without_JUnit)
+                        .omit("runners", "junit", "JUnit", "opentest4j")
+                        .listOwnedClasses();
+
+        ClassLoadabilityChecker checker =
+                new ClassLoadabilityChecker(classLoader_without_JUnit, "JUnit");
+
+        // The later class is required to be initialized before any inline mock maker classes can be
+        // loaded.
+        checker.checkLoadability(
+                "org.mockito.internal.creation.bytebuddy.InlineDelegateByteBuddyMockMaker");
+        pureMockitoAPIClasses.remove(
+                "org.mockito.internal.creation.bytebuddy.InlineDelegateByteBuddyMockMaker");
+
+        for (String pureMockitoAPIClass : pureMockitoAPIClasses) {
+            checker.checkLoadability(pureMockitoAPIClass);
+        }
+    }
+}
diff --git a/src/test/java/org/mockitointegration/package-info.java b/mockito-core/src/test/java/org/mockitointegration/package-info.java
similarity index 100%
rename from src/test/java/org/mockitointegration/package-info.java
rename to mockito-core/src/test/java/org/mockitointegration/package-info.java
diff --git a/mockito-core/src/test/java/org/mockitousage/CompilationWarningsTest.java b/mockito-core/src/test/java/org/mockitousage/CompilationWarningsTest.java
new file mode 100644
index 0000000000..faf019f094
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/CompilationWarningsTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import static org.mockito.BDDMockito.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+public class CompilationWarningsTest {
+
+    @Before
+    public void pay_attention_to_compilation_warnings_and_JDK_version() {}
+
+    @Test
+    public void no_warnings_for_most_common_api() throws Exception {
+        doReturn(null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+        doReturn("a", 12).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+        doReturn(1000).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+        doThrow(new NullPointerException())
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        doThrow(new NullPointerException(), new IllegalArgumentException())
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        doThrow(NullPointerException.class)
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+
+        doAnswer(ignore()).doReturn(null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+        doAnswer(ignore())
+                .doReturn("a", 12)
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        doAnswer(ignore()).doReturn(1000).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+        doAnswer(ignore())
+                .doThrow(new NullPointerException())
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        doAnswer(ignore())
+                .doThrow(new NullPointerException(), new IllegalArgumentException())
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        doAnswer(ignore())
+                .doThrow(NullPointerException.class)
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+
+        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(null);
+        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn("a", 12L);
+        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(1000);
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .thenThrow(new NullPointerException());
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .thenThrow(new NullPointerException(), new IllegalArgumentException());
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .thenThrow(NullPointerException.class);
+
+        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(null);
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .then(ignore())
+                .thenReturn("a", 12L);
+        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(1000);
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .then(ignore())
+                .thenThrow(new NullPointerException());
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .then(ignore())
+                .thenThrow(new NullPointerException(), new IllegalArgumentException());
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .then(ignore())
+                .thenThrow(NullPointerException.class);
+
+        willReturn(null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+        willReturn("a", 12).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+        willReturn(1000).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+        willThrow(new NullPointerException())
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willThrow(new NullPointerException(), new IllegalArgumentException())
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willThrow(NullPointerException.class)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+
+        willAnswer(ignore())
+                .willReturn(null)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willAnswer(ignore())
+                .willReturn("a", 12)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willAnswer(ignore())
+                .willReturn(1000)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willAnswer(ignore())
+                .willThrow(new NullPointerException())
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willAnswer(ignore())
+                .willThrow(new NullPointerException(), new IllegalArgumentException())
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        willAnswer(ignore())
+                .willThrow(NullPointerException.class)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+
+        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(null);
+        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn("a", 12L);
+        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(1000);
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .willThrow(new NullPointerException());
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .willThrow(new NullPointerException(), new IllegalArgumentException());
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .willThrow(NullPointerException.class);
+
+        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(null);
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .will(ignore())
+                .willReturn("a", 12L);
+        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(1000);
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .will(ignore())
+                .willThrow(new NullPointerException());
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .will(ignore())
+                .willThrow(new NullPointerException(), new IllegalArgumentException());
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .will(ignore())
+                .willThrow(NullPointerException.class);
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void
+            heap_pollution_JDK7plus_warning_avoided_BUT_now_unchecked_generic_array_creation_warnings_ON_JDK5plus_environment()
+                    throws Exception {
+        doThrow(NullPointerException.class, IllegalArgumentException.class)
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .thenThrow(NullPointerException.class, IllegalArgumentException.class);
+        doAnswer(ignore())
+                .doThrow(NullPointerException.class, IllegalArgumentException.class)
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+
+        willThrow(NullPointerException.class, IllegalArgumentException.class)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .willThrow(NullPointerException.class, IllegalArgumentException.class);
+        willAnswer(ignore())
+                .willThrow(NullPointerException.class, IllegalArgumentException.class)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+    }
+
+    @Test
+    public void unchecked_confusing_null_argument_warnings() throws Exception {
+        doReturn(null, (Object[]) null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+        doAnswer(ignore())
+                .doReturn(null, (Object[]) null)
+                .when(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(null, (Object[]) null);
+        when(mock(IMethods.class).objectReturningMethodNoArgs())
+                .then(ignore())
+                .thenReturn(null, (Object[]) null);
+        willReturn(null, (Object[]) null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(null, (Object[]) null);
+        willAnswer(ignore())
+                .willReturn(null, (Object[]) null)
+                .given(mock(IMethods.class))
+                .objectReturningMethodNoArgs();
+        given(mock(IMethods.class).objectReturningMethodNoArgs())
+                .will(ignore())
+                .willReturn(null, (Object[]) null);
+    }
+
+    private static Answer<?> ignore() {
+        return new Answer<Object>() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                return null;
+            }
+        };
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/PlaygroundTest.java b/mockito-core/src/test/java/org/mockitousage/PlaygroundTest.java
new file mode 100644
index 0000000000..33c20368f0
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/PlaygroundTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
+public class PlaygroundTest extends TestBase {
+    static class Foo {
+
+        int doSomeThing() {
+            return 0;
+        }
+
+        protected String getStuff() {
+            return "foo";
+        }
+    }
+
+    class Boo {
+        public final Object withLong(long y) {
+            return "";
+        }
+
+        public Object foo() {
+            return "";
+        }
+    }
+
+    Foo mock;
+    @Mock IMethods mockTwo;
+
+    @Test
+    public void spyInAction() {}
+
+    @Test
+    public void partialMockInAction() {
+        //        mock = mock(Foo.class, withSettings()
+        //            .defaultBehavior(CALLS_REAL_METHODS);
+
+        //        mock = mock(Foo.class, withSettings()
+        //            .defaultMockAnswer(CALLS_REAL_METHODS);
+
+        //        mock = mock(Foo.class, withSettings()
+        //            .defaultAnswer(CALLS_REAL_METHODS);
+
+        //        mock = mock(Foo.class, CALLS_REAL_METHODS);
+
+        //        mock = mock(Foo.class, withSettings()
+        //            .defaultBehavior(CALLS_REAL_METHODS)
+        //            .createUsingDefaultConstructor();
+        //
+        //        mock = mock(Foo.class, withSettings()
+        //            .defaultBehavior(CALLS_REAL_METHODS)
+        //            .createPassingArguments("some arg", 1);
+        //
+        //        spy = spy(Foo.class, "some arg", 1);
+        //
+        //            .withName("foo")
+        //            .withDefaultBehavior(RETURNS_SMART_NULLS)
+        //            .withInterfaces(Bar.class);
+        //
+        //        mock = mock(Foo.class)
+        //            .name("foo")
+        //            .defaultBehavior(RETURNS_SMART_NULLS)
+        //            .interfaces(Bar.class);
+        //
+        //        mock = mock(Foo.class)
+        //            .named("foo")
+        //            .byDefault(RETURNS_SMART_NULLS)
+        //            .alsoImplements(Bar.class, Bar2.class);
+        //
+        //        mock = mock(Foo.class)
+        //            hasName("foo");
+
+        //        when(mock.getStuff()).thenReturn("aha!");
+        //        when(mock.doSomeThing()).thenCallRealMethod();
+        //
+
+        //        mock.doSomeThing();
+    }
+
+    //    interface Colored {
+    //
+    //    }
+    //
+    //    interface Bar {
+    //        <T extends Foo & Colored> T getColoredPoint();
+    //    }
+    //
+    //    @Test
+    //    public void testname() throws Exception {
+    //        when(mock.get()).then(returnArgument());
+    //
+    //        Bar mock = mock(Bar.class);
+    //        when(mock.getColoredPoint()).thenReturn(new Foo());
+    //    }
+}
diff --git a/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java b/mockito-core/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
similarity index 81%
rename from src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
rename to mockito-core/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
index 0bece8c10c..3ff4379f20 100644
--- a/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
@@ -7,7 +7,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.BDDMockito.willAnswer;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.verify;
 
 import java.util.Date;
@@ -35,46 +35,52 @@ public void setUp() throws Exception {
 
     @Test
     public void shouldIncludeInitialLog() {
-        //given
+        // given
         int importType = 0;
         Date currentDate = new GregorianCalendar(2009, 10, 12).getTime();
 
         ImportLogBean initialLog = new ImportLogBean(currentDate, importType);
         initialLog.setStatus(1);
 
-        given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate)).willReturn(false);
-        willAnswer(byCheckingLogEquals(initialLog)).given(importLogDao).include(any(ImportLogBean.class));
+        given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate))
+                .willReturn(false);
+        willAnswer(byCheckingLogEquals(initialLog))
+                .given(importLogDao)
+                .include(any(ImportLogBean.class));
 
-        //when
+        // when
         importManager.startImportProcess(importType, currentDate);
 
-        //then
+        // then
         verify(importLogDao).include(any(ImportLogBean.class));
     }
 
     @Test
     public void shouldAlterFinalLog() {
-        //given
+        // given
         int importType = 0;
         Date currentDate = new GregorianCalendar(2009, 10, 12).getTime();
 
         ImportLogBean finalLog = new ImportLogBean(currentDate, importType);
         finalLog.setStatus(9);
 
-        given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate)).willReturn(false);
-        willAnswer(byCheckingLogEquals(finalLog)).given(importLogDao).alter(any(ImportLogBean.class));
+        given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate))
+                .willReturn(false);
+        willAnswer(byCheckingLogEquals(finalLog))
+                .given(importLogDao)
+                .alter(any(ImportLogBean.class));
 
-        //when
+        // when
         importManager.startImportProcess(importType, currentDate);
 
-        //then
+        // then
         verify(importLogDao).alter(any(ImportLogBean.class));
     }
 
     private Answer<Object> byCheckingLogEquals(final ImportLogBean status) {
         return new Answer<Object>() {
             public Object answer(InvocationOnMock invocation) throws Throwable {
-                ImportLogBean bean =  invocation.getArgument(0);
+                ImportLogBean bean = invocation.getArgument(0);
                 assertEquals(status, bean);
                 return null;
             }
@@ -97,7 +103,8 @@ public void startImportProcess(int importType, Date date) {
                 importLogBean = createResume(importType, date);
                 if (isOkToImport(importType, date)) {
                     // get the right handler
-                    //importLogBean = ImportHandlerFactory.singleton().getImportHandler(importType).processImport(importLogBean);
+                    // importLogBean =
+                    // ImportHandlerFactory.singleton().getImportHandler(importType).processImport(importLogBean);
                     // 2 = ok
                     importLogBean.setStatus(2);
                 } else {
@@ -106,11 +113,9 @@ public void startImportProcess(int importType, Date date) {
                 }
             } catch (Exception e) {
                 // 9 = failed - exception
-                if (importLogBean != null)
-                    importLogBean.setStatus(9);
+                if (importLogBean != null) importLogBean.setStatus(9);
             } finally {
-                if (importLogBean != null)
-                    finalizeResume(importLogBean);
+                if (importLogBean != null) finalizeResume(importLogBean);
             }
         }
 
@@ -119,8 +124,7 @@ private boolean isOkToImport(int importType, Date date) {
         }
 
         private ImportLogBean createResume(int importType, Date date) {
-            ImportLogBean importLogBean = new ImportLogBean(date,
-                    importType);
+            ImportLogBean importLogBean = new ImportLogBean(date, importType);
             // 1 = running
             importLogBean.setStatus(1);
             importLogDao.include(importLogBean);
@@ -140,8 +144,7 @@ private interface ImportLogDao {
         void alter(ImportLogBean importLogBean);
     }
 
-    private class IImportHandler {
-    }
+    private class IImportHandler {}
 
     private class ImportLogBean {
         private Date currentDate;
@@ -166,7 +169,9 @@ public boolean equals(Object o) {
 
             if (importType != that.importType) return false;
             if (status != that.status) return false;
-            if (currentDate != null ? !currentDate.equals(that.currentDate) : that.currentDate != null) return false;
+            if (currentDate != null
+                    ? !currentDate.equals(that.currentDate)
+                    : that.currentDate != null) return false;
 
             return true;
         }
diff --git a/src/test/java/org/mockitousage/annotation/AnnotationsTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
similarity index 78%
rename from src/test/java/org/mockitousage/annotation/AnnotationsTest.java
rename to mockito-core/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
index 59785b90d4..939888a73d 100644
--- a/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
@@ -38,7 +38,7 @@ public class AnnotationsTest extends TestBase {
 
     @Before
     public void setup() {
-        MockitoAnnotations.initMocks(this);
+        MockitoAnnotations.openMocks(this);
     }
 
     @Test
@@ -55,10 +55,11 @@ public void shouldInitMocks() throws Exception {
     @Test
     public void shouldScreamWhenInitializingMocksForNullClass() throws Exception {
         try {
-            MockitoAnnotations.initMocks(null);
+            MockitoAnnotations.openMocks(null);
             fail();
         } catch (MockitoException e) {
-            assertEquals("testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class",
+            assertEquals(
+                    "testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class",
                     e.getMessage());
         }
     }
@@ -66,18 +67,29 @@ public void shouldScreamWhenInitializingMocksForNullClass() throws Exception {
     @Test
     public void shouldLookForAnnotatedMocksInSuperClasses() throws Exception {
         Sub sub = new Sub();
-        MockitoAnnotations.initMocks(sub);
+        MockitoAnnotations.openMocks(sub);
 
         assertNotNull(sub.getMock());
         assertNotNull(sub.getBaseMock());
         assertNotNull(sub.getSuperBaseMock());
     }
 
-    @Mock(answer = Answers.RETURNS_MOCKS, name = "i have a name") IMethods namedAndReturningMocks;
-    @Mock(answer = Answers.RETURNS_DEFAULTS) IMethods returningDefaults;
-    @Mock(extraInterfaces = {List.class}) IMethods hasExtraInterfaces;
+    @Mock(answer = Answers.RETURNS_MOCKS, name = "i have a name")
+    IMethods namedAndReturningMocks;
+
+    @Mock(answer = Answers.RETURNS_DEFAULTS)
+    IMethods returningDefaults;
+
+    @Mock(extraInterfaces = {List.class})
+    IMethods hasExtraInterfaces;
+
     @Mock() IMethods noExtraConfig;
-    @Mock(stubOnly=true) IMethods stubOnly;
+
+    @Mock(stubOnly = true)
+    IMethods stubOnly;
+
+    @Mock(withoutAnnotations = true)
+    IMethods withoutAnnotations;
 
     @Test
     public void shouldInitMocksWithGivenSettings() throws Exception {
@@ -90,6 +102,11 @@ public void shouldInitMocksWithGivenSettings() throws Exception {
         assertTrue(hasExtraInterfaces instanceof List);
         assertTrue(Mockito.mockingDetails(stubOnly).getMockCreationSettings().isStubOnly());
 
+        assertTrue(
+                Mockito.mockingDetails(withoutAnnotations)
+                        .getMockCreationSettings()
+                        .isStripAnnotations());
+
         assertEquals(0, noExtraConfig.intReturningMethod());
     }
 
diff --git a/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
rename to mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
index 6d3799fb0d..6f8dc66e59 100644
--- a/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
@@ -51,10 +51,10 @@ private void createPerson(String name, String surname) {
 
     @Test
     public void shouldUseCaptorInOrdinaryWay() {
-        //when
+        // when
         createPerson("Wes", "Williams");
 
-        //then
+        // then
         ArgumentCaptor<Person> captor = ArgumentCaptor.forClass(Person.class);
         verify(peopleRepository).save(captor.capture());
         assertEquals("Wes", captor.getValue().getName());
@@ -65,24 +65,25 @@ public void shouldUseCaptorInOrdinaryWay() {
 
     @Test
     public void shouldUseAnnotatedCaptor() {
-        //when
+        // when
         createPerson("Wes", "Williams");
 
-        //then
+        // then
         verify(peopleRepository).save(captor.capture());
         assertEquals("Wes", captor.getValue().getName());
         assertEquals("Williams", captor.getValue().getSurname());
     }
 
     @SuppressWarnings("rawtypes")
-    @Captor ArgumentCaptor genericLessCaptor;
+    @Captor
+    ArgumentCaptor genericLessCaptor;
 
     @Test
     public void shouldUseGenericlessAnnotatedCaptor() {
-        //when
+        // when
         createPerson("Wes", "Williams");
 
-        //then
+        // then
         verify(peopleRepository).save((Person) genericLessCaptor.capture());
         assertEquals("Wes", ((Person) genericLessCaptor.getValue()).getName());
         assertEquals("Williams", ((Person) genericLessCaptor.getValue()).getSurname());
@@ -93,14 +94,14 @@ public void shouldUseGenericlessAnnotatedCaptor() {
 
     @Test
     public void shouldCaptureGenericList() {
-        //given
+        // given
         List<String> list = new LinkedList<String>();
         mock.listArgMethod(list);
 
-        //when
+        // when
         verify(mock).listArgMethod(genericListCaptor.capture());
 
-        //then
+        // then
         assertSame(list, genericListCaptor.getValue());
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
new file mode 100644
index 0000000000..f015f1b358
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.*;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class CaptorAnnotationTest extends TestBase {
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface NotAMock {}
+
+    @Captor final ArgumentCaptor<String> finalCaptor = ArgumentCaptor.forClass(String.class);
+
+    @Captor ArgumentCaptor<List<List<String>>> genericsCaptor;
+
+    @SuppressWarnings("rawtypes")
+    @Captor
+    ArgumentCaptor nonGenericCaptorIsAllowed;
+
+    @Mock MockInterface mockInterface;
+
+    @NotAMock Set<?> notAMock;
+
+    public interface MockInterface {
+        void testMe(String simple, List<List<String>> genericList);
+    }
+
+    @Test
+    public void testNormalUsage() {
+
+        MockitoAnnotations.openMocks(this);
+
+        // check if assigned correctly
+        assertNotNull(finalCaptor);
+        assertNotNull(genericsCaptor);
+        assertNotNull(nonGenericCaptorIsAllowed);
+        assertNull(notAMock);
+
+        // use captors in the field to be sure they are cool
+        String argForFinalCaptor = "Hello";
+        ArrayList<List<String>> argForGenericsCaptor = new ArrayList<List<String>>();
+
+        mockInterface.testMe(argForFinalCaptor, argForGenericsCaptor);
+
+        Mockito.verify(mockInterface).testMe(finalCaptor.capture(), genericsCaptor.capture());
+
+        assertEquals(argForFinalCaptor, finalCaptor.getValue());
+        assertEquals(argForGenericsCaptor, genericsCaptor.getValue());
+    }
+
+    public static class WrongType {
+        @Captor List<?> wrongType;
+    }
+
+    @Test
+    public void shouldScreamWhenWrongTypeForCaptor() {
+        try {
+            MockitoAnnotations.openMocks(new WrongType());
+            fail();
+        } catch (MockitoException e) {
+        }
+    }
+
+    public static class ToManyAnnotations {
+        @Captor @Mock ArgumentCaptor<List> missingGenericsField;
+    }
+
+    @Test
+    public void shouldScreamWhenMoreThanOneMockitoAnnotation() {
+        try {
+            MockitoAnnotations.openMocks(new ToManyAnnotations());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e)
+                    .hasMessageContaining("missingGenericsField")
+                    .hasMessageContaining("multiple Mockito annotations");
+        }
+    }
+
+    @Test
+    public void shouldScreamWhenInitializingCaptorsForNullClass() throws Exception {
+        try {
+            MockitoAnnotations.openMocks(null);
+            fail();
+        } catch (MockitoException e) {
+        }
+    }
+
+    @Test
+    public void shouldLookForAnnotatedCaptorsInSuperClasses() throws Exception {
+        Sub sub = new Sub();
+        MockitoAnnotations.openMocks(sub);
+
+        assertNotNull(sub.getCaptor());
+        assertNotNull(sub.getBaseCaptor());
+        assertNotNull(sub.getSuperBaseCaptor());
+    }
+
+    class SuperBase {
+        @Captor private ArgumentCaptor<IMethods> mock;
+
+        public ArgumentCaptor<IMethods> getSuperBaseCaptor() {
+            return mock;
+        }
+    }
+
+    class Base extends SuperBase {
+        @Captor private ArgumentCaptor<IMethods> mock;
+
+        public ArgumentCaptor<IMethods> getBaseCaptor() {
+            return mock;
+        }
+    }
+
+    class Sub extends Base {
+        @Captor private ArgumentCaptor<IMethods> mock;
+
+        public ArgumentCaptor<IMethods> getCaptor() {
+            return mock;
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
similarity index 75%
rename from src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
rename to mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
index 15e9f6c18a..f49de96cb9 100644
--- a/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
@@ -23,20 +23,20 @@ public class CaptorAnnotationUnhappyPathTest extends TestBase {
     @Before
     @Override
     public void init() {
-        //we need to get rid of parent implementation this time
+        // we need to get rid of parent implementation this time
     }
 
     @Test
     public void shouldFailIfCaptorHasWrongType() throws Exception {
         try {
-            //when
-            MockitoAnnotations.initMocks(this);
+            // when
+            MockitoAnnotations.openMocks(this);
             fail();
         } catch (MockitoException e) {
-            //then
+            // then
             assertThat(e)
-                .hasMessageContaining("notACaptorField")
-                .hasMessageContaining("wrong type");
+                    .hasMessageContaining("notACaptorField")
+                    .hasMessageContaining("wrong type");
         }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/DoNotMockTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/DoNotMockTest.java
new file mode 100644
index 0000000000..14fe814d92
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/DoNotMockTest.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+
+import org.junit.Test;
+import org.mockito.DoNotMock;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.MockitoAnnotations;
+import org.mockito.exceptions.misusing.DoNotMockException;
+
+public class DoNotMockTest {
+
+    @Test
+    public void can_not_mock_class_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            NotMockable notMockable = mock(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_statically_mock_class_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockable> notMockable = mockStatic(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_mock_class_via_mock_annotation() {
+        assertThatThrownBy(
+                        () -> {
+                            MockitoAnnotations.openMocks(new TestClass());
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_mock_class_with_interface_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            SubclassOfNotMockableInterface notMockable =
+                                    mock(SubclassOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_statically_mock_class_with_interface_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfNotMockableInterface> notMockable =
+                                    mockStatic(SubclassOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_mock_subclass_with_unmockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            DoubleSubclassOfInterface notMockable =
+                                    mock(DoubleSubclassOfInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_statically_mock_subclass_with_unmockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<DoubleSubclassOfInterface> notMockable =
+                                    mockStatic(DoubleSubclassOfInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_mock_subclass_with_unmockable_superclass() {
+        assertThatThrownBy(
+                        () -> {
+                            SubclassOfNotMockableSuperclass notMockable =
+                                    mock(SubclassOfNotMockableSuperclass.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_statically_mock_subclass_with_unmockable_superclass() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfNotMockableSuperclass> notMockable =
+                                    mockStatic(SubclassOfNotMockableSuperclass.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void
+            can_not_mock_subclass_with_unmockable_interface_that_extends_non_mockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            SubclassOfSubInterfaceOfNotMockableInterface notMockable =
+                                    mock(SubclassOfSubInterfaceOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void
+            can_not_statically_mock_subclass_with_unmockable_interface_that_extends_non_mockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfSubInterfaceOfNotMockableInterface> notMockable =
+                                    mockStatic(SubclassOfSubInterfaceOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void thrown_exception_includes_non_mockable_reason() {
+        assertThatThrownBy(
+                        () -> {
+                            NotMockable notMockable = mock(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("Create a real instance instead");
+    }
+
+    @Test
+    public void thrown_exception_includes_special_non_mockable_reason() {
+        assertThatThrownBy(
+                        () -> {
+                            NotMockableWithReason notMockable = mock(NotMockableWithReason.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("Special reason");
+    }
+
+    @Test
+    public void thrown_exception_includes_special_non_mockable_reason_static() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockableWithReason> notMockable =
+                                    mockStatic(NotMockableWithReason.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("Special reason");
+    }
+
+    @Test
+    public void can_not_mock_class_with_custom_donotmock_annotation() {
+        assertThatThrownBy(
+                        () -> {
+                            NotMockableWithDifferentAnnotation notMockable =
+                                    mock(NotMockableWithDifferentAnnotation.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void can_not_statically_mock_class_with_custom_donotmock_annotation() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockableWithDifferentAnnotation> notMockable =
+                                    mockStatic(NotMockableWithDifferentAnnotation.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @DoNotMock
+    private static class NotMockable {}
+
+    @DoNotMock
+    private interface NotMockableInterface {}
+
+    @org.mockitousage.annotation.org.mockito.DoNotMock
+    private static class NotMockableWithDifferentAnnotation {}
+
+    @DoNotMock(reason = "Special reason")
+    private interface NotMockableWithReason {}
+
+    static class SubclassOfNotMockableInterface implements NotMockableInterface {}
+
+    private static class DoubleSubclassOfInterface extends SubclassOfNotMockableInterface {}
+
+    private static class SubclassOfNotMockableSuperclass extends NotMockable {}
+
+    private interface SubInterfaceOfNotMockableInterface extends NotMockableInterface {}
+
+    private static class SubclassOfSubInterfaceOfNotMockableInterface
+            implements SubInterfaceOfNotMockableInterface {}
+
+    private static class TestClass {
+        @Mock private NotMockable notMockable;
+    }
+}
diff --git a/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
rename to mockito-core/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
index ef5e3d5487..defb88a93a 100644
--- a/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
@@ -44,7 +44,6 @@ public void named_mocks_should_be_resolved_with_their_name() throws Exception {
         assertSame(antenna, receiver.dvbtAntenna);
     }
 
-
     @Test
     public void inject_mocks_even_in_declared_spy() throws Exception {
         assertNotNull(spiedReceiver.oldAntenna);
@@ -58,10 +57,12 @@ static class Receiver {
         Antenna dvbtAntenna;
         Tuner tuner;
 
-        public boolean tune() { return true; }
+        public boolean tune() {
+            return true;
+        }
     }
 
-    private static class Antenna { }
-    private static class Tuner { }
+    private static class Antenna {}
 
+    private static class Tuner {}
 }
diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java b/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
similarity index 91%
rename from src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
rename to mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
index b2a222057e..0e5c67f02c 100644
--- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
@@ -30,16 +30,14 @@ static class Issue421 {
 
         private ArticleCalculator calculator;
 
-        public Issue421(int a) {
-        }
+        public Issue421(int a) {}
 
         public Issue421(ArticleCalculator calculator) {
             this.calculator = calculator;
         }
 
-        public void checkIfMockIsInjected(){
+        public void checkIfMockIsInjected() {
             assertThat(MockUtil.isMock(calculator)).isTrue();
         }
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
new file mode 100644
index 0000000000..c45c90ae2f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.openMocks;
+
+import java.util.AbstractCollection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.internal.TextListener;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+import org.mockitousage.examples.use.ArticleCalculator;
+import org.mockitousage.examples.use.ArticleDatabase;
+import org.mockitousage.examples.use.ArticleManager;
+
+public class MockInjectionUsingConstructorTest {
+
+    @Mock private ArticleCalculator calculator;
+    @Mock private ArticleDatabase database;
+
+    @InjectMocks private ArticleManager articleManager;
+    @Spy @InjectMocks private ArticleManager spiedArticleManager;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    public void shouldNotFailWhenNotInitialized() {
+        assertNotNull(articleManager);
+    }
+
+    @Test
+    public void innerMockShouldRaiseAnExceptionThatChangesOuterMockBehavior() {
+        when(calculator.countArticles("new")).thenThrow(new IllegalArgumentException());
+
+        assertThatThrownBy(
+                        () -> {
+                            articleManager.updateArticleCounters("new");
+                        })
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void mockJustWorks() {
+        articleManager.updateArticleCounters("new");
+    }
+
+    @Test
+    public void constructor_is_called_for_each_test_in_test_class() throws Exception {
+        // given
+        junit_test_with_3_tests_methods.constructor_instantiation = 0;
+        JUnitCore jUnitCore = new JUnitCore();
+        jUnitCore.addListener(new TextListener(System.out));
+
+        // when
+        jUnitCore.run(junit_test_with_3_tests_methods.class);
+
+        // then
+        assertThat(junit_test_with_3_tests_methods.constructor_instantiation).isEqualTo(3);
+    }
+
+    @Test
+    public void objects_created_with_constructor_initialization_can_be_spied() throws Exception {
+        assertFalse(MockUtil.isMock(articleManager));
+        assertTrue(MockUtil.isMock(spiedArticleManager));
+    }
+
+    @Test
+    public void should_report_failure_only_when_object_initialization_throws_exception()
+            throws Exception {
+
+        try {
+            MockitoAnnotations.openMocks(new ATest());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage())
+                    .contains("failingConstructor")
+                    .contains("constructor")
+                    .contains("threw an exception");
+            assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class junit_test_with_3_tests_methods {
+        private static int constructor_instantiation = 0;
+
+        @Mock List<?> some_collaborator;
+        @InjectMocks some_class_with_parametered_constructor should_be_initialized_3_times;
+
+        @Test
+        public void test_1() {}
+
+        @Test
+        public void test_2() {}
+
+        @Test
+        public void test_3() {}
+
+        private static class some_class_with_parametered_constructor {
+            public some_class_with_parametered_constructor(List<?> collaborator) {
+                constructor_instantiation++;
+            }
+        }
+    }
+
+    private static class FailingConstructor {
+        FailingConstructor(Set<?> set) {
+            throw new IllegalStateException("always fail");
+        }
+    }
+
+    @Ignore("don't run this code in the test runner")
+    private static class ATest {
+        @Mock Set<?> set;
+        @InjectMocks FailingConstructor failingConstructor;
+    }
+
+    @Test
+    public void injectMocksMustFailWithInterface() {
+        class TestCase {
+            @InjectMocks IMethods f;
+        }
+
+        assertThatThrownBy(
+                        () -> {
+                            openMocks(new TestCase());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'IMethods' is an interface");
+    }
+
+    @Test
+    public void injectMocksMustFailWithEnum() throws Exception {
+        class TestCase {
+            @InjectMocks TimeUnit f;
+        }
+
+        assertThatThrownBy(
+                        () -> {
+                            openMocks(new TestCase());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'TimeUnit' is an enum");
+    }
+
+    @Test
+    public void injectMocksMustFailWithAbstractClass() {
+        class TestCase {
+            @InjectMocks AbstractCollection<?> f;
+        }
+
+        assertThatThrownBy(
+                        () -> {
+                            openMocks(new TestCase());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'AbstractCollection' is an abstract class");
+    }
+
+    @Test
+    public void injectMocksMustFailWithNonStaticInnerClass() {
+        class TestCase {
+            class InnerClass {}
+
+            @InjectMocks InnerClass f;
+        }
+
+        assertThatThrownBy(
+                        () -> {
+                            openMocks(new TestCase());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'InnerClass' is an inner non static class");
+    }
+
+    static class StaticInnerClass {}
+
+    @Test
+    public void injectMocksMustSucceedWithStaticInnerClass() {
+        class TestCase {
+            @InjectMocks StaticInnerClass f;
+        }
+
+        TestCase testClass = new TestCase();
+        openMocks(testClass);
+
+        assertThat(testClass.f).isInstanceOf(StaticInnerClass.class);
+    }
+
+    @Test
+    public void injectMocksMustSucceedWithInstance() {
+        class TestCase {
+            @InjectMocks StaticInnerClass f = new StaticInnerClass();
+        }
+
+        TestCase testClass = new TestCase();
+        StaticInnerClass original = testClass.f;
+        openMocks(testClass);
+
+        assertThat(testClass.f).isSameAs(original);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
new file mode 100644
index 0000000000..0d2af98d67
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.junit.Assert.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.assertj.core.api.Assertions;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.MockUtil;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings({"unchecked", "unused"})
+public class MockInjectionUsingSetterOrPropertyTest extends TestBase {
+
+    private SuperUnderTesting superUnderTestWithoutInjection = new SuperUnderTesting();
+    @InjectMocks private SuperUnderTesting superUnderTest = new SuperUnderTesting();
+    @InjectMocks private BaseUnderTesting baseUnderTest = new BaseUnderTesting();
+    @InjectMocks private SubUnderTesting subUnderTest = new SubUnderTesting();
+    @InjectMocks private OtherBaseUnderTesting otherBaseUnderTest = new OtherBaseUnderTesting();
+
+    @InjectMocks
+    private HasTwoFieldsWithSameType hasTwoFieldsWithSameType = new HasTwoFieldsWithSameType();
+
+    private BaseUnderTesting baseUnderTestingInstance = new BaseUnderTesting();
+    @InjectMocks private BaseUnderTesting initializedBase = baseUnderTestingInstance;
+    @InjectMocks private BaseUnderTesting notInitializedBase;
+
+    @Spy @InjectMocks private SuperUnderTesting initializedSpy = new SuperUnderTesting();
+    @Spy @InjectMocks private SuperUnderTesting notInitializedSpy;
+
+    @Mock private Map<?, ?> map;
+    @Mock private List<?> list;
+    @Mock private Set<?> histogram1;
+    @Mock private Set<?> histogram2;
+    @Mock private IMethods candidate2;
+
+    @Spy private TreeSet<String> searchTree = new TreeSet<String>();
+
+    private AutoCloseable session;
+
+    @Before
+    public void enforces_new_instances() {
+        // openMocks called in TestBase Before method, so instances are not the same
+        session = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void close_new_instances() throws Exception {
+        if (session != null) {
+            session.close();
+        }
+    }
+
+    @Test
+    public void should_keep_same_instance_if_field_initialized() {
+        assertSame(baseUnderTestingInstance, initializedBase);
+    }
+
+    @Test
+    public void should_initialize_annotated_field_if_null() {
+        assertNotNull(notInitializedBase);
+    }
+
+    @Test
+    public void should_inject_mocks_in_spy() {
+        assertNotNull(initializedSpy.getAList());
+        assertTrue(MockUtil.isMock(initializedSpy));
+    }
+
+    @Test
+    public void should_initialize_spy_if_null_and_inject_mocks() {
+        assertNotNull(notInitializedSpy);
+        assertNotNull(notInitializedSpy.getAList());
+        assertTrue(MockUtil.isMock(notInitializedSpy));
+    }
+
+    @Test
+    public void should_inject_mocks_if_annotated() {
+        MockitoAnnotations.openMocks(this);
+        assertSame(list, superUnderTest.getAList());
+    }
+
+    @Test
+    public void should_not_inject_if_not_annotated() {
+        MockitoAnnotations.openMocks(this);
+        assertNull(superUnderTestWithoutInjection.getAList());
+    }
+
+    @Test
+    public void should_inject_mocks_for_class_hierarchy_if_annotated() {
+        MockitoAnnotations.openMocks(this);
+        assertSame(list, baseUnderTest.getAList());
+        assertSame(map, baseUnderTest.getAMap());
+    }
+
+    @Test
+    public void should_inject_mocks_by_name() {
+        MockitoAnnotations.openMocks(this);
+        assertSame(histogram1, subUnderTest.getHistogram1());
+        assertSame(histogram2, subUnderTest.getHistogram2());
+    }
+
+    @Test
+    public void should_inject_spies() {
+        MockitoAnnotations.openMocks(this);
+        assertSame(searchTree, otherBaseUnderTest.getSearchTree());
+    }
+
+    @Test
+    public void
+            should_insert_into_field_with_matching_name_when_multiple_fields_of_same_type_exists_in_injectee() {
+        MockitoAnnotations.openMocks(this);
+        assertNull("not injected, no mock named 'candidate1'", hasTwoFieldsWithSameType.candidate1);
+        assertNotNull(
+                "injected, there's a mock named 'candidate2'", hasTwoFieldsWithSameType.candidate2);
+    }
+
+    @Test
+    public void should_instantiate_inject_mock_field_if_possible() throws Exception {
+        assertNotNull(notInitializedBase);
+    }
+
+    @Test
+    public void should_keep_instance_on_inject_mock_field_if_present() throws Exception {
+        assertSame(baseUnderTestingInstance, initializedBase);
+    }
+
+    @Test
+    public void should_report_nicely() throws Exception {
+        Object failing =
+                new Object() {
+                    @InjectMocks ThrowingConstructor failingConstructor;
+                };
+        try {
+            MockitoAnnotations.openMocks(failing);
+            fail();
+        } catch (MockitoException e) {
+            Assertions.assertThat(e.getMessage())
+                    .contains("failingConstructor")
+                    .contains("constructor")
+                    .contains("threw an exception");
+            Assertions.assertThat(e.getCause()).isInstanceOf(RuntimeException.class);
+        }
+    }
+
+    static class ThrowingConstructor {
+        ThrowingConstructor() {
+            throw new RuntimeException("aha");
+        }
+    }
+
+    static class SuperUnderTesting {
+        private List<?> aList;
+
+        public List<?> getAList() {
+            return aList;
+        }
+    }
+
+    static class BaseUnderTesting extends SuperUnderTesting {
+        private Map<?, ?> aMap;
+
+        public Map<?, ?> getAMap() {
+            return aMap;
+        }
+    }
+
+    static class OtherBaseUnderTesting extends SuperUnderTesting {
+        private TreeSet<?> searchTree;
+
+        public TreeSet<?> getSearchTree() {
+            return searchTree;
+        }
+    }
+
+    static class SubUnderTesting extends BaseUnderTesting {
+        private Set<?> histogram1;
+        private Set<?> histogram2;
+
+        public Set<?> getHistogram1() {
+            return histogram1;
+        }
+
+        public Set<?> getHistogram2() {
+            return histogram2;
+        }
+    }
+
+    static class HasTwoFieldsWithSameType {
+        private IMethods candidate1;
+        private IMethods candidate2;
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
new file mode 100644
index 0000000000..60f87913bf
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.internal.util.MockUtil.isMock;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.internal.util.MockUtil;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class SpyAnnotationInitializedInBaseClassTest extends TestBase {
+
+    class BaseClass {
+
+        @Spy List list = new LinkedList();
+    }
+
+    class SubClass extends BaseClass {}
+
+    @Test
+    public void shouldInitSpiesInBaseClass() throws Exception {
+        // given
+        SubClass subClass = new SubClass();
+        // when
+        MockitoAnnotations.openMocks(subClass);
+        // then
+        assertTrue(MockUtil.isMock(subClass.list));
+    }
+
+    @Before
+    @Override
+    public void init() {
+        // we need to get rid of parent implementation this time
+    }
+
+    @Before
+    public void before() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Spy List spyInBaseclass = new LinkedList();
+
+    public static class SubTest extends SpyAnnotationInitializedInBaseClassTest {
+
+        @Spy List spyInSubclass = new LinkedList();
+
+        @Test
+        public void shouldInitSpiesInHierarchy() throws Exception {
+            assertTrue(isMock(spyInSubclass));
+            assertTrue(isMock(spyInBaseclass));
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
new file mode 100644
index 0000000000..daa71bed33
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Assume;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.InlineMockMaker;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unused")
+public class SpyAnnotationTest extends TestBase {
+
+    @Spy final List<String> spiedList = new ArrayList<String>();
+
+    @Spy InnerStaticClassWithNoArgConstructor staticTypeWithNoArgConstructor;
+
+    @Spy InnerStaticClassWithoutDefinedConstructor staticTypeWithoutDefinedConstructor;
+
+    @Spy MockTranslator translator;
+
+    @Rule public final ExpectedException shouldThrow = ExpectedException.none();
+
+    @Test
+    public void should_init_spy_by_instance() throws Exception {
+        doReturn("foo").when(spiedList).get(10);
+        assertEquals("foo", spiedList.get(10));
+        assertTrue(spiedList.isEmpty());
+    }
+
+    @Test
+    public void should_init_spy_and_automatically_create_instance() throws Exception {
+        when(staticTypeWithNoArgConstructor.toString()).thenReturn("x");
+        when(staticTypeWithoutDefinedConstructor.toString()).thenReturn("y");
+        assertEquals("x", staticTypeWithNoArgConstructor.toString());
+        assertEquals("y", staticTypeWithoutDefinedConstructor.toString());
+    }
+
+    @Test
+    public void should_allow_spying_on_interfaces() throws Exception {
+        class WithSpy {
+            @Spy List<String> list;
+        }
+
+        WithSpy withSpy = new WithSpy();
+        MockitoAnnotations.openMocks(withSpy);
+        when(withSpy.list.size()).thenReturn(3);
+        assertEquals(3, withSpy.list.size());
+    }
+
+    @Test
+    public void should_allow_spying_on_interfaces_when_instance_is_concrete() throws Exception {
+        class WithSpy {
+            @Spy List<String> list = new LinkedList<String>();
+        }
+        WithSpy withSpy = new WithSpy();
+
+        // when
+        MockitoAnnotations.openMocks(withSpy);
+
+        // then
+        verify(withSpy.list, never()).clear();
+    }
+
+    @Test
+    public void should_report_when_no_arg_less_constructor() throws Exception {
+        class FailingSpy {
+            @Spy NoValidConstructor noValidConstructor;
+        }
+
+        try {
+            MockitoAnnotations.openMocks(new FailingSpy());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage())
+                    .contains("Please ensure that the type")
+                    .contains(NoValidConstructor.class.getSimpleName())
+                    .contains("has a no-arg constructor");
+        }
+    }
+
+    @Test
+    public void should_report_when_constructor_is_explosive() throws Exception {
+        class FailingSpy {
+            @Spy ThrowingConstructor throwingConstructor;
+        }
+
+        try {
+            MockitoAnnotations.openMocks(new FailingSpy());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e.getMessage()).contains("Unable to create mock instance");
+        }
+    }
+
+    @Test
+    public void should_spy_abstract_class() throws Exception {
+        class SpyAbstractClass {
+            @Spy AbstractList<String> list;
+
+            List<String> asSingletonList(String s) {
+                when(list.size()).thenReturn(1);
+                when(list.get(0)).thenReturn(s);
+                return list;
+            }
+        }
+        SpyAbstractClass withSpy = new SpyAbstractClass();
+        MockitoAnnotations.openMocks(withSpy);
+        assertEquals(Arrays.asList("a"), withSpy.asSingletonList("a"));
+    }
+
+    @Test
+    public void should_spy_inner_class() throws Exception {
+
+        class WithMockAndSpy {
+            @Spy private InnerStrength strength;
+            @Mock private List<String> list;
+
+            abstract class InnerStrength {
+                private final String name;
+
+                InnerStrength() {
+                    // Make sure that @Mock fields are always injected before @Spy fields.
+                    assertNotNull(list);
+                    // Make sure constructor is indeed called.
+                    this.name = "inner";
+                }
+
+                abstract String strength();
+
+                String fullStrength() {
+                    return name + " " + strength();
+                }
+            }
+        }
+        WithMockAndSpy outer = new WithMockAndSpy();
+        MockitoAnnotations.openMocks(outer);
+        when(outer.strength.strength()).thenReturn("strength");
+        assertEquals("inner strength", outer.strength.fullStrength());
+    }
+
+    @Test
+    public void should_reset_spy() throws Exception {
+        assertThatThrownBy(
+                        () -> {
+                            spiedList.get(10); // see shouldInitSpy
+                        })
+                .isInstanceOf(IndexOutOfBoundsException.class);
+    }
+
+    @Test
+    public void should_report_when_enclosing_instance_is_needed() throws Exception {
+        class Outer {
+            class Inner {}
+        }
+        class WithSpy {
+            @Spy private Outer.Inner inner;
+        }
+        try {
+            MockitoAnnotations.openMocks(new WithSpy());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e).hasMessageContaining("@Spy annotation can only initialize inner classes");
+        }
+    }
+
+    @Test
+    public void should_spy_private_inner() throws Exception {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineMockMaker.class));
+
+        WithInnerPrivate inner = new WithInnerPrivate();
+        MockitoAnnotations.openMocks(inner);
+
+        when(inner.spy_field.lenght()).thenReturn(10);
+        assertEquals(10, inner.spy_field.lenght());
+    }
+
+    @Test
+    public void should_report_private_inner_not_supported() throws Exception {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
+        try {
+            MockitoAnnotations.openMocks(new WithInnerPrivate());
+            fail();
+        } catch (MockitoException e) {
+            // Currently fails at instantiation time, because the mock subclass don't have the
+            // 1-arg constructor expected for the outerclass.
+            // org.mockito.internal.creation.instance.ConstructorInstantiator.withParams()
+            assertThat(e)
+                    .hasMessageContaining("Unable to initialize @Spy annotated field 'spy_field'")
+                    .hasMessageContaining(WithInnerPrivate.InnerPrivate.class.getSimpleName());
+        }
+    }
+
+    @Test
+    public void should_report_private_abstract_inner_not_supported() throws Exception {
+        try {
+            MockitoAnnotations.openMocks(new WithInnerPrivateAbstract());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "@Spy annotation can't initialize private abstract inner classes")
+                    .hasMessageContaining(WithInnerPrivateAbstract.class.getSimpleName())
+                    .hasMessageContaining(
+                            WithInnerPrivateAbstract.InnerPrivateAbstract.class.getSimpleName())
+                    .hasMessageContaining("You should augment the visibility of this inner class");
+        }
+    }
+
+    @Test
+    public void should_report_private_static_abstract_inner_not_supported() throws Exception {
+        try {
+            MockitoAnnotations.openMocks(new WithInnerPrivateStaticAbstract());
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "@Spy annotation can't initialize private abstract inner classes")
+                    .hasMessageContaining(WithInnerPrivateStaticAbstract.class.getSimpleName())
+                    .hasMessageContaining(
+                            WithInnerPrivateStaticAbstract.InnerPrivateStaticAbstract.class
+                                    .getSimpleName())
+                    .hasMessageContaining("You should augment the visibility of this inner class");
+        }
+    }
+
+    @Test
+    public void should_be_able_to_stub_and_verify_via_varargs_for_list_params() throws Exception {
+        // You can stub with varargs.
+        when(translator.translate("hello", "mockito")).thenReturn(Arrays.asList("you", "too"));
+
+        // Pretend the prod code will call translate(List<String>) with these elements.
+        assertThat(translator.translate(Arrays.asList("hello", "mockito")))
+                .containsExactly("you", "too");
+        assertThat(translator.translate(Arrays.asList("not stubbed"))).isEmpty();
+
+        // You can verify with varargs.
+        verify(translator).translate("hello", "mockito");
+    }
+
+    @Test
+    public void should_be_able_to_stub_and_verify_via_varargs_of_matchers_for_list_params()
+            throws Exception {
+        // You can stub with varargs of matchers.
+        when(translator.translate(Mockito.anyString())).thenReturn(Arrays.asList("huh?"));
+        when(translator.translate(eq("hello"))).thenReturn(Arrays.asList("hi"));
+
+        // Pretend the prod code will call translate(List<String>) with these elements.
+        assertThat(translator.translate(Arrays.asList("hello"))).containsExactly("hi");
+        assertThat(translator.translate(Arrays.asList("not explicitly stubbed")))
+                .containsExactly("huh?");
+
+        // You can verify with varargs of matchers.
+        verify(translator).translate(eq("hello"));
+    }
+
+    static class WithInnerPrivateStaticAbstract {
+        @Spy private InnerPrivateStaticAbstract spy_field;
+
+        private abstract static class InnerPrivateStaticAbstract {}
+    }
+
+    static class WithInnerPrivateAbstract {
+        @Spy private InnerPrivateAbstract spy_field;
+
+        public void some_method() {
+            new InnerPrivateConcrete();
+        }
+
+        private abstract class InnerPrivateAbstract {}
+
+        private class InnerPrivateConcrete extends InnerPrivateAbstract {}
+    }
+
+    static class WithInnerPrivate {
+        @Spy private InnerPrivate spy_field;
+
+        private class InnerPrivate {
+            int lenght() {
+                return 0;
+            }
+        }
+
+        private class InnerPrivateSub extends InnerPrivate {}
+    }
+
+    static class InnerStaticClassWithoutDefinedConstructor {}
+
+    static class InnerStaticClassWithNoArgConstructor {
+        InnerStaticClassWithNoArgConstructor() {}
+
+        InnerStaticClassWithNoArgConstructor(String f) {}
+    }
+
+    static class NoValidConstructor {
+        NoValidConstructor(String f) {}
+    }
+
+    static class ThrowingConstructor {
+        ThrowingConstructor() {
+            throw new RuntimeException("boo!");
+        }
+    }
+
+    interface Translator {
+        List<String> translate(List<String> messages);
+    }
+
+    abstract static class MockTranslator implements Translator {
+        @Override
+        public final List<String> translate(List<String> messages) {
+            return translate(messages.toArray(new String[0]));
+        }
+
+        abstract List<String> translate(String... messages);
+    }
+}
diff --git a/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
rename to mockito-core/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
index 664f992b1e..9961e6ee20 100644
--- a/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
@@ -20,6 +20,7 @@ public class SpyInjectionTest extends TestBase {
 
     static class HasSpy {
         private List<?> spy;
+
         public void setSpy(List<?> spy) {
             this.spy = spy;
         }
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java b/mockito-core/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
new file mode 100644
index 0000000000..a2b1560e1a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.*;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitoutil.TestBase;
+
+public class WrongSetOfAnnotationsTest extends TestBase {
+
+    @Test
+    public void should_not_allow_Mock_and_Spy() {
+        assertThatThrownBy(
+                        () -> {
+                            MockitoAnnotations.openMocks(
+                                    new Object() {
+                                        @Mock @Spy List<?> mock;
+                                    });
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage(
+                        "This combination of annotations is not permitted on a single field:\n"
+                                + "@Spy and @Mock");
+    }
+
+    @Test
+    public void should_not_allow_Spy_and_InjectMocks_on_interfaces() {
+        try {
+            MockitoAnnotations.openMocks(
+                    new Object() {
+                        @InjectMocks @Spy List<?> mock;
+                    });
+            fail();
+        } catch (MockitoException me) {
+            Assertions.assertThat(me.getMessage()).contains("'List' is an interface");
+        }
+    }
+
+    @Test
+    public void should_allow_Spy_and_InjectMocks() {
+        MockitoAnnotations.openMocks(
+                new Object() {
+                    @InjectMocks @Spy WithDependency mock;
+                });
+    }
+
+    static class WithDependency {
+        List<?> list;
+    }
+
+    @Test
+    public void should_not_allow_Mock_and_InjectMocks() {
+        assertThatThrownBy(
+                        () -> {
+                            MockitoAnnotations.openMocks(
+                                    new Object() {
+                                        @InjectMocks @Mock List<?> mock;
+                                    });
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage(
+                        "This combination of annotations is not permitted on a single field:\n"
+                                + "@Mock and @InjectMocks");
+    }
+
+    @Test
+    public void should_not_allow_Captor_and_Mock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockitoAnnotations.openMocks(
+                                    new Object() {
+                                        @Mock @Captor ArgumentCaptor<?> captor;
+                                    });
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "You cannot have more than one Mockito annotation on a field!",
+                        "The field 'captor' has multiple Mockito annotations.",
+                        "For info how to use annotations see examples in javadoc for MockitoAnnotations class.");
+    }
+
+    @Test
+    public void should_not_allow_Captor_and_Spy() {
+        assertThatThrownBy(
+                        () -> {
+                            MockitoAnnotations.openMocks(
+                                    new Object() {
+                                        @Spy @Captor ArgumentCaptor<?> captor;
+                                    });
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage(
+                        "This combination of annotations is not permitted on a single field:\n"
+                                + "@Spy and @Captor");
+    }
+
+    @Test
+    public void should_not_allow_Captor_and_InjectMocks() {
+        assertThatThrownBy(
+                        () -> {
+                            MockitoAnnotations.openMocks(
+                                    new Object() {
+                                        @InjectMocks @Captor ArgumentCaptor<?> captor;
+                                    });
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessage(
+                        "This combination of annotations is not permitted on a single field:\n"
+                                + "@Captor and @InjectMocks");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/annotation/org/mockito/DoNotMock.java b/mockito-core/src/test/java/org/mockitousage/annotation/org/mockito/DoNotMock.java
new file mode 100644
index 0000000000..1dc4245356
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/annotation/org/mockito/DoNotMock.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation.org.mockito;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Test to make sure that we are matching on name rather than only {@link org.mockito.DoNotMock}
+ * type equality.
+ */
+@Target({TYPE})
+@Retention(RUNTIME)
+public @interface DoNotMock {}
diff --git a/src/test/java/org/mockitousage/basicapi/MockAccessTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/basicapi/MockAccessTest.java
rename to mockito-core/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
index 66280dbd10..13c0c744c7 100644
--- a/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
@@ -4,7 +4,6 @@
  */
 package org.mockitousage.basicapi;
 
-
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
diff --git a/mockito-core/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
new file mode 100644
index 0000000000..f7c3b00b6b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.basicapi;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
+import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
+import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+
+// See issue 453
+public class MockingMultipleInterfacesTest {
+
+    class Foo {}
+
+    interface IFoo {}
+
+    interface IBar {}
+
+    @Test
+    public void should_allow_multiple_interfaces() {
+        // when
+        Foo mock = mock(Foo.class, withSettings().extraInterfaces(IFoo.class, IBar.class));
+
+        // then
+        assertThat(mock).isInstanceOf(IFoo.class);
+        assertThat(mock).isInstanceOf(IBar.class);
+    }
+
+    @Test
+    public void should_scream_when_null_passed_instead_of_an_interface() {
+        try {
+            // when
+            mock(Foo.class, withSettings().extraInterfaces(IFoo.class, null));
+            fail();
+        } catch (MockitoException e) {
+            // then
+            assertThat(e.getMessage())
+                    .contains("extraInterfaces() does not accept null parameters");
+        }
+    }
+
+    @Test
+    public void should_scream_when_no_args_passed() {
+        try {
+            // when
+            mock(Foo.class, withSettings().extraInterfaces());
+            fail();
+        } catch (MockitoException e) {
+            // then
+            assertThat(e.getMessage())
+                    .contains("extraInterfaces() requires at least one interface");
+        }
+    }
+
+    @Test
+    public void should_scream_when_null_passed_instead_of_an_array() {
+        try {
+            // when
+            mock(Foo.class, withSettings().extraInterfaces((Class[]) null));
+            fail();
+        } catch (MockitoException e) {
+            // then
+            assertThat(e.getMessage())
+                    .contains("extraInterfaces() requires at least one interface");
+        }
+    }
+
+    @Test
+    public void should_scream_when_non_interface_passed() {
+        try {
+            // when
+            mock(Foo.class, withSettings().extraInterfaces(Foo.class));
+            fail();
+        } catch (MockitoException e) {
+            // then
+            assertThat(e.getMessage()).contains("Foo which is not an interface");
+        }
+    }
+
+    @Test
+    public void should_scream_when_the_same_interfaces_passed() {
+        try {
+            // when
+            mock(IMethods.class, withSettings().extraInterfaces(IMethods.class));
+            fail();
+        } catch (MockitoException e) {
+            // then
+            assertThat(e.getMessage()).contains("You mocked following type: IMethods");
+        }
+    }
+
+    @Test
+    public void
+            should_mock_class_with_interfaces_of_different_class_loader_AND_different_classpaths()
+                    throws ClassNotFoundException {
+        // Note : if classes are in the same classpath, SearchingClassLoader can find the
+        // class/classes and load them in the first matching classloader
+        Class<?> interface1 =
+                inMemoryClassLoader()
+                        .withClassDefinition(
+                                "test.Interface1", makeMarkerInterface("test.Interface1"))
+                        .build()
+                        .loadClass("test.Interface1");
+        Class<?> interface2 =
+                inMemoryClassLoader()
+                        .withClassDefinition(
+                                "test.Interface2", makeMarkerInterface("test.Interface2"))
+                        .build()
+                        .loadClass("test.Interface2");
+
+        Object mocked = mock(interface1, withSettings().extraInterfaces(interface2));
+        assertThat(interface2.isInstance(mocked))
+                .describedAs("mock should be assignable from interface2 type")
+                .isTrue();
+    }
+}
diff --git a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
similarity index 80%
rename from src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
rename to mockito-core/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
index 8689592b2c..241c7754a9 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
@@ -39,62 +39,66 @@ public void should_create_mock_when_constructor_is_private() {
 
     @Test
     public void should_combine_mock_name_and_smart_nulls() {
-        //given
-        IMethods mock = mock(IMethods.class, withSettings()
-            .defaultAnswer(RETURNS_SMART_NULLS)
-            .name("great mockie"));
+        // given
+        IMethods mock =
+                mock(
+                        IMethods.class,
+                        withSettings().defaultAnswer(RETURNS_SMART_NULLS).name("great mockie"));
 
-        //when
+        // when
         IMethods smartNull = mock.iMethodsReturningMethod();
         String name = mock.toString();
 
-        //then
+        // then
         assertThat(name).contains("great mockie");
-        //and
+        // and
         try {
             smartNull.simpleMethod();
             fail();
-        } catch(SmartNullPointerException e) {}
+        } catch (SmartNullPointerException e) {
+        }
     }
 
     @Test
     public void should_combine_mock_name_and_extra_interfaces() {
-        //given
-        IMethods mock = mock(IMethods.class, withSettings()
-                .extraInterfaces(List.class)
-                .name("great mockie"));
+        // given
+        IMethods mock =
+                mock(
+                        IMethods.class,
+                        withSettings().extraInterfaces(List.class).name("great mockie"));
 
-        //when
+        // when
         String name = mock.toString();
 
-        //then
+        // then
         assertThat(name).contains("great mockie");
-        //and
+        // and
         assertTrue(mock instanceof List);
     }
 
     @Test
     public void should_specify_mock_name_via_settings() {
-        //given
+        // given
         IMethods mock = mock(IMethods.class, withSettings().name("great mockie"));
 
-        //when
+        // when
         String name = mock.toString();
 
-        //then
+        // then
         assertThat(name).contains("great mockie");
     }
 
     @Test
     public void should_scream_when_spy_created_with_wrong_type() {
-        //given
+        // given
         List list = new LinkedList();
         try {
-            //when
+            // when
             mock(List.class, withSettings().spiedInstance(list));
             fail();
-            //then
-        } catch (MockitoException e) {}
+            // then
+        } catch (MockitoException e) {
+        }
     }
 
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@@ -112,14 +116,15 @@ public void should_allow_inline_mock_creation() {
     @Retention(RetentionPolicy.RUNTIME)
     @interface SomeAnnotation {}
 
-    @SomeAnnotation static class Foo {}
+    @SomeAnnotation
+    static class Foo {}
 
     @Test
     public void should_strip_annotations() {
         Foo withAnnotations = mock(Foo.class);
         Foo withoutAnnotations = mock(Foo.class, withSettings().withoutAnnotations());
 
-        //expect:
+        // expect:
         assertTrue(withAnnotations.getClass().isAnnotationPresent(SomeAnnotation.class));
         assertFalse(withoutAnnotations.getClass().isAnnotationPresent(SomeAnnotation.class));
     }
diff --git a/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
similarity index 83%
rename from src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
rename to mockito-core/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
index 1c3548521e..68e54f9aa6 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
@@ -13,6 +13,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Observable;
+import java.util.function.Supplier;
 
 import org.assertj.core.api.Assertions;
 import org.junit.Test;
@@ -32,19 +33,36 @@ public class MocksSerializationForAnnotationTest extends TestBase implements Ser
     private static final long serialVersionUID = 6160482220413048624L;
 
     @Mock Any any;
-    @Mock(serializable=true) Bar barMock;
-    @Mock(serializable=true) IMethods imethodsMock;
-    @Mock(serializable=true) IMethods imethodsMock2;
-    @Mock(serializable=true) Any anyMock;
-    @Mock(serializable=true) AlreadySerializable alreadySerializableMock;
-    @Mock(extraInterfaces={List.class},serializable=true) IMethods imethodsWithExtraInterfacesMock;
+
+    @Mock(serializable = true)
+    Bar barMock;
+
+    @Mock(serializable = true)
+    IMethods imethodsMock;
+
+    @Mock(serializable = true)
+    IMethods imethodsMock2;
+
+    @Mock(serializable = true)
+    Any anyMock;
+
+    @Mock(serializable = true)
+    AlreadySerializable alreadySerializableMock;
+
+    @Mock(
+            extraInterfaces = {List.class},
+            serializable = true)
+    IMethods imethodsWithExtraInterfacesMock;
+
+    @Mock(serializable = true)
+    Supplier<Object> parameterizedSupplier;
 
     @Test
     public void should_allow_throws_exception_to_be_serializable() throws Exception {
         // given
         when(barMock.doSomething()).thenAnswer(new ThrowsException(new RuntimeException()));
 
-        //when-serialize then-deserialize
+        // when-serialize then-deserialize
         serializeAndBack(barMock);
     }
 
@@ -54,6 +72,11 @@ public void should_allow_mock_to_be_serializable() throws Exception {
         serializeAndBack(imethodsMock);
     }
 
+    @Test
+    public void should_allow_mock_of_parameterized_type_to_be_serializable() throws Exception {
+        serializeAndBack(parameterizedSupplier);
+    }
+
     @Test
     public void should_allow_mock_and_boolean_value_to_serializable() throws Exception {
         // given
@@ -96,7 +119,8 @@ public void should_all_mock_and_serializable_value_to_be_serialized() throws Exc
     }
 
     @Test
-    public void should_serialize_method_call_with_parameters_that_are_serializable() throws Exception {
+    public void should_serialize_method_call_with_parameters_that_are_serializable()
+            throws Exception {
         List<?> value = Collections.emptyList();
         when(imethodsMock.objectArgMethod(value)).thenReturn(value);
 
@@ -147,8 +171,9 @@ public void should_verify_even_if_some_methods_called_after_serialization() thro
         // then
         verify(readObject, times(2)).simpleMethod(1);
 
-        //this test is working because it seems that java serialization mechanism replaces all instances
-        //of serialized object in the object graph (if there are any)
+        // this test is working because it seems that java serialization mechanism replaces all
+        // instances
+        // of serialized object in the object graph (if there are any)
     }
 
     class Bar implements Serializable {
@@ -161,6 +186,7 @@ public Foo doSomething() {
 
     class Foo implements Serializable {
         Bar bar;
+
         Foo() {
             bar = new Bar();
             bar.foo = this;
@@ -169,17 +195,17 @@ class Foo implements Serializable {
 
     @Test
     public void should_serialization_work() throws Exception {
-        //given
+        // given
         Foo foo = new Foo();
-        //when
+        // when
         foo = serializeAndBack(foo);
-        //then
+        // then
         assertSame(foo, foo.bar.foo);
     }
 
     @Test
     public void should_stub_even_if_some_methods_called_after_serialization() throws Exception {
-        //given
+        // given
         // when
         when(imethodsMock.simpleMethod(1)).thenReturn("foo");
         ByteArrayOutputStream serialized = serializeMock(imethodsMock);
@@ -227,7 +253,7 @@ public void should_serialize_with_stubbing_callback() throws Exception {
 
         // given
         CustomAnswersMustImplementSerializableForSerializationToWork answer =
-            new CustomAnswersMustImplementSerializableForSerializationToWork();
+                new CustomAnswersMustImplementSerializableForSerializationToWork();
         answer.string = "return value";
         when(imethodsMock.objectArgMethod(anyString())).thenAnswer(answer);
 
@@ -240,8 +266,9 @@ public void should_serialize_with_stubbing_callback() throws Exception {
     }
 
     static class CustomAnswersMustImplementSerializableForSerializationToWork
-        implements Answer<Object>, Serializable {
+            implements Answer<Object>, Serializable {
         private String string;
+
         public Object answer(InvocationOnMock invocation) throws Throwable {
             invocation.getArguments();
             invocation.getMock();
@@ -253,10 +280,13 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
     public void should_serialize_with_real_object_spy() throws Exception {
         // given
         SerializableSample list = new SerializableSample();
-        SerializableSample spy = mock(SerializableSample.class, withSettings()
-                        .spiedInstance(list)
-                        .defaultAnswer(CALLS_REAL_METHODS)
-                        .serializable());
+        SerializableSample spy =
+                mock(
+                        SerializableSample.class,
+                        withSettings()
+                                .spiedInstance(list)
+                                .defaultAnswer(CALLS_REAL_METHODS)
+                                .serializable());
         when(spy.foo()).thenReturn("foo");
 
         // when
@@ -279,7 +309,7 @@ public void should_serialize_object_mock() throws Exception {
     @Test
     public void should_serialize_real_partial_mock() throws Exception {
         // given
-        when(anyMock.matches(anyObject())).thenCallRealMethod();
+        when(anyMock.matches(any())).thenCallRealMethod();
 
         // when
         ByteArrayOutputStream serialized = serializeMock(anyMock);
@@ -305,29 +335,35 @@ public void should_serialize_already_serializable_class() throws Exception {
 
     @Test
     public void should_be_serialize_and_have_extra_interfaces() throws Exception {
-        //then
+        // then
         Assertions.assertThat((Object) serializeAndBack((List) imethodsWithExtraInterfacesMock))
                 .isInstanceOf(List.class)
                 .isInstanceOf(IMethods.class);
     }
 
     static class NotSerializableAndNoDefaultConstructor {
-        NotSerializableAndNoDefaultConstructor(Observable o) { super(); }
+        NotSerializableAndNoDefaultConstructor(Observable o) {
+            super();
+        }
     }
 
     static class SerializableAndNoDefaultConstructor implements Serializable {
-        SerializableAndNoDefaultConstructor(Observable o) { super(); }
+        SerializableAndNoDefaultConstructor(Observable o) {
+            super();
+        }
     }
 
     public static class TestClassThatHoldValidField {
-        @Mock(serializable=true)
+        @Mock(serializable = true)
         SerializableAndNoDefaultConstructor serializableAndNoDefaultConstructor;
     }
 
     @Test
-    public void should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor() throws Exception {
+    public void
+            should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor()
+                    throws Exception {
         TestClassThatHoldValidField testClass = new TestClassThatHoldValidField();
-        MockitoAnnotations.initMocks(testClass);
+        MockitoAnnotations.openMocks(testClass);
 
         serializeAndBack(testClass.serializableAndNoDefaultConstructor);
     }
diff --git a/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
similarity index 86%
rename from src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
rename to mockito-core/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
index a021c53c45..327899295e 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
@@ -5,7 +5,6 @@
 package org.mockitousage.basicapi;
 
 import static org.junit.Assert.*;
-import static org.junit.Assume.assumeTrue;
 import static org.mockito.Mockito.*;
 import static org.mockitoutil.SimpleSerializationUtil.*;
 
@@ -16,7 +15,6 @@
 import java.util.List;
 import java.util.Observable;
 
-import net.bytebuddy.ClassFileVersion;
 import org.assertj.core.api.Assertions;
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -49,7 +47,7 @@ public void should_allow_method_delegation() throws Exception {
         Foo fooMock = mock(Foo.class);
         when(barMock.doSomething()).thenAnswer(new ThrowsException(new RuntimeException()));
 
-        //when-serialize then-deserialize
+        // when-serialize then-deserialize
         serializeAndBack(barMock);
     }
 
@@ -107,7 +105,8 @@ public void should_all_mock_and_serializable_value_to_be_serialized() throws Exc
     }
 
     @Test
-    public void should_serialize_method_call_with_parameters_that_are_serializable() throws Exception {
+    public void should_serialize_method_call_with_parameters_that_are_serializable()
+            throws Exception {
         IMethods mock = mock(IMethods.class, withSettings().serializable());
         List<?> value = Collections.emptyList();
         when(mock.objectArgMethod(value)).thenReturn(value);
@@ -151,7 +150,7 @@ public void should_verify_called_n_times_for_serialized_mock() throws Exception
 
     @Test
     public void should_verify_even_if_some_methods_called_after_serialization() throws Exception {
-        //given
+        // given
         IMethods mock = mock(IMethods.class, withSettings().serializable());
 
         // when
@@ -163,8 +162,9 @@ public void should_verify_even_if_some_methods_called_after_serialization() thro
         // then
         verify(readObject, times(2)).simpleMethod(1);
 
-        //this test is working because it seems that java serialization mechanism replaces all instances
-        //of serialized object in the object graph (if there are any)
+        // this test is working because it seems that java serialization mechanism replaces all
+        // instances
+        // of serialized object in the object graph (if there are any)
     }
 
     class Bar implements Serializable {
@@ -177,6 +177,7 @@ public Foo doSomething() {
 
     class Foo implements Serializable {
         Bar bar;
+
         Foo() {
             bar = new Bar();
             bar.foo = this;
@@ -185,17 +186,17 @@ class Foo implements Serializable {
 
     @Test
     public void should_serialization_work() throws Exception {
-        //given
+        // given
         Foo foo = new Foo();
-        //when
+        // when
         foo = serializeAndBack(foo);
-        //then
+        // then
         assertSame(foo, foo.bar.foo);
     }
 
     @Test
     public void should_stub_even_if_some_methods_called_after_serialization() throws Exception {
-        //given
+        // given
         IMethods mock = mock(IMethods.class, withSettings().serializable());
 
         // when
@@ -264,6 +265,7 @@ public void should_serialize_with_stubbing_callback() throws Exception {
     class CustomAnswersMustImplementSerializableForSerializationToWork
             implements Answer<Object>, Serializable {
         private String string;
+
         public Object answer(InvocationOnMock invocation) throws Throwable {
             invocation.getArguments();
             invocation.getMock();
@@ -275,10 +277,13 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
     public void should_serialize_with_real_object_spy() throws Exception {
         // given
         SerializableClass sample = new SerializableClass();
-        SerializableClass spy = mock(SerializableClass.class, withSettings()
-                .spiedInstance(sample)
-                .defaultAnswer(CALLS_REAL_METHODS)
-                .serializable());
+        SerializableClass spy =
+                mock(
+                        SerializableClass.class,
+                        withSettings()
+                                .spiedInstance(sample)
+                                .defaultAnswer(CALLS_REAL_METHODS)
+                                .serializable());
         when(spy.foo()).thenReturn("foo");
 
         // when
@@ -305,7 +310,7 @@ public void should_serialize_object_mock() throws Exception {
     public void should_serialize_real_partial_mock() throws Exception {
         // given
         Any mock = mock(Any.class, withSettings().serializable());
-        when(mock.matches(anyObject())).thenCallRealMethod();
+        when(mock.matches(any())).thenCallRealMethod();
 
         // when
         ByteArrayOutputStream serialized = serializeMock(mock);
@@ -332,11 +337,13 @@ public void should_serialize_already_serializable_class() throws Exception {
 
     @Test
     public void should_be_serialize_and_have_extra_interfaces() throws Exception {
-        //when
-        IMethods mock = mock(IMethods.class, withSettings().serializable().extraInterfaces(List.class));
-        IMethods mockTwo = mock(IMethods.class, withSettings().extraInterfaces(List.class).serializable());
+        // when
+        IMethods mock =
+                mock(IMethods.class, withSettings().serializable().extraInterfaces(List.class));
+        IMethods mockTwo =
+                mock(IMethods.class, withSettings().extraInterfaces(List.class).serializable());
 
-        //then
+        // then
         Assertions.assertThat((Object) serializeAndBack((List) mock))
                 .isInstanceOf(List.class)
                 .isInstanceOf(IMethods.class);
@@ -346,28 +353,34 @@ public void should_be_serialize_and_have_extra_interfaces() throws Exception {
     }
 
     static class SerializableAndNoDefaultConstructor implements Serializable {
-        SerializableAndNoDefaultConstructor(Observable o) { super(); }
+        SerializableAndNoDefaultConstructor(Observable o) {
+            super();
+        }
     }
 
     @Test
-    public void should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor() throws Exception {
+    public void
+            should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor()
+                    throws Exception {
         serializeAndBack(mock(SerializableAndNoDefaultConstructor.class));
     }
 
-
-
     public static class AClassWithPrivateNoArgConstructor {
         private AClassWithPrivateNoArgConstructor() {}
-        List returningSomething() { return Collections.emptyList(); }
+
+        List returningSomething() {
+            return Collections.emptyList();
+        }
     }
 
     @Test
-    public void private_constructor_currently_not_supported_at_the_moment_at_deserialization_time() throws Exception {
+    public void private_constructor_currently_not_supported_at_the_moment_at_deserialization_time()
+            throws Exception {
         // given
-        AClassWithPrivateNoArgConstructor mockWithPrivateConstructor = Mockito.mock(
-                AClassWithPrivateNoArgConstructor.class,
-                Mockito.withSettings().serializable()
-        );
+        AClassWithPrivateNoArgConstructor mockWithPrivateConstructor =
+                Mockito.mock(
+                        AClassWithPrivateNoArgConstructor.class,
+                        Mockito.withSettings().serializable());
 
         try {
             // when
@@ -379,14 +392,15 @@ public void private_constructor_currently_not_supported_at_the_moment_at_deseria
         }
     }
 
-
     @Test
     public void BUG_ISSUE_399_try_some_mocks_with_current_answers() throws Exception {
-        assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V7));
-
-        IMethods iMethods = mock(IMethods.class, withSettings().serializable().defaultAnswer(RETURNS_DEEP_STUBS));
+        IMethods iMethods =
+                mock(
+                        IMethods.class,
+                        withSettings().serializable().defaultAnswer(RETURNS_DEEP_STUBS));
 
-        when(iMethods.iMethodsReturningMethod().linkedListReturningMethod().contains(anyString())).thenReturn(false);
+        when(iMethods.iMethodsReturningMethod().linkedListReturningMethod().contains(anyString()))
+                .thenReturn(false);
 
         serializeAndBack(iMethods);
     }
diff --git a/mockito-core/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
new file mode 100644
index 0000000000..c3c668c96d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.basicapi;
+
+import static org.junit.Assert.assertSame;
+import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
+
+import java.io.Serializable;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("serial")
+public class ObjectsSerializationTest extends TestBase implements Serializable {
+
+    // Ok, this test has nothing to do with mocks but it shows fundamental feature of java
+    // serialization that
+    // plays important role in mocking:
+    // Serialization/deserialization actually replaces all instances of serialized object in the
+    // object graph (if there are any)
+    // thanks to that mechanizm, stubbing & verification can correctly match method invocations
+    // because
+    // one of the parts of invocation matching is checking if mock object is the same
+
+    class Bar implements Serializable {
+        Foo foo;
+    }
+
+    class Foo implements Serializable {
+        Bar bar;
+
+        Foo() {
+            bar = new Bar();
+            bar.foo = this;
+        }
+    }
+
+    @Test
+    public void shouldSerializationWork() throws Exception {
+        // given
+        Foo foo = new Foo();
+        // when
+        foo = serializeAndBack(foo);
+        // then
+        assertSame(foo, foo.bar.foo);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
new file mode 100644
index 0000000000..72903f9e6e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.basicapi;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockitoutil.TestBase;
+
+public class ReplacingObjectMethodsTest extends TestBase {
+
+    private interface DummyInterface {}
+
+    private class DummyClass {}
+
+    @Test
+    public void shouldProvideMockyImplementationOfToString() {
+        DummyClass dummyClass = Mockito.mock(DummyClass.class);
+        assertEquals(
+                "Mock for DummyClass, hashCode: " + dummyClass.hashCode(), dummyClass.toString());
+        DummyInterface dummyInterface = Mockito.mock(DummyInterface.class);
+        assertEquals(
+                "Mock for DummyInterface, hashCode: " + dummyInterface.hashCode(),
+                dummyInterface.toString());
+    }
+
+    @Test
+    public void shouldReplaceObjectMethods() {
+        Object mock = Mockito.mock(ObjectMethodsOverridden.class);
+        Object otherMock = Mockito.mock(ObjectMethodsOverridden.class);
+
+        assertThat(mock).isEqualTo(mock);
+        assertThat(mock).isNotEqualTo(otherMock);
+        assertThat(mock.hashCode()).isNotEqualTo(otherMock.hashCode());
+
+        assertThat(mock.toString()).contains("Mock for ObjectMethodsOverridden");
+    }
+
+    @Test
+    public void shouldReplaceObjectMethodsWhenOverridden() {
+        Object mock = Mockito.mock(ObjectMethodsOverriddenSubclass.class);
+        Object otherMock = Mockito.mock(ObjectMethodsOverriddenSubclass.class);
+
+        assertThat(mock).isEqualTo(mock);
+        assertThat(mock).isNotEqualTo(otherMock);
+        assertThat(mock.hashCode()).isNotEqualTo(otherMock.hashCode());
+
+        assertThat(mock.toString()).contains("Mock for ObjectMethodsOverriddenSubclass");
+    }
+
+    public static class ObjectMethodsOverridden {
+        public boolean equals(Object o) {
+            throw new RuntimeException(
+                    "Should not be called. MethodInterceptorFilter provides implementation");
+        }
+
+        public int hashCode() {
+            throw new RuntimeException(
+                    "Should not be called. MethodInterceptorFilter provides implementation");
+        }
+
+        public String toString() {
+            throw new RuntimeException(
+                    "Should not be called. MethodInterceptorFilter provides implementation");
+        }
+    }
+
+    public static class ObjectMethodsOverriddenSubclass extends ObjectMethodsOverridden {}
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
new file mode 100644
index 0000000000..580f055760
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.basicapi;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class ResetInvocationsTest extends TestBase {
+
+    @Mock IMethods methods;
+
+    @Mock IMethods moarMethods;
+
+    @Test
+    public void reset_invocations_should_reset_only_invocations() {
+        when(methods.simpleMethod()).thenReturn("return");
+
+        methods.simpleMethod();
+        verify(methods).simpleMethod();
+
+        clearInvocations(methods);
+
+        verifyNoMoreInteractions(methods);
+        assertEquals("return", methods.simpleMethod());
+    }
+
+    @Test
+    public void should_reset_invocations_on_multiple_mocks() {
+        methods.simpleMethod();
+        moarMethods.simpleMethod();
+
+        clearInvocations(methods, moarMethods);
+
+        verifyNoMoreInteractions(methods, moarMethods);
+    }
+
+    @Test
+    public void resettingNonMockIsSafe() {
+        assertThatThrownBy(
+                        () -> {
+                            clearInvocations("");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is: class java.lang.String");
+    }
+
+    @Test
+    public void resettingNullIsSafe() {
+        assertThatThrownBy(
+                        () -> {
+                            clearInvocations(new Object[] {null});
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is null!");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/basicapi/ResetTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/ResetTest.java
new file mode 100644
index 0000000000..72db5c7101
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/ResetTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.basicapi;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.MissingMethodInvocationException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.UnfinishedVerificationException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class ResetTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    @Mock private IMethods mockTwo;
+
+    @Test
+    public void shouldResetOngoingStubbingSoThatMoreMeaningfulExceptionsAreRaised() {
+        mock.booleanReturningMethod();
+        reset(mock);
+        try {
+            when(null).thenReturn("anything");
+            fail();
+        } catch (MissingMethodInvocationException e) {
+        }
+    }
+
+    @Test
+    public void resettingNonMockIsSafe() {
+        assertThatThrownBy(
+                        () -> {
+                            reset("");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is: class java.lang.String");
+    }
+
+    @Test
+    public void resettingNullIsSafe() {
+        assertThatThrownBy(
+                        () -> {
+                            reset(new Object[] {null});
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is null!");
+    }
+
+    @Test
+    public void shouldRemoveAllStubbing() {
+        when(mock.objectReturningMethod(isA(Integer.class))).thenReturn(100);
+        when(mock.objectReturningMethod(200)).thenReturn(200);
+        reset(mock);
+        assertNull(mock.objectReturningMethod(200));
+        assertEquals(
+                "default behavior should return null", null, mock.objectReturningMethod("blah"));
+    }
+
+    @Test
+    public void shouldRemoveAllInteractions() {
+        mock.simpleMethod(1);
+        reset(mock);
+        verifyNoInteractions(mock);
+    }
+
+    @Test
+    public void shouldRemoveAllInteractionsVerifyNoInteractions() {
+        mock.simpleMethod(1);
+        reset(mock);
+        verifyNoInteractions(mock);
+    }
+
+    @Test
+    public void shouldRemoveStubbingToString() {
+        IMethods mockTwo = mock(IMethods.class);
+        when(mockTwo.toString()).thenReturn("test");
+        reset(mockTwo);
+        assertThat(mockTwo.toString()).contains("Mock for IMethods");
+    }
+
+    @Test
+    public void shouldStubbingNotBeTreatedAsInteractionVerifyNoInteractions() {
+        when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
+        doThrow(new RuntimeException()).when(mock).simpleMethod("two");
+        reset(mock);
+        verifyNoInteractions(mock);
+    }
+
+    @Test
+    public void shouldNotAffectMockName() {
+        IMethods mock = mock(IMethods.class, "mockie");
+        IMethods mockTwo = mock(IMethods.class);
+        reset(mock);
+        assertThat(mockTwo.toString()).contains("Mock for IMethods");
+        assertEquals("mockie", "" + mock);
+    }
+
+    @Test
+    public void shouldResetMultipleMocks() {
+        mock.simpleMethod();
+        mockTwo.simpleMethod();
+        reset(mock, mockTwo);
+        verifyNoMoreInteractions(mock, mockTwo);
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void shouldValidateStateWhenResetting() {
+        // invalid verify:
+        verify(mock);
+
+        try {
+            reset(mockTwo);
+            fail();
+        } catch (UnfinishedVerificationException e) {
+        }
+    }
+
+    @Test
+    public void shouldMaintainPreviousDefaultAnswer() {
+        // given
+        mock = mock(IMethods.class, RETURNS_MOCKS);
+        // when
+        reset(mock);
+        // then
+        assertNotNull(mock.iMethodsReturningMethod());
+    }
+}
diff --git a/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java b/mockito-core/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
similarity index 82%
rename from src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
rename to mockito-core/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
index d71077f819..8d69a2a52f 100644
--- a/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
@@ -21,10 +21,14 @@ public class UsingVarargsTest extends TestBase {
 
     private interface IVarArgs {
         void withStringVarargs(int value, String... s);
+
         String withStringVarargsReturningString(int value, String... s);
+
         void withObjectVarargs(int value, Object... o);
+
         boolean withBooleanVarargs(int value, boolean... b);
-        int foo(Object ... objects);
+
+        int foo(Object... objects);
     }
 
     @Mock IVarArgs mock;
@@ -82,7 +86,8 @@ public void shouldVerifyStringVarargs() {
         try {
             verify(mock).withStringVarargs(2, "1", "2", "79", "4");
             fail();
-        } catch (ArgumentsAreDifferent e) {}
+        } catch (ArgumentsAreDifferent e) {
+        }
     }
 
     @Test
@@ -96,7 +101,8 @@ public void shouldVerifyObjectVarargs() {
         try {
             verifyNoMoreInteractions(mock);
             fail();
-        } catch (NoInteractionsWanted e) {}
+        } catch (NoInteractionsWanted e) {
+        }
     }
 
     @Test
@@ -110,22 +116,23 @@ public void shouldVerifyBooleanVarargs() {
         try {
             verify(mock).withBooleanVarargs(3, true, true, true, true);
             fail();
-        } catch (ArgumentsAreDifferent e) {}
+        } catch (ArgumentsAreDifferent e) {
+        }
     }
 
     @Test
-    public void shouldVerifyWithAnyObject() {
+    public void shouldVerifyWithAny() {
         Foo foo = Mockito.mock(Foo.class);
         foo.varArgs("");
-        Mockito.verify(foo).varArgs((String[]) Mockito.anyObject());
-        Mockito.verify(foo).varArgs((String) Mockito.anyObject());
+        Mockito.verify(foo).varArgs((String[]) Mockito.any());
+        Mockito.verify(foo).varArgs((String) Mockito.any());
     }
 
     @Test
     public void shouldVerifyWithNullVarArgArray() {
         Foo foo = Mockito.mock(Foo.class);
         foo.varArgs((String[]) null);
-        Mockito.verify(foo).varArgs((String[]) Mockito.anyObject());
+        Mockito.verify(foo).varArgs((String[]) Mockito.any());
         Mockito.verify(foo).varArgs((String[]) null);
     }
 
@@ -135,41 +142,42 @@ public void varArgs(String... args) {}
 
     interface MixedVarargs {
         String doSomething(String one, String... varargs);
+
         String doSomething(String one, String two, String... varargs);
     }
 
     @SuppressWarnings("all")
     @Test
-    //See bug #31
+    // See bug #31
     public void shouldStubCorrectlyWhenMixedVarargsUsed() {
         MixedVarargs mixedVarargs = mock(MixedVarargs.class);
-        when(mixedVarargs.doSomething("hello", (String[])null)).thenReturn("hello");
-        when(mixedVarargs.doSomething("goodbye", (String[])null)).thenReturn("goodbye");
+        when(mixedVarargs.doSomething("hello", (String[]) null)).thenReturn("hello");
+        when(mixedVarargs.doSomething("goodbye", (String[]) null)).thenReturn("goodbye");
 
-        String result = mixedVarargs.doSomething("hello",(String[]) null);
+        String result = mixedVarargs.doSomething("hello", (String[]) null);
         assertEquals("hello", result);
 
-        verify(mixedVarargs).doSomething("hello", (String[])null);
+        verify(mixedVarargs).doSomething("hello", (String[]) null);
     }
 
     @SuppressWarnings("all")
     @Test
     public void shouldStubCorrectlyWhenDoubleStringAndMixedVarargsUsed() {
         MixedVarargs mixedVarargs = mock(MixedVarargs.class);
-        when(mixedVarargs.doSomething("one", "two", (String[])null)).thenReturn("hello");
-        when(mixedVarargs.doSomething("1", "2", (String[])null)).thenReturn("goodbye");
+        when(mixedVarargs.doSomething("one", "two", (String[]) null)).thenReturn("hello");
+        when(mixedVarargs.doSomething("1", "2", (String[]) null)).thenReturn("goodbye");
 
-        String result = mixedVarargs.doSomething("one", "two", (String[])null);
+        String result = mixedVarargs.doSomething("one", "two", (String[]) null);
         assertEquals("hello", result);
     }
 
     @Test
-    //See bug #157
-    public void shouldMatchEasilyEmptyVararg() throws Exception {
-        //when
-        when(mock.foo(anyVararg())).thenReturn(-1);
+    // See bug #157
+    public void shouldMatchEasilyEmptyVararg() {
+        // when
+        when(mock.foo(any(Object[].class))).thenReturn(-1);
 
-        //then
+        // then
         assertEquals(-1, mock.foo());
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
similarity index 98%
rename from src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
index f1b862707e..f7127240e0 100644
--- a/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
@@ -9,12 +9,14 @@
 import org.junit.Test;
 import org.mockitoutil.TestBase;
 
-//see bug 116
+// see bug 116
 public class AIOOBExceptionWithAtLeastTest extends TestBase {
 
     interface IProgressMonitor {
         void beginTask(String s, int i);
+
         void worked(int i);
+
         void done();
     }
 
diff --git a/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
similarity index 76%
rename from src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
index 13d37662c4..ac46998abb 100644
--- a/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
@@ -18,18 +18,18 @@ public interface Fun {
 
     @Test
     public void shouldAllowPassingNullArgument() {
-        //given
+        // given
         Fun mockFun = mock(Fun.class);
-        when(mockFun.doFun((String) anyObject())).thenReturn("value");
+        when(mockFun.doFun((String) any())).thenReturn("value");
 
-        //when
+        // when
         mockFun.doFun(null);
 
-        //then
+        // then
         try {
             verify(mockFun).doFun("hello");
-        } catch(AssertionError r) {
-            //it's ok, we just want to reproduce the bug
+        } catch (AssertionError r) {
+            // it's ok, we just want to reproduce the bug
             return;
         }
         fail();
diff --git a/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java b/mockito-core/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
new file mode 100644
index 0000000000..2c231e06f6
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.Test;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockitoutil.TestBase;
+
+// see issue 112
+public class AtLeastMarksAllInvocationsVerified extends TestBase {
+
+    public static class SomeMethods {
+        public void allowedMethod() {}
+
+        public void disallowedMethod() {}
+    }
+
+    @Test
+    public void shouldFailBecauseDisallowedMethodWasCalled() {
+        SomeMethods someMethods = mock(SomeMethods.class);
+
+        someMethods.allowedMethod();
+        someMethods.disallowedMethod();
+
+        verify(someMethods, atLeast(1)).allowedMethod();
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions(someMethods);
+                        })
+                .isInstanceOf(NoInteractionsWanted.class)
+                .hasMessageContainingAll(
+                        "No interactions wanted here:",
+                        "-> at ",
+                        "But found this interaction on mock 'someMethods':",
+                        "-> at ",
+                        "For your reference, here is the list of all invocations ([?] - means unverified).",
+                        "1. -> at ",
+                        "2. [?]-> at ");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java
new file mode 100644
index 0000000000..c5f1b63102
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.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.bugs;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.io.Serializable;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockitoutil.TestBase;
+
+// see issue 101
+public class BridgeMethodsHitAgainTest extends TestBase {
+
+    public interface Factory {}
+
+    public interface ExtendedFactory extends Factory {}
+
+    public interface SomeInterface {
+        Factory factory();
+    }
+
+    public interface SomeSubInterface extends SomeInterface {
+        ExtendedFactory factory();
+    }
+
+    public interface Base<T extends Serializable> {
+        int test(T value);
+    }
+
+    public interface Extended extends Base<String> {
+        @Override
+        int test(String value);
+    }
+
+    @Mock SomeSubInterface someSubInterface;
+    @Mock ExtendedFactory extendedFactory;
+
+    @Test
+    public void basicCheck() {
+        Mockito.when((someSubInterface).factory()).thenReturn(extendedFactory);
+        SomeInterface si = someSubInterface;
+        assertTrue(si.factory() != null);
+    }
+
+    @Test
+    public void checkWithExtraCast() {
+        Mockito.when(((SomeInterface) someSubInterface).factory()).thenReturn(extendedFactory);
+        SomeInterface si = someSubInterface;
+        assertTrue(si.factory() != null);
+    }
+
+    @Test
+    public void testBridgeInvocationIsRecordedForInterceptedMethod() {
+        Extended ext = mock(Extended.class);
+        ext.test("123");
+        verify(ext).test("123");
+        ((Base<String>) ext).test("456");
+        verify(ext).test("456");
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
similarity index 95%
rename from src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
index ebbaa11ec7..78c70e912f 100644
--- a/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
@@ -14,11 +14,12 @@
 import org.mockito.Mock;
 import org.mockitoutil.TestBase;
 
-//see issue 188
+// see issue 188
 public class CaptorAnnotationAutoboxingTest extends TestBase {
 
     interface Fun {
         void doFun(double prmitive);
+
         void moreFun(int howMuch);
     }
 
@@ -27,10 +28,10 @@ interface Fun {
 
     @Test
     public void shouldAutoboxSafely() {
-        //given
+        // given
         fun.doFun(1.0);
 
-        //then
+        // then
         verify(fun).doFun(captor.capture());
         assertEquals(Double.valueOf(1.0), captor.getValue());
     }
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
new file mode 100644
index 0000000000..a22ae24539
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import org.junit.Test;
+import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.stubbing.Answer;
+
+public class ClassCastExOnVerifyZeroInteractionsTest {
+    public interface TestMock {
+        boolean m1();
+    }
+
+    @Test
+    public void should_not_throw_ClassCastException_when_mock_verification_fails() {
+        TestMock test = mock(TestMock.class, (Answer<Object>) invocation -> false);
+        test.m1();
+
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoInteractions(test);
+                        })
+                .isInstanceOf(NoInteractionsWanted.class)
+                .hasMessageContainingAll(
+                        "No interactions wanted here:",
+                        "But found these interactions on mock 'testMock':",
+                        "Actually, above is the only interaction with this mock.");
+    }
+
+    @Test
+    public void should_report_bogus_default_answer() {
+        TestMock test = mock(TestMock.class, (Answer<Object>) invocation -> false);
+
+        assertThatThrownBy(
+                        () -> {
+                            String ignored = test.toString();
+                        })
+                .isInstanceOf(WrongTypeOfReturnValue.class)
+                .hasMessageContainingAll(
+                        "Default answer returned a result with the wrong type:",
+                        "Boolean cannot be returned by toString()",
+                        "toString() should return String",
+                        "The default answer of testMock that was configured on the mock is probably incorrectly implemented.");
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
similarity index 85%
rename from src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
index 01243c066c..dd6db3fbb8 100644
--- a/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
@@ -6,8 +6,8 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.AdditionalMatchers.leq;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.startsWith;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.startsWith;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -24,11 +24,9 @@
 public class CompareMatcherTest {
     private static final Object NOT_A_COMPARABLE = new Object();
 
-    @Rule
-    public MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
 
-    @Mock
-    public IMethods mock;
+    @Mock public IMethods mock;
 
     /**
      * Should not throw an {@link NullPointerException}
@@ -41,7 +39,7 @@ public void compareNullArgument() {
 
         when(mock.forInteger(leq(5))).thenReturn("");
 
-        assertThat(mock.forInteger(null)).isNull();// a default value must be returned
+        assertThat(mock.forInteger(null)).isNull(); // a default value must be returned
     }
 
     /**
@@ -51,7 +49,7 @@ public void compareNullArgument() {
     public void compareToNonCompareable() {
         when(mock.forObject(leq(5))).thenReturn("");
 
-        assertThat(mock.forObject(NOT_A_COMPARABLE)).isNull();// a default value must be returned
+        assertThat(mock.forObject(NOT_A_COMPARABLE)).isNull(); // a default value must be returned
     }
 
     /**
@@ -61,7 +59,7 @@ public void compareToNonCompareable() {
     public void compareToNull() {
         when(mock.forInteger(leq((Integer) null))).thenReturn("");
 
-        assertThat(mock.forInteger(null)).isNull();// a default value must be returned
+        assertThat(mock.forInteger(null)).isNull(); // a default value must be returned
     }
 
     /**
@@ -71,7 +69,7 @@ public void compareToNull() {
     public void compareToStringVsInt() {
         when(mock.forObject(startsWith("Hello"))).thenReturn("");
 
-        assertThat(mock.forObject(123)).isNull();// a default value must be returned
+        assertThat(mock.forObject(123)).isNull(); // a default value must be returned
     }
 
     @Test
@@ -98,7 +96,6 @@ public boolean matches(Date arg) {
             public boolean matches(Integer arg, Void v) {
                 throw new UnsupportedOperationException();
             }
-
         }
 
         when(mock.forObject(argThat(new TestMatcher()))).thenReturn("x");
@@ -132,5 +129,4 @@ public boolean matches(T argument) {
 
         assertThat(mock.forObject(123)).isNull();
     }
-
 }
diff --git a/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
similarity index 92%
rename from src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
index ffc08ad8e7..46cbb9587a 100644
--- a/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
@@ -39,7 +39,8 @@ public void setUp() {
 
     @Test
     public void shouldSuccessfullyVerifyConcurrentInvocationsWithTimeout() throws Exception {
-        int potentialOverhead = 1000; // Leave 1000ms extra before timing out as leeway for test overheads
+        int potentialOverhead =
+                1000; // Leave 1000ms extra before timing out as leeway for test overheads
         int expectedMaxTestLength = TIMES * INTERVAL_MILLIS + potentialOverhead;
 
         reset(target);
@@ -49,13 +50,11 @@ public void shouldSuccessfullyVerifyConcurrentInvocationsWithTimeout() throws Ex
         verifyNoMoreInteractions(target);
     }
 
-    private void startInvocations() throws InterruptedException,
-            ExecutionException {
+    private void startInvocations() throws InterruptedException, ExecutionException {
 
-        for(int i=0; i<nThreads; i++) {
+        for (int i = 0; i < nThreads; i++) {
             fixedThreadPool.submit(new TargetInvoker(i));
         }
-
     }
 
     public class TargetInvoker implements Callable<Object> {
@@ -75,11 +74,9 @@ public Object call() throws Exception {
             System.err.println("finished" + seq);
             return seq;
         }
-
     }
 
     public interface ITarget {
         String targetMethod(String arg);
     }
-
 }
diff --git a/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
similarity index 80%
rename from src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
index 8d79b54a47..99c638c953 100644
--- a/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
@@ -13,7 +13,8 @@
 public class ConfusedSignatureTest {
 
     @Test
-    public void should_mock_method_which_has_generic_return_type_in_superclass_and_concrete_one_in_interface() {
+    public void
+            should_mock_method_which_has_generic_return_type_in_superclass_and_concrete_one_in_interface() {
         Sub mock = mock(Sub.class);
         // The following line resulted in
         // org.mockito.exceptions.misusing.MissingMethodInvocationException:
@@ -31,12 +32,12 @@ public Super(T value) {
             this.value = value;
         }
 
-        public T getFoo() { return value; }
+        public T getFoo() {
+            return value;
+        }
     }
 
-    public class Sub
-            extends Super<String>
-            implements iInterface {
+    public class Sub extends Super<String> implements iInterface {
 
         public Sub(String s) {
             super(s);
diff --git a/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
similarity index 98%
rename from src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
index 919ec77ec3..91d24867a1 100644
--- a/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
@@ -10,7 +10,7 @@
 import org.junit.Test;
 import org.mockitoutil.TestBase;
 
-//see issue 101
+// see issue 101
 public class CovariantOverrideTest extends TestBase {
 
     public interface ReturnsObject {
diff --git a/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
similarity index 88%
rename from src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
index 4861dd54dd..e678594b82 100644
--- a/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
@@ -31,12 +31,12 @@ public Super(T value) {
             this.value = value;
         }
 
-        public T getFoo() { return value; }
+        public T getFoo() {
+            return value;
+        }
     }
 
-    public class Sub
-            extends Super<String>
-            implements iInterface {
+    public class Sub extends Super<String> implements iInterface {
 
         public Sub(String s) {
             super(s);
diff --git a/src/test/java/org/mockitousage/bugs/EnabledMockingInterfaceCloneMethodTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/EnabledMockingInterfaceCloneMethodTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/bugs/EnabledMockingInterfaceCloneMethodTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/EnabledMockingInterfaceCloneMethodTest.java
diff --git a/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java
diff --git a/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
index a11cae7a67..e22505a133 100644
--- a/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
@@ -42,14 +42,15 @@ public Exception fillInStackTrace() {
         }
     }
 
-    //issue 866
+    // issue 866
     @Test
     public void avoids_NPE() {
         when(mock.simpleMethod()).thenThrow(new NullStackTraceException());
         try {
             mock.simpleMethod();
             fail();
-        } catch(NullStackTraceException e) {}
+        } catch (NullStackTraceException e) {
+        }
     }
 
     @Test
@@ -58,6 +59,7 @@ public void uses_return_value_from_fillInStackTrace() {
         try {
             mock.simpleMethod();
             fail();
-        } catch(SomeException e) {}
+        } catch (SomeException e) {
+        }
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
similarity index 87%
rename from src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
index 5cc91afe6a..a2569ccd63 100644
--- a/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
@@ -19,7 +19,7 @@ public class FinalHashCodeAndEqualsRaiseNPEInInitMocksTest {
 
     @Test
     public void dont_raise_NullPointerException() throws Exception {
-        MockitoAnnotations.initMocks(this);
+        MockitoAnnotations.openMocks(this);
     }
 
     private static class FieldCharsetHolder {
@@ -27,7 +27,6 @@ private static class FieldCharsetHolder {
     }
 
     private static class ConstructorCharsetHolder {
-        public ConstructorCharsetHolder(Charset charset) {
-        }
+        public ConstructorCharsetHolder(Charset charset) {}
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
similarity index 78%
rename from src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
index 1caecec217..7c3f17ebf2 100644
--- a/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
@@ -5,7 +5,7 @@
 package org.mockitousage.bugs;
 
 import static org.mockito.BDDMockito.given;
-import static org.mockito.MockitoAnnotations.initMocks;
+import static org.mockito.MockitoAnnotations.openMocks;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -20,13 +20,13 @@
  */
 public class GenericsMockitoAnnotationsTest {
 
-    @Mock
-    private TestCollectionSourceProvider testCollectionSourceProvider;
+    @Mock private TestCollectionSourceProvider testCollectionSourceProvider;
 
     @Ignore
     @Test
     public void should_not_throw_class_cast_exception() {
-        given(testCollectionSourceProvider.getCollection(new ArrayList<Integer>())).willReturn(new ArrayList<Integer>());
+        given(testCollectionSourceProvider.getCollection(new ArrayList<Integer>()))
+                .willReturn(new ArrayList<Integer>());
     }
 
     static class TestCollectionSourceProvider {
@@ -37,6 +37,6 @@ <T extends Collection<E>, E> T getCollection(T collection) {
 
     @Before
     public void setUp() throws Exception {
-        initMocks(this);
+        openMocks(this);
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
similarity index 95%
rename from src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
index 3d8db84947..4885d24540 100644
--- a/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
@@ -6,7 +6,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
diff --git a/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
new file mode 100644
index 0000000000..69cde9101c
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.verify;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+// see issue 200
+public class InheritedGenericsPolimorphicCallTest extends TestBase {
+
+    protected interface MyIterable<T> extends Iterable<T> {
+        MyIterator<T> iterator();
+    }
+
+    protected interface MyIterator<T> extends Iterator<T> {
+        // adds nothing here
+    }
+
+    MyIterator<String> myIterator = Mockito.mock(MyIterator.class);
+    MyIterable<String> iterable = Mockito.mock(MyIterable.class);
+
+    @Test
+    public void shouldStubbingWork() {
+        Mockito.when(iterable.iterator()).thenReturn(myIterator);
+        assertNotNull(((Iterable<String>) iterable).iterator());
+        assertNotNull(iterable.iterator());
+    }
+
+    @Test
+    public void shouldVerificationWorks() {
+        MyIterator<String> unused = iterable.iterator();
+
+        verify(iterable).iterator();
+        verify((Iterable<String>) iterable).iterator();
+    }
+
+    @Test
+    public void shouldWorkExactlyAsJavaProxyWould() {
+        // given
+        final List<Method> methods = new LinkedList<Method>();
+        InvocationHandler handler =
+                new InvocationHandler() {
+                    public Object invoke(Object proxy, Method method, Object[] args)
+                            throws Throwable {
+                        methods.add(method);
+                        return null;
+                    }
+                };
+
+        iterable =
+                (MyIterable<String>)
+                        Proxy.newProxyInstance(
+                                this.getClass().getClassLoader(),
+                                new Class<?>[] {MyIterable.class},
+                                handler);
+
+        // when
+        MyIterator<String> unused = iterable.iterator();
+        Iterator<String> unused2 = ((Iterable<String>) iterable).iterator();
+
+        // then
+        assertEquals(2, methods.size());
+        assertEquals(methods.get(0), methods.get(1));
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
index a464d442ec..c9b2bcd187 100644
--- a/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
@@ -4,7 +4,6 @@
  */
 package org.mockitousage.bugs;
 
-
 import static org.mockito.Mockito.*;
 
 import java.util.List;
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
new file mode 100644
index 0000000000..312984c764
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+import org.junit.Test;
+import org.junit.internal.TextListener;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitoutil.TestBase;
+
+// @Ignore("for demo only. this test cannot be enabled as it fails :)")
+public class MockitoRunnerBreaksWhenNoTestMethodsTest extends TestBase {
+
+    @Test
+    public void ensure_the_test_runner_breaks() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        //        runner.addListener(new TextListener(System.out));
+        runner.addListener(new TextListener(DevNull.out));
+
+        Result result = runner.run(TestClassWithoutTestMethod.class);
+
+        assertEquals(1, result.getFailureCount());
+        assertTrue(result.getFailures().get(0).getException() instanceof MockitoException);
+        assertFalse(result.wasSuccessful());
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    static class TestClassWithoutTestMethod { // package visibility is important
+        public void notATestMethod() {}
+    }
+
+    public static final class DevNull {
+        public static final PrintStream out =
+                new PrintStream(
+                        new OutputStream() {
+                            public void close() {}
+
+                            public void flush() {}
+
+                            public void write(byte[] b) {}
+
+                            public void write(byte[] b, int off, int len) {}
+
+                            public void write(int b) {}
+                        });
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
new file mode 100644
index 0000000000..1cf92688f0
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockitoutil.TestBase;
+
+/**
+ * @see <a href="https://github.com/mockito/mockito/issues/1279">Issue #1279</a>
+ */
+public class MockitoStubbedCallInAnswerTest extends TestBase {
+
+    @Mock Foo foo;
+    @Mock Bar bar;
+
+    @Test
+    public void stubbing_the_right_mock() throws Exception {
+        // stubbing on different mock should not be altered
+        when(bar.doInt()).thenReturn(0);
+        when(foo.doInt())
+                .thenAnswer(
+                        new Answer<Integer>() {
+                            @Override
+                            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                                return bar.doInt();
+                            }
+                        });
+        assertEquals(0, foo.doInt());
+        assertEquals(0, bar.doInt());
+
+        // when we override the stubbing
+        when(foo.doInt()).thenReturn(1);
+
+        // we expect it to be reflected:
+        assertEquals(1, foo.doInt());
+
+        // but the stubbing on a different mock should not be altered:
+        assertEquals(0, bar.doInt());
+    }
+
+    @Test
+    public void return_type_validation() throws Exception {
+        when(foo.doString())
+                .thenAnswer(
+                        new Answer<String>() {
+                            public String answer(InvocationOnMock invocation) throws Throwable {
+                                // invoking a method on a different mock, with different return type
+                                return String.valueOf(bar.doInt());
+                            }
+                        });
+        assertEquals("0", foo.doString());
+
+        // we can override stubbing without misleading return type validation errors:
+        when(foo.doString()).thenReturn("");
+        assertEquals("", foo.doString());
+    }
+
+    @Test
+    public void prevents_stack_overflow() throws Exception {
+        when(foo.doInt())
+                .thenAnswer(
+                        new Answer<Integer>() {
+                            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                                return bar.doInt();
+                            }
+                        });
+        assertEquals(0, foo.doInt());
+
+        when(foo.doInt())
+                .thenAnswer(
+                        new Answer<Integer>() {
+                            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                                return bar.doInt() + 1;
+                            }
+                        });
+
+        // calling below used to cause SO error
+        assertEquals(1, foo.doInt());
+    }
+
+    @Test
+    public void overriding_stubbing() throws Exception {
+        when(bar.doInt()).thenReturn(10);
+        when(foo.doInt())
+                .thenAnswer(
+                        new Answer<Integer>() {
+                            public Integer answer(InvocationOnMock invocation) throws Throwable {
+                                return bar.doInt() + 1;
+                            }
+                        });
+
+        assertEquals(11, foo.doInt());
+
+        // when we override the stubbing with a different one
+        when(foo.doInt()).thenReturn(100);
+
+        // we expect it to be reflected:
+        assertEquals(100, foo.doInt());
+    }
+
+    interface Foo {
+        String doString();
+
+        int doInt();
+    }
+
+    interface Bar {
+        int doInt();
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
similarity index 91%
rename from src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
index f213ce129e..65472ff903 100644
--- a/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
@@ -17,8 +17,8 @@
 public class MultipleInOrdersTest {
 
     @Test
-    public void inOrderTest(){
-        List<String> list= mock(List.class);
+    public void inOrderTest() {
+        List<String> list = mock(List.class);
 
         list.add("a");
         list.add("x");
diff --git a/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
similarity index 85%
rename from src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
index 36db7a707b..30a8eae8e7 100644
--- a/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
@@ -67,9 +67,9 @@ public void run() {
     }
 
     @Test
-    //this problem shows at 4 out of 5 executions
-    //it is not strictly a bug because Mockito does not support simultanous stubbing (see FAQ)
-    //however I decided to synchronize some calls in order to make the exceptions nicer
+    // this problem shows at 4 out of 5 executions
+    // it is not strictly a bug because Mockito does not support simultanous stubbing (see FAQ)
+    // however I decided to synchronize some calls in order to make the exceptions nicer
     public void tryToRevealTheProblem() {
         ToMock toMock = mock(ToMock.class);
         for (int i = 0; i < 100; i++) {
@@ -77,8 +77,8 @@ public void tryToRevealTheProblem() {
 
             // Repeated mocking
             when(toMock.getValue(i)).thenReturn(j);
-            //TODO make it also showing errors for doReturn()
-//            doReturn(j).when(toMock).getValue(i);
+            // TODO make it also showing errors for doReturn()
+            //            doReturn(j).when(toMock).getValue(i);
 
             while (true) {
                 try {
@@ -91,7 +91,7 @@ public void tryToRevealTheProblem() {
             }
 
             try {
-                Thread.sleep(10 / ((i % 10) + 1)); //NOPMD
+                Thread.sleep(10 / ((i % 10) + 1)); // NOPMD
             } catch (InterruptedException e) {
             }
         }
diff --git a/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
similarity index 96%
rename from src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
index 7b7b4ac347..daa61c7a9c 100644
--- a/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
@@ -9,7 +9,7 @@
 import org.junit.Test;
 import org.mockitoutil.TestBase;
 
-//see issue 221
+// see issue 221
 public class NPEOnAnyClassMatcherAutounboxTest extends TestBase {
 
     interface Foo {
diff --git a/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
similarity index 92%
rename from src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
index 7da0967426..a266efd471 100644
--- a/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
@@ -21,13 +21,14 @@ class DummyException extends RuntimeException {
         private static final long serialVersionUID = 1L;
     }
 
-    //issue 70
+    // issue 70
     @Test
     public void shouldNotThrowNPE() {
         when(mock.simpleMethod()).thenThrow(mock2);
         try {
             mock.simpleMethod();
             fail();
-        } catch(DummyException e) {}
+        } catch (DummyException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
new file mode 100644
index 0000000000..80703202c5
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class NPEWithCertainMatchersTest extends TestBase {
+
+    @Mock IMethods mock;
+
+    @After
+    public void clearState() {
+        this.resetState();
+    }
+
+    @Test
+    public void shouldNotThrowNPEWhenIntegerPassed() {
+        mock.intArgumentMethod(100);
+
+        verify(mock).intArgumentMethod(isA(Integer.class));
+    }
+
+    @Test
+    public void shouldNotThrowNPEWhenIntPassed() {
+        mock.intArgumentMethod(100);
+
+        verify(mock).intArgumentMethod(isA(Integer.class));
+    }
+
+    @Test
+    public void shouldNotThrowNPEWhenIntegerPassedToEq() {
+        mock.intArgumentMethod(100);
+
+        verify(mock).intArgumentMethod(eq(new Integer(100)));
+    }
+
+    @Test
+    public void shouldNotThrowNPEWhenIntegerPassedToSame() {
+        mock.intArgumentMethod(100);
+
+        verify(mock, never()).intArgumentMethod(same(new Integer(100)));
+    }
+
+    @Test
+    public void shouldNotThrowNPEWhenNullPassedToEq() {
+        mock.objectArgMethod("not null");
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).objectArgMethod(eq(null));
+                        })
+                .isInstanceOf(AssertionError.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.objectArgMethod(null);",
+                        "Actual invocations have different arguments:",
+                        "mock.objectArgMethod(\"not null\");");
+    }
+
+    @Test
+    public void shouldNotThrowNPEWhenNullPassedToSame() {
+        mock.objectArgMethod("not null");
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).objectArgMethod(same(null));
+                        })
+                .isInstanceOf(AssertionError.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mock.objectArgMethod(same(null));",
+                        "Actual invocations have different arguments:",
+                        "mock.objectArgMethod(\"not null\");");
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
similarity index 80%
rename from src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
index dafaf393cd..a695be9ce8 100644
--- a/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
@@ -14,59 +14,59 @@
 import org.junit.Test;
 import org.mockitoutil.TestBase;
 
-//see issue 184
+// see issue 184
 public class ShouldMocksCompareToBeConsistentWithEqualsTest extends TestBase {
 
     @Test
     public void should_compare_to_be_consistent_with_equals() {
-        //given
-        Date today    = mock(Date.class);
+        // given
+        Date today = mock(Date.class);
         Date tomorrow = mock(Date.class);
 
-        //when
+        // when
         Set<Date> set = new TreeSet<Date>();
         set.add(today);
         set.add(tomorrow);
 
-        //then
+        // then
         assertEquals(2, set.size());
     }
 
     @Test
     public void should_compare_to_be_consistent_with_equals_when_comparing_the_same_reference() {
-        //given
-        Date today    = mock(Date.class);
+        // given
+        Date today = mock(Date.class);
 
-        //when
+        // when
         Set<Date> set = new TreeSet<Date>();
         set.add(today);
         set.add(today);
 
-        //then
+        // then
         assertEquals(1, set.size());
     }
 
     @Test
     public void should_allow_stubbing_and_verifying_compare_to() {
-        //given
-        Date mock    = mock(Date.class);
+        // given
+        Date mock = mock(Date.class);
         when(mock.compareTo(any(Date.class))).thenReturn(10);
 
-        //when
+        // when
         mock.compareTo(new Date());
 
-        //then
+        // then
         assertEquals(10, mock.compareTo(new Date()));
         verify(mock, atLeastOnce()).compareTo(any(Date.class));
     }
 
     @Test
     public void should_reset_not_remove_default_stubbing() {
-        //given
-        Date mock    = mock(Date.class);
+        // given
+        Date mock = mock(Date.class);
         reset(mock);
 
-        //then
+        // then
         assertEquals(1, mock.compareTo(new Date()));
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
index 7141333697..e1c8dbdab6 100644
--- a/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
@@ -16,7 +16,7 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-//see bug 190
+// see bug 190
 public class ShouldNotDeadlockAnswerExecutionTest {
 
     @Test
@@ -91,7 +91,6 @@ public String answer(InvocationOnMock invocation) throws Throwable {
 
             return null;
         }
-
     }
 
     static class ServiceRunner implements Runnable {
@@ -105,13 +104,10 @@ public ServiceRunner(Service service) {
         public void run() {
             service.verySlowMethod();
         }
-
     }
 
     interface Service {
 
         String verySlowMethod();
-
     }
-
 }
diff --git a/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
index 6793cbaccd..7da4f7ed38 100644
--- a/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
@@ -14,21 +14,21 @@
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-//bug 197
+// bug 197
 public class ShouldOnlyModeAllowCapturingArgumentsTest extends TestBase {
 
     @Mock IMethods mock;
 
     @Test
     public void shouldAllowCapturingArguments() {
-        //given
+        // given
         mock.simpleMethod("o");
         ArgumentCaptor<String> arg = ArgumentCaptor.forClass(String.class);
 
-        //when
+        // when
         verify(mock, only()).simpleMethod(arg.capture());
 
-        //then
+        // then
         assertEquals("o", arg.getValue());
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
similarity index 91%
rename from src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
index ac7a494162..353b405469 100644
--- a/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
@@ -15,20 +15,20 @@
 import org.mockito.Spy;
 import org.mockitoutil.TestBase;
 
-//see issue 216
+// see issue 216
 public class SpyShouldHaveNiceNameTest extends TestBase {
 
     @Spy List<Integer> veryCoolSpy = new LinkedList<Integer>();
 
     @Test
     public void shouldPrintNiceName() {
-        //when
+        // when
         veryCoolSpy.add(1);
 
         try {
             verify(veryCoolSpy).add(2);
             fail();
-        } catch(AssertionError e) {
+        } catch (AssertionError e) {
             Assertions.assertThat(e.getMessage()).contains("veryCoolSpy");
         }
     }
diff --git a/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
similarity index 98%
rename from src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
index ef3fe6c340..19043e4e8f 100644
--- a/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
@@ -10,7 +10,7 @@
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-//issue 151
+// issue 151
 public class StubbingMocksThatAreConfiguredToReturnMocksTest extends TestBase {
 
     @Test
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/ThreadLocalTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/ThreadLocalTest.java
new file mode 100644
index 0000000000..8c113d90a6
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/ThreadLocalTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs;
+
+import static org.mockito.Mockito.RETURNS_MOCKS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+/**
+ * This was an issue reported in #2905. Mocking {@link ThreadLocal} or classes extending {@link ThreadLocal} was
+ * throwing a {@link StackOverflowError}.
+ */
+public class ThreadLocalTest extends TestBase {
+
+    @Test
+    public void mock_ThreadLocal_does_not_raise_StackOverflowError() {
+        StackOverflowError stackOverflowError =
+                Assertions.catchThrowableOfType(
+                        () -> {
+                            mock(ThreadLocal.class, RETURNS_MOCKS);
+                        },
+                        StackOverflowError.class);
+        Assertions.assertThat(stackOverflowError).isNull();
+    }
+
+    @Test
+    public void mock_class_extending_ThreadLocal_does_not_raise_StackOverflowError() {
+        StackOverflowError stackOverflowError =
+                Assertions.catchThrowableOfType(
+                        () -> {
+                            mock(SomeThreadLocal.class, RETURNS_MOCKS);
+                        },
+                        StackOverflowError.class);
+        Assertions.assertThat(stackOverflowError).isNull();
+    }
+
+    @Test
+    public void spy_ThreadLocal_does_not_raise_StackOverflowError() {
+        StackOverflowError stackOverflowError =
+                Assertions.catchThrowableOfType(
+                        () -> {
+                            spy(ThreadLocal.class);
+                        },
+                        StackOverflowError.class);
+        Assertions.assertThat(stackOverflowError).isNull();
+    }
+
+    @Test
+    public void spy_class_extending_ThreadLocal_does_not_raise_StackOverflowError() {
+        StackOverflowError stackOverflowError =
+                Assertions.catchThrowableOfType(
+                        () -> {
+                            spy(SomeThreadLocal.class);
+                        },
+                        StackOverflowError.class);
+        Assertions.assertThat(stackOverflowError).isNull();
+    }
+
+    static class SomeThreadLocal<T> extends ThreadLocal<T> {}
+}
diff --git a/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
similarity index 88%
rename from src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
index dfd2b7cd34..eb64989f68 100644
--- a/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
@@ -13,7 +13,7 @@
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-//see bug 138
+// see bug 138
 public class VerifyingWithAnExtraCallToADifferentMockTest extends TestBase {
 
     @Mock IMethods mock;
@@ -21,17 +21,18 @@ public class VerifyingWithAnExtraCallToADifferentMockTest extends TestBase {
 
     @Test
     public void shouldAllowVerifyingWhenOtherMockCallIsInTheSameLine() {
-        //given
+        // given
         when(mock.otherMethod()).thenReturn("foo");
 
-        //when
+        // when
         mockTwo.simpleMethod("foo");
 
-        //then
+        // then
         verify(mockTwo).simpleMethod(mock.otherMethod());
         try {
             verify(mockTwo, never()).simpleMethod(mock.otherMethod());
             fail();
-        } catch (NeverWantedButInvoked e) {}
+        } catch (NeverWantedButInvoked e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
new file mode 100644
index 0000000000..ccd14d9b29
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.creation;
+
+import java.util.Random;
+
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+@RunWith(Enclosed.class)
+public class ConstructorInvokingMethodShouldNotRaiseExceptionTest {
+
+    public static class WithDumbMethod {
+        @Spy HasConstructorInvokingMethod hasConstructorInvokingMethod;
+
+        @Test
+        public void should_be_able_to_create_spy() throws Exception {
+            MockitoAnnotations.openMocks(this);
+        }
+
+        private static class HasConstructorInvokingMethod {
+            public HasConstructorInvokingMethod() {
+                someMethod();
+            }
+
+            void someMethod() {}
+        }
+    }
+
+    public static class UsingMethodObjectReferenceResult {
+        @Spy HasConstructorInvokingMethod hasConstructorInvokingMethod;
+
+        @Test
+        public void should_be_able_to_create_spy() throws Exception {
+            MockitoAnnotations.openMocks(this);
+        }
+
+        private static class HasConstructorInvokingMethod {
+            private final boolean doesIt;
+
+            public HasConstructorInvokingMethod() {
+                doesIt = someMethod().contains("yup");
+            }
+
+            String someMethod() {
+                return "tada!";
+            }
+        }
+    }
+
+    public static class UsingMethodPrimitiveResult {
+        @Spy HasConstructorInvokingMethod hasConstructorInvokingMethod;
+
+        @Test
+        public void should_be_able_to_create_spy() throws Exception {
+            MockitoAnnotations.openMocks(this);
+        }
+
+        private static class HasConstructorInvokingMethod {
+            private final boolean doesIt;
+
+            public HasConstructorInvokingMethod() {
+                doesIt = someMethod();
+            }
+
+            boolean someMethod() {
+                return new Random().nextBoolean();
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/creation/MockClassWithMissingStaticDepTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/MockClassWithMissingStaticDepTest.java
new file mode 100644
index 0000000000..e6e189514f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/MockClassWithMissingStaticDepTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.creation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+
+// See Issue #3498
+public class MockClassWithMissingStaticDepTest {
+
+    @Test
+    public void shouldNotSwallowClinitErrorOfClassToMock() {
+        try {
+            @SuppressWarnings("unused")
+            var unused = Mockito.mock(ClassWithErrorInClassInit.class);
+
+            fail();
+        } catch (MockitoException e) {
+            var cause = e.getCause();
+            assertThat(cause).isInstanceOf(MockitoException.class);
+            assertThat(cause.getMessage())
+                    .isEqualTo(
+                            "Cannot instrument class org.mockitousage.bugs.creation.MockClassWithMissingStaticDepTest$ClassWithErrorInClassInit because it or one of its supertypes could not be initialized");
+
+            var cause2 = cause.getCause();
+            assertThat(cause2).isInstanceOf(NoClassDefFoundError.class);
+            assertThat(cause2.getMessage())
+                    .isEqualTo("Simulate missing transitive dependency used in class init.");
+        } catch (NoClassDefFoundError ex) {
+            // Note: mock-maker-subclass will throw the NoClassDefFoundError as is
+            assertThat(ex.getMessage())
+                    .isEqualTo("Simulate missing transitive dependency used in class init.");
+        }
+    }
+
+    private static class ClassWithErrorInClassInit {
+        static {
+            //noinspection ConstantValue
+            if (true) {
+                throw new NoClassDefFoundError(
+                        "Simulate missing transitive dependency used in class init.");
+            }
+        }
+    }
+
+    @Test
+    public void shouldNotSwallowClinitExceptionOfClassToMock() {
+        try {
+            @SuppressWarnings("unused")
+            var unused = Mockito.mock(ClassWithExceptionInClassInit.class);
+
+            fail();
+        } catch (MockitoException e) {
+            var cause = e.getCause();
+            assertThat(cause).isInstanceOf(MockitoException.class);
+            assertThat(cause.getMessage())
+                    .isEqualTo(
+                            "Cannot instrument class org.mockitousage.bugs.creation.MockClassWithMissingStaticDepTest$ClassWithExceptionInClassInit because it or one of its supertypes could not be initialized");
+
+            var cause2 = cause.getCause();
+            assertThat(cause2).isInstanceOf(IllegalStateException.class);
+            assertThat(cause2.getMessage()).isEqualTo("Exception in class init.");
+        } catch (ExceptionInInitializerError ex) {
+            // Note: mock-maker-subclass will throw the ExceptionInInitializerError as is
+            var cause = ex.getCause();
+            assertThat(cause).isInstanceOf(IllegalStateException.class);
+            assertThat(cause.getMessage()).isEqualTo("Exception in class init.");
+        }
+    }
+
+    private static class ClassWithExceptionInClassInit {
+        static {
+            //noinspection ConstantValue
+            if (true) {
+                throw new IllegalStateException("Exception in class init.");
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/creation/PackagePrivateWithContextClassLoaderTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/PackagePrivateWithContextClassLoaderTest.java
new file mode 100644
index 0000000000..95095f32f4
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/PackagePrivateWithContextClassLoaderTest.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.creation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/** Regression tests for issue #2303*/
+public class PackagePrivateWithContextClassLoaderTest {
+
+    private ClassLoader oldContextClassloader;
+
+    public abstract static class PublicClass {
+        int packagePrivateMethod() {
+            return 0;
+        }
+
+        abstract void packagePrivateAbstractMethod();
+    }
+
+    public interface PublicInterfaceWithPackagePrivateMethodParam {
+        void doSomething(PackagePrivateInterface i);
+    }
+
+    public interface PublicInterfaceWithPackagePrivateMethodReturn {
+        PackagePrivateInterface doSomething();
+    }
+
+    public interface PublicInterfaceOverridesPackagePrivateMethodReturn {
+        PublicChildOfPackagePrivate doSomething();
+    }
+
+    public interface PublicInterface {}
+
+    interface PackagePrivateInterface {}
+
+    public interface PublicChildOfPackagePrivate extends PackagePrivateInterface {}
+
+    static class PackagePrivateClass {}
+
+    @Before
+    public void setUp() {
+        oldContextClassloader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(new ClassLoader(oldContextClassloader) {});
+    }
+
+    @After
+    public void teardown() {
+        Thread.currentThread().setContextClassLoader(oldContextClassloader);
+    }
+
+    @Test
+    public void should_be_able_to_mock_package_private_method() throws Exception {
+        PublicClass publicClass = mock(PublicClass.class);
+        when(publicClass.packagePrivateMethod()).thenReturn(3);
+        assertThat(publicClass.packagePrivateMethod()).isEqualTo(3);
+    }
+
+    @Test
+    public void should_be_able_to_mock_interface_method_package_private_param() throws Exception {
+        PublicInterfaceWithPackagePrivateMethodParam publicClass =
+                mock(PublicInterfaceWithPackagePrivateMethodParam.class);
+        publicClass.doSomething(null);
+    }
+
+    @Test
+    public void should_be_able_to_mock_interface_method_package_private_return() throws Exception {
+        PublicInterfaceWithPackagePrivateMethodReturn publicClass =
+                mock(PublicInterfaceWithPackagePrivateMethodReturn.class);
+        PackagePrivateInterface packagePrivateInterface = publicClass.doSomething();
+    }
+
+    @Test
+    public void should_be_able_to_mock_interface_method_package_private_return_override()
+            throws Exception {
+        PublicInterfaceOverridesPackagePrivateMethodReturn publicClass =
+                mock(PublicInterfaceOverridesPackagePrivateMethodReturn.class);
+        PackagePrivateInterface packagePrivateInterface = publicClass.doSomething();
+    }
+
+    @Test
+    public void should_be_able_to_mock_package_private_class() throws Exception {
+        PackagePrivateClass mock = mock(PackagePrivateClass.class);
+    }
+
+    @Test
+    public void should_be_able_to_mock_package_private_interface() throws Exception {
+        PackagePrivateInterface mock = mock(PackagePrivateInterface.class);
+    }
+
+    @Test
+    public void should_be_able_to_mock_package_private_extra_interface() throws Exception {
+        PackagePrivateInterface mock =
+                (PackagePrivateInterface)
+                        mock(
+                                PublicInterface.class,
+                                withSettings().extraInterfaces(PackagePrivateInterface.class));
+    }
+
+    /**
+     * In this test we have a class that delegates loading of mockito/JDK classes to its parent,
+     * but defines in its own for others. If mockito selects the defining classloader of the mock
+     * to the classloader of mockito, calling the abstract package-private method will fail - the
+     * defining classloader of the mocked type's package is different from the generated mock class
+     * package. Because the nonDelegatingLoader is a child of mockito's loader, it's more specific
+     * and should be preferred.
+     */
+    @Test
+    public void classloader_with_parent_but_does_not_delegate() throws Exception {
+        ClassLoader nonDelegatingLoader = new NotAlwaysDelegatingClassLoader();
+        Thread.currentThread().setContextClassLoader(nonDelegatingLoader);
+        Class<?> loaded =
+                Class.forName(LoadedByCustomLoader.class.getName(), false, nonDelegatingLoader);
+        Method attemptMock = loaded.getDeclaredMethod("attemptMock");
+        attemptMock.invoke(null);
+    }
+
+    public static class LoadedByCustomLoader {
+        public static void attemptMock() {
+            PublicClass mock = mock(PublicClass.class);
+            mock.packagePrivateAbstractMethod();
+        }
+    }
+
+    /**
+     * This classloader has a parent, but doesn't always delegate to it.
+     */
+    public static final class NotAlwaysDelegatingClassLoader extends ClassLoader {
+
+        /**
+         * Initial size of buffer used to read class data.
+         */
+        /*  Note: should be enough for most classes, and is not a hard limit. */
+        private static final int BUF_SIZE = 4096;
+
+        public NotAlwaysDelegatingClassLoader() {
+            super(NotAlwaysDelegatingClassLoader.class.getClassLoader());
+        }
+
+        @Override
+        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+            // First, check if the class has already been loaded. If not, load it
+            // ourselves or delegate to the parent.
+            Class<?> result = findLoadedClass(name);
+            if (result == null) {
+                // All classes defined in this testsuite should be loaded by this classloader,
+                // but any other class (e.g. those coming from java.* or org.mockito.* packages)
+                // will be loaded by the parent.
+                if (name.startsWith("org.mockitousage.")) {
+                    result = findClass(name);
+                } else {
+                    return super.loadClass(name, resolve);
+                }
+            }
+            if (resolve) {
+                resolveClass(result);
+            }
+            return result;
+        }
+
+        @Override
+        public Class<?> findClass(String className) throws ClassNotFoundException {
+            try {
+                // Create a package for this class, unless it's in the default package.
+                int dotpos = className.lastIndexOf('.');
+                if (dotpos != -1) {
+                    String pkgname = className.substring(0, dotpos);
+                    if (getPackage(pkgname) == null) {
+                        definePackage(pkgname, null, null, null, null, null, null, null);
+                    }
+                }
+                String resourceName = className.replace('.', File.separatorChar) + ".class";
+                InputStream input = getSystemResourceAsStream(resourceName);
+                if (input == null) {
+                    throw new ClassNotFoundException("Couldn't find resource " + resourceName);
+                }
+                byte[] classData = loadClassData(input);
+                return defineClass(className, classData, 0, classData.length, null);
+            } catch (IOException e) {
+                throw new ClassNotFoundException("Cannot load " + className, e);
+            }
+        }
+
+        /**
+         * Load class data from a given input stream.
+         */
+        private byte[] loadClassData(InputStream input) throws IOException {
+            ByteArrayOutputStream output = new ByteArrayOutputStream(BUF_SIZE);
+            byte[] buffer = new byte[BUF_SIZE];
+            int readCount;
+            while ((readCount = input.read(buffer, 0, BUF_SIZE)) >= 0) {
+                output.write(buffer, 0, readCount);
+            }
+            return output.toByteArray();
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
index 5a5e43d4d4..93c77e4733 100644
--- a/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
@@ -4,7 +4,6 @@
  */
 package org.mockitousage.bugs.creation;
 
-
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.mockitousage.bugs.creation.api.PublicClass;
diff --git a/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
similarity index 97%
rename from src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
index 5ba878b047..fab68e3385 100644
--- a/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
@@ -15,7 +15,7 @@
 import org.mockito.Mock;
 import org.mockitoutil.TestBase;
 
-//see issue 191
+// see issue 191
 public class ShouldAllowInlineMockCreationTest extends TestBase {
 
     @Mock List list;
diff --git a/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
similarity index 81%
rename from src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
index 834ef86c0a..048208c627 100644
--- a/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
@@ -6,5 +6,4 @@
 
 import org.mockitousage.bugs.creation.otherpackage.PublicParentClass;
 
-public class PublicClass extends PublicParentClass {
-}
+public class PublicClass extends PublicParentClass {}
diff --git a/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java b/mockito-core/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
similarity index 85%
rename from src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
index df7f79a3dc..3de5f2cf51 100644
--- a/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
@@ -5,6 +5,7 @@
 package org.mockitousage.bugs.creation.otherpackage;
 
 public class PublicParentClass {
-    public void method_with_non_public_argument(PackageLocalArg arg) { }
-    static class PackageLocalArg { }
+    public void method_with_non_public_argument(PackageLocalArg arg) {}
+
+    static class PackageLocalArg {}
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
new file mode 100644
index 0000000000..ac9029cdc4
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.deepstubs;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+public class DeepStubFailingWhenGenericNestedAsRawTypeTest {
+
+    interface MyClass1<MC2 extends MyClass2> {
+        MC2 getNested();
+    }
+
+    interface MyClass2<MC3 extends MyClass3> {
+        MC3 getNested();
+    }
+
+    interface MyClass3 {
+        String returnSomething();
+    }
+
+    @Test
+    public void discoverDeepMockingOfGenerics() {
+        MyClass1 myMock1 = mock(MyClass1.class, RETURNS_DEEP_STUBS);
+        when(myMock1.getNested().getNested().returnSomething()).thenReturn("Hello World.");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java
new file mode 100644
index 0000000000..7f61dc68a5
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.deepstubs;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+
+/**
+ * In GH issue 99 : https://github.com/mockito/mockito/issues/99
+ */
+public class DeepStubsWronglyReportsSerializationProblemsTest {
+
+    @Test
+    public void
+            should_not_raise_a_mockito_exception_about_serialization_when_accessing_deep_stub() {
+        NotSerializableShouldBeMocked the_deep_stub =
+                mock(ToBeDeepStubbed.class, RETURNS_DEEP_STUBS).getSomething();
+        assertThat(the_deep_stub).isNotNull();
+    }
+
+    public static class ToBeDeepStubbed {
+        public ToBeDeepStubbed() {}
+
+        public NotSerializableShouldBeMocked getSomething() {
+            return null;
+        }
+    }
+
+    public static class NotSerializableShouldBeMocked {
+        NotSerializableShouldBeMocked(String mandatory_param) {}
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
similarity index 89%
rename from src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
index c58ebb4975..8570db1790 100644
--- a/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
@@ -15,11 +15,9 @@
 // issue 289
 @RunWith(MockitoJUnitRunner.class)
 public class ChildWithSameParentFieldInjectionTest {
-    @InjectMocks
-    private System system;
+    @InjectMocks private System system;
 
-    @Mock
-    private SomeService someService;
+    @Mock private SomeService someService;
 
     @Test
     public void parent_field_is_not_null() {
@@ -48,7 +46,6 @@ public void doSomething() {
     }
 
     public static class SomeService {
-        public void doSomething() {
-        }
+        public void doSomething() {}
     }
 }
diff --git a/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
index bf3c797278..0869f581bb 100644
--- a/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
@@ -44,5 +44,4 @@ public void setPropertySetterAccess(List<?> propertySetterAccess) {
             propertySetterUsed = true;
         }
     }
-
 }
diff --git a/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
index 1ad4eb44cb..5a8b41571b 100644
--- a/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
@@ -22,7 +22,10 @@ public class InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest {
     @Mock private Bean mockedBean;
 
     @InjectMocks private Service illegalInjectionExample = new Service();
-    @InjectMocks private ServiceWithReversedOrder reversedOrderService = new ServiceWithReversedOrder();
+
+    @InjectMocks
+    private ServiceWithReversedOrder reversedOrderService = new ServiceWithReversedOrder();
+
     @InjectMocks private WithNullObjectField withNullObjectField = new WithNullObjectField();
 
     @Test
@@ -63,7 +66,7 @@ public static class ServiceWithReversedOrder {
         public final Object mockShouldNotGoInHere = REFERENCE;
     }
 
-    class WithNullObjectField{
+    class WithNullObjectField {
         Bean injectMePlease;
         Object keepMeNull = null;
     }
diff --git a/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
similarity index 76%
rename from src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
index 434abe1d03..3023e32f2b 100644
--- a/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
@@ -4,7 +4,6 @@
  */
 package org.mockitousage.bugs.injection;
 
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertSame;
 
@@ -24,8 +23,12 @@ public class Issue353InjectionMightNotHappenInCertainConfigurationTest {
     @InjectMocks FooService fooService;
 
     @Test
-    public void when_identical_types_and_the_correct_mock_name_is_greater_than_the_non_matching_name_then_injection_occurs_only_on_the_named_one() {
-        assertThat("stringString_that_matches_field".compareTo("mockStringInteger_was_not_injected")).isGreaterThanOrEqualTo(1);
+    public void
+            when_identical_types_and_the_correct_mock_name_is_greater_than_the_non_matching_name_then_injection_occurs_only_on_the_named_one() {
+        assertThat(
+                        "stringString_that_matches_field"
+                                .compareTo("mockStringInteger_was_not_injected"))
+                .isGreaterThanOrEqualTo(1);
 
         assertSame(stringString_that_matches_field, fooService.stringString_that_matches_field);
         assertSame(mockStringInteger_was_not_injected, fooService.stringInteger_field);
@@ -35,5 +38,4 @@ public static class FooService {
         Map<String, Integer> stringInteger_field = new HashMap<String, Integer>();
         Map<String, String> stringString_that_matches_field = new HashMap<String, String>();
     }
-
 }
diff --git a/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
similarity index 88%
rename from src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
index ec56b7e9a7..6c118808aa 100644
--- a/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
@@ -19,7 +19,7 @@ public class ParentTestMockInjectionTest {
     @Test
     public void injectMocksShouldInjectMocksFromTestSuperClasses() {
         ImplicitTest it = new ImplicitTest();
-        MockitoAnnotations.initMocks(it);
+        MockitoAnnotations.openMocks(it);
 
         assertNotNull(it.daoFromParent);
         assertNotNull(it.daoFromSub);
@@ -28,7 +28,7 @@ public void injectMocksShouldInjectMocksFromTestSuperClasses() {
     }
 
     @Ignore
-    public static abstract class BaseTest {
+    public abstract static class BaseTest {
         @Mock protected DaoA daoFromParent;
     }
 
@@ -40,7 +40,7 @@ public static class ImplicitTest extends BaseTest {
 
         @Before
         public void setup() {
-            MockitoAnnotations.initMocks(this);
+            MockitoAnnotations.openMocks(this);
         }
 
         @Test
@@ -59,13 +59,11 @@ public void businessMethod() {
         }
     }
 
-
     public static class DaoA {
-        public void doQuery() { }
+        public void doQuery() {}
     }
 
     public static class DaoB {
-        public void doQuery() { }
+        public void doQuery() {}
     }
-
 }
diff --git a/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
index 1da31290da..c98103d996 100644
--- a/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
@@ -30,12 +30,10 @@ public static class ExampleService {
     @InjectMocks private ExampleService exampleService = new ExampleService();
 
     @Test
-    public void dont_fail_with_CONSTANTS() throws Exception {
-    }
+    public void dont_fail_with_CONSTANTS() throws Exception {}
 
     @Test
     public void dont_inject_in_final() {
         assertNotSame(unrelatedSet, exampleService.aSet);
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyPicksUpExtraInvocationsTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyPicksUpExtraInvocationsTest.java
new file mode 100644
index 0000000000..c08bdf0643
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyPicksUpExtraInvocationsTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.varargs;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
+public class VarargsAndAnyPicksUpExtraInvocationsTest extends TestBase {
+    public interface TableBuilder {
+        void newRow(String trAttributes, String... cells);
+    }
+
+    @Mock TableBuilder table;
+
+    @Test
+    public void shouldVerifyCorrectlyWithAny() {
+        // when
+        table.newRow("qux", "foo", "bar", "baz");
+        table.newRow("abc", "def");
+
+        // then
+        verify(table, times(2)).newRow(anyString(), any(String[].class));
+    }
+
+    @Test
+    public void shouldVerifyCorrectlyNumberOfInvocationsUsingAnyAndEqualArgument() {
+        // when
+        table.newRow("x", "foo", "bar", "baz");
+        table.newRow("x", "def");
+
+        // then
+        verify(table, times(2)).newRow(eq("x"), any(String[].class));
+    }
+
+    @Test
+    public void shouldVerifyCorrectlyNumberOfInvocationsWithVarargs() {
+        // when
+        table.newRow("qux", "foo", "bar", "baz");
+        table.newRow("abc", "def");
+
+        // then
+        verify(table).newRow(anyString(), eq("foo"), anyString(), anyString());
+        verify(table).newRow(anyString(), anyString());
+    }
+}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java b/mockito-core/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
similarity index 92%
rename from src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
rename to mockito-core/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
index bc11f92273..22382211a8 100644
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
@@ -13,7 +13,7 @@
 public class VarargsErrorWhenCallingRealMethodTest extends TestBase {
 
     class Foo {
-        int blah(String a, String b, Object ... c) {
+        int blah(String a, String b, Object... c) {
             return 1;
         }
     }
diff --git a/mockito-core/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java b/mockito-core/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
new file mode 100644
index 0000000000..6c08198864
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.configuration;
+
+import static org.mockito.Mockito.mock;
+
+import java.util.concurrent.Callable;
+
+import org.junit.Test;
+import org.mockito.internal.configuration.ConfigurationAccess;
+import org.mockitoutil.SimplePerRealmReloadingClassLoader;
+
+public class ClassCacheVersusClassReloadingTest {
+    // TODO refactor to use ClassLoaders
+
+    private SimplePerRealmReloadingClassLoader testMethodClassLoaderRealm =
+            new SimplePerRealmReloadingClassLoader(reloadMockito());
+
+    @Test
+    public void should_not_throw_ClassCastException_when_objenesis_cache_disabled()
+            throws Exception {
+        prepareMockitoAndDisableObjenesisCache();
+
+        doInNewChildRealm(
+                testMethodClassLoaderRealm,
+                "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
+        doInNewChildRealm(
+                testMethodClassLoaderRealm,
+                "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
+    }
+
+    public static class DoTheMocking implements Callable<Object> {
+        public Object call() throws Exception {
+            Class<?> clazz =
+                    this.getClass()
+                            .getClassLoader()
+                            .loadClass("org.mockitousage.configuration.ClassToBeMocked");
+            return mock(clazz);
+        }
+    }
+
+    private static void doInNewChildRealm(
+            ClassLoader parentRealm, String callableCalledInClassLoaderRealm) throws Exception {
+        new SimplePerRealmReloadingClassLoader(parentRealm, reloadScope())
+                .doInRealm(callableCalledInClassLoaderRealm);
+    }
+
+    private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadScope() {
+        return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
+            public boolean acceptReloadOf(String qualifiedName) {
+                return "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking"
+                                .equals(qualifiedName)
+                        || "org.mockitousage.configuration.ClassToBeMocked".equals(qualifiedName);
+            }
+        };
+    }
+
+    private void prepareMockitoAndDisableObjenesisCache() throws Exception {
+        testMethodClassLoaderRealm.doInRealm(
+                "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$PrepareMockito");
+    }
+
+    public static class PrepareMockito implements Callable<Boolean> {
+        public Boolean call() throws Exception {
+            Class.forName("org.mockito.Mockito");
+            ConfigurationAccess.getConfig().overrideEnableClassCache(false);
+            return Boolean.TRUE;
+        }
+    }
+
+    private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadMockito() {
+        return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
+            public boolean acceptReloadOf(String qualifiedName) {
+                return (!qualifiedName.contains("net.bytebuddy")
+                        && qualifiedName.contains("org.mockito")
+                        && !qualifiedName.contains(
+                                "org.mockito.internal.creation.bytebuddy.inject"));
+            }
+        };
+    }
+}
diff --git a/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java b/mockito-core/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
similarity index 87%
rename from src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
rename to mockito-core/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
index adc863d6ee..fbb852d894 100644
--- a/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
+++ b/mockito-core/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
@@ -7,4 +7,4 @@
 /**
  * Some class to mock that is created via Class.forClass
  */
-public class ClassToBeMocked { }
+public class ClassToBeMocked {}
diff --git a/mockito-core/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java b/mockito-core/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
new file mode 100644
index 0000000000..76dbacbad1
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.constructor;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.mock.SerializableMode;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class CreatingMocksWithConstructorTest extends TestBase {
+
+    abstract static class AbstractMessage {
+        private final String message;
+
+        AbstractMessage() {
+            this.message = "hey!";
+        }
+
+        AbstractMessage(String message) {
+            this.message = message;
+        }
+
+        AbstractMessage(int i) {
+            this.message = String.valueOf(i);
+        }
+
+        String getMessage() {
+            return message;
+        }
+    }
+
+    static class Message extends AbstractMessage {}
+
+    class InnerClass extends AbstractMessage {}
+
+    @Test
+    public void can_create_mock_with_constructor() {
+        Message mock =
+                mock(
+                        Message.class,
+                        withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+        // the message is a part of state of the mocked type that gets initialized in constructor
+        assertEquals("hey!", mock.getMessage());
+    }
+
+    @Test
+    public void can_mock_abstract_classes() {
+        AbstractMessage mock =
+                mock(
+                        AbstractMessage.class,
+                        withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("hey!", mock.getMessage());
+    }
+
+    @Test
+    public void can_spy_abstract_classes() {
+        AbstractMessage mock = spy(AbstractMessage.class);
+        assertEquals("hey!", mock.getMessage());
+    }
+
+    @Test
+    public void can_spy_abstract_classes_with_constructor_args() {
+        AbstractMessage mock =
+                mock(
+                        AbstractMessage.class,
+                        withSettings().useConstructor("hello!").defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("hello!", mock.getMessage());
+    }
+
+    @Test
+    public void can_spy_abstract_classes_with_constructor_primitive_args() {
+        AbstractMessage mock =
+                mock(
+                        AbstractMessage.class,
+                        withSettings().useConstructor(7).defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("7", mock.getMessage());
+    }
+
+    @Test
+    public void can_spy_abstract_classes_with_constructor_array_of_nulls() {
+        AbstractMessage mock =
+                mock(
+                        AbstractMessage.class,
+                        withSettings()
+                                .useConstructor(new Object[] {null})
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertNull(mock.getMessage());
+    }
+
+    @Test
+    public void can_spy_abstract_classes_with_casted_null() {
+        AbstractMessage mock =
+                mock(
+                        AbstractMessage.class,
+                        withSettings()
+                                .useConstructor((String) null)
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertNull(mock.getMessage());
+    }
+
+    @Test
+    public void can_spy_abstract_classes_with_null_varargs() {
+        try {
+            mock(
+                    AbstractMessage.class,
+                    withSettings().useConstructor(null).defaultAnswer(CALLS_REAL_METHODS));
+            fail();
+        } catch (IllegalArgumentException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "constructorArgs should not be null. "
+                                    + "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
+        }
+    }
+
+    @Test
+    public void can_mock_inner_classes() {
+        InnerClass mock =
+                mock(
+                        InnerClass.class,
+                        withSettings()
+                                .useConstructor()
+                                .outerInstance(this)
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("hey!", mock.getMessage());
+    }
+
+    public static class ThrowingConstructorClass {
+        public ThrowingConstructorClass() {
+            throw new RuntimeException();
+        }
+    }
+
+    @Test
+    public void explains_constructor_exceptions() {
+        try {
+            mock(
+                    ThrowingConstructorClass.class,
+                    withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e).hasRootCauseInstanceOf(RuntimeException.class);
+            assertThat(e.getCause())
+                    .hasMessageContaining(
+                            "Please ensure the target class has a 0-arg constructor and executes cleanly.");
+        }
+    }
+
+    static class HasConstructor {
+        HasConstructor(String x) {}
+    }
+
+    @Test
+    public void exception_message_when_constructor_not_found() {
+        try {
+            // when
+            spy(HasConstructor.class);
+            // then
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e).hasMessage("Unable to create mock instance of type 'HasConstructor'");
+            assertThat(e.getCause())
+                    .hasMessageContaining(
+                            "Please ensure that the target class has a 0-arg constructor.");
+        }
+    }
+
+    static class Base {}
+
+    static class ExtendsBase extends Base {}
+
+    static class ExtendsExtendsBase extends ExtendsBase {}
+
+    static class UsesBase {
+        public UsesBase(Base b) {
+            constructorUsed = "Base";
+        }
+
+        public UsesBase(ExtendsBase b) {
+            constructorUsed = "ExtendsBase";
+        }
+
+        private String constructorUsed = null;
+
+        String getConstructorUsed() {
+            return constructorUsed;
+        }
+    }
+
+    @Test
+    public void can_mock_unambigous_constructor_with_inheritance_base_class_exact_match() {
+        UsesBase u =
+                mock(
+                        UsesBase.class,
+                        withSettings()
+                                .useConstructor(new Base())
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("Base", u.getConstructorUsed());
+    }
+
+    @Test
+    public void can_mock_unambigous_constructor_with_inheritance_extending_class_exact_match() {
+        UsesBase u =
+                mock(
+                        UsesBase.class,
+                        withSettings()
+                                .useConstructor(new ExtendsBase())
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("ExtendsBase", u.getConstructorUsed());
+    }
+
+    @Test
+    public void can_mock_unambigous_constructor_with_inheritance_non_exact_match() {
+        UsesBase u =
+                mock(
+                        UsesBase.class,
+                        withSettings()
+                                .useConstructor(new ExtendsExtendsBase())
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("ExtendsBase", u.getConstructorUsed());
+    }
+
+    static class UsesTwoBases {
+        public UsesTwoBases(Base b1, Base b2) {
+            constructorUsed = "Base,Base";
+        }
+
+        public UsesTwoBases(ExtendsBase b1, Base b2) {
+            constructorUsed = "ExtendsBase,Base";
+        }
+
+        public UsesTwoBases(Base b1, ExtendsBase b2) {
+            constructorUsed = "Base,ExtendsBase";
+        }
+
+        private String constructorUsed = null;
+
+        String getConstructorUsed() {
+            return constructorUsed;
+        }
+    }
+
+    @Test
+    public void can_mock_unambigous_constructor_with_inheritance_multiple_base_class_exact_match() {
+        UsesTwoBases u =
+                mock(
+                        UsesTwoBases.class,
+                        withSettings()
+                                .useConstructor(new Base(), new Base())
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("Base,Base", u.getConstructorUsed());
+    }
+
+    @Test
+    public void
+            can_mock_unambigous_constructor_with_inheritance_first_extending_class_exact_match() {
+        UsesTwoBases u =
+                mock(
+                        UsesTwoBases.class,
+                        withSettings()
+                                .useConstructor(new ExtendsBase(), new Base())
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("ExtendsBase,Base", u.getConstructorUsed());
+    }
+
+    @Test
+    public void
+            can_mock_unambigous_constructor_with_inheritance_second_extending_class_exact_match() {
+        UsesTwoBases u =
+                mock(
+                        UsesTwoBases.class,
+                        withSettings()
+                                .useConstructor(new Base(), new ExtendsBase())
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("Base,ExtendsBase", u.getConstructorUsed());
+    }
+
+    @Test
+    public void fail_when_multiple_matching_constructors_with_inheritence() {
+        try {
+            // when
+            mock(
+                    UsesTwoBases.class,
+                    withSettings().useConstructor(new ExtendsBase(), new ExtendsBase()));
+            // then
+            fail();
+        } catch (MockitoException e) {
+            // TODO the exception message includes Mockito internals like the name of the generated
+            // class name.
+            // I suspect that we could make this exception message nicer.
+            assertThat(e).hasMessage("Unable to create mock instance of type 'UsesTwoBases'");
+            assertThat(e.getCause())
+                    .hasMessageContaining(
+                            "Multiple constructors could be matched to arguments of types "
+                                    + "[org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase, "
+                                    + "org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase]")
+                    .hasMessageContaining(
+                            "If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.\n"
+                                    + "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.\n"
+                                    + "See https://github.com/mockito/mockito/issues/685");
+        }
+    }
+
+    @Test
+    public void mocking_inner_classes_with_wrong_outer_instance() {
+        try {
+            // when
+            mock(
+                    InnerClass.class,
+                    withSettings()
+                            .useConstructor()
+                            .outerInstance(123)
+                            .defaultAnswer(CALLS_REAL_METHODS));
+            // then
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e).hasMessage("Unable to create mock instance of type 'InnerClass'");
+            // TODO it would be nice if all useful information was in the top level exception,
+            // instead of in the exception's cause
+            // also applies to other scenarios in this test
+            assertThat(e.getCause())
+                    .hasMessageContaining(
+                            "Please ensure that the target class has a 0-arg constructor"
+                                    + " and provided outer instance is correct.");
+        }
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void mocking_interfaces_with_constructor() {
+        // at the moment this is allowed however we can be more strict if needed
+        // there is not much sense in creating a spy of an interface
+        mock(IMethods.class, withSettings().useConstructor());
+        spy(IMethods.class);
+    }
+
+    @Test
+    public void prevents_across_jvm_serialization_with_constructor() {
+        try {
+            // when
+            mock(
+                    AbstractMessage.class,
+                    withSettings()
+                            .useConstructor()
+                            .serializable(SerializableMode.ACROSS_CLASSLOADERS));
+            // then
+            fail();
+        } catch (MockitoException e) {
+            assertEquals(
+                    "Mocks instantiated with constructor cannot be combined with "
+                            + SerializableMode.ACROSS_CLASSLOADERS
+                            + " serialization mode.",
+                    e.getMessage());
+        }
+    }
+
+    abstract static class AbstractThing {
+        abstract String name();
+
+        String fullName() {
+            return "abstract " + name();
+        }
+    }
+
+    @Test
+    public void abstract_method_returns_default() {
+        AbstractThing thing = spy(AbstractThing.class);
+        assertEquals("abstract null", thing.fullName());
+    }
+
+    @Test
+    public void abstract_method_stubbed() {
+        AbstractThing thing = spy(AbstractThing.class);
+        when(thing.name()).thenReturn("me");
+        assertEquals("abstract me", thing.fullName());
+    }
+
+    @Test
+    public void interface_method_stubbed() {
+        List<?> list = spy(List.class);
+        when(list.size()).thenReturn(12);
+        assertEquals(12, list.size());
+    }
+
+    @Test
+    public void calls_real_interface_method() {
+        List list = mock(List.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));
+        assertNull(list.get(1));
+    }
+
+    @Test
+    public void handles_bridge_methods_correctly() {
+        SomeConcreteClass<Integer> testBug = spy(new SomeConcreteClass<Integer>());
+        assertEquals("value", testBug.getValue(0));
+    }
+
+    @Test
+    public void forbid_spy_on_mock() {
+        try {
+            spy(mock(List.class));
+            fail();
+        } catch (IllegalArgumentException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "Please don't pass mock here. Spy is not allowed on mock.");
+        }
+    }
+
+    public abstract class SomeAbstractClass<T> {
+
+        protected abstract String getRealValue(T value);
+
+        public String getValue(T value) {
+            return getRealValue(value);
+        }
+    }
+
+    public class SomeConcreteClass<T extends Number> extends SomeAbstractClass<T> {
+
+        @Override
+        protected String getRealValue(T value) {
+            return "value";
+        }
+    }
+
+    private static class AmbiguousWithPrimitive {
+        public AmbiguousWithPrimitive(String s, int i) {
+            data = s;
+        }
+
+        public AmbiguousWithPrimitive(Object o, int i) {
+            data = "just an object";
+        }
+
+        private String data;
+
+        public String getData() {
+            return data;
+        }
+    }
+
+    @Test
+    public void can_spy_ambiguius_constructor_with_primitive() {
+        AmbiguousWithPrimitive mock =
+                mock(
+                        AmbiguousWithPrimitive.class,
+                        withSettings()
+                                .useConstructor("String", 7)
+                                .defaultAnswer(CALLS_REAL_METHODS));
+        assertEquals("String", mock.getData());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/customization/BDDMockitoTest.java b/mockito-core/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
new file mode 100644
index 0000000000..89f85fbf5b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.customization;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.anyString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.inOrder;
+import static org.mockito.BDDMockito.mock;
+import static org.mockito.BDDMockito.then;
+import static org.mockito.BDDMockito.times;
+import static org.mockito.BDDMockito.willAnswer;
+import static org.mockito.BDDMockito.willCallRealMethod;
+import static org.mockito.BDDMockito.willDoNothing;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.BDDMockito.willThrow;
+
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.stubbing.Answer;
+import org.mockitousage.IMethods;
+import org.mockitousage.MethodsImpl;
+import org.mockitoutil.TestBase;
+
+public class BDDMockitoTest extends TestBase {
+
+    @Mock IMethods mock;
+
+    @Test
+    public void should_stub() {
+        given(mock.simpleMethod("foo")).willReturn("bar");
+
+        assertThat(mock.simpleMethod("foo")).isEqualTo("bar");
+        assertThat(mock.simpleMethod("whatever")).isNull();
+    }
+
+    @Test
+    public void should_stub_with_throwable() {
+        given(mock.simpleMethod("foo")).willThrow(new SomethingWasWrong());
+
+        try {
+            assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_with_throwable_class() {
+        given(mock.simpleMethod("foo")).willThrow(SomethingWasWrong.class);
+
+        try {
+            assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void should_stub_with_throwable_classes() {
+        // unavoidable 'unchecked generic array creation' warning (from JDK7 onward)
+        given(mock.simpleMethod("foo"))
+                .willThrow(SomethingWasWrong.class, AnotherThingWasWrong.class);
+
+        try {
+            assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_with_answer() {
+        given(mock.simpleMethod(anyString()))
+                .willAnswer(
+                        (Answer<String>)
+                                invocation -> {
+                                    return invocation.getArgument(0);
+                                });
+
+        assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+    }
+
+    @Test
+    public void should_stub_with_will_answer_alias() {
+        given(mock.simpleMethod(anyString()))
+                .will(
+                        (Answer<String>)
+                                invocation -> {
+                                    return invocation.getArgument(0);
+                                });
+
+        assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+    }
+
+    @Test
+    public void should_stub_consecutively() {
+        given(mock.simpleMethod(anyString())).willReturn("foo").willReturn("bar");
+
+        assertThat(mock.simpleMethod("whatever")).isEqualTo("foo");
+        assertThat(mock.simpleMethod("whatever")).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_return_consecutively() {
+        given(mock.objectReturningMethodNoArgs()).willReturn("foo", "bar", 12L, new byte[0]);
+
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("foo");
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("bar");
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(12L);
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(new byte[0]);
+    }
+
+    @Test
+    public void should_stub_consecutively_with_call_real_method() {
+        MethodsImpl mock = mock(MethodsImpl.class);
+        willReturn("foo").willCallRealMethod().given(mock).simpleMethod();
+
+        assertThat(mock.simpleMethod()).isEqualTo("foo");
+        assertThat(mock.simpleMethod()).isNull();
+    }
+
+    @Test
+    public void should_stub_void() {
+        willThrow(new SomethingWasWrong()).given(mock).voidMethod();
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_void_with_exception_class() {
+        willThrow(SomethingWasWrong.class).given(mock).voidMethod();
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void should_stub_void_with_exception_classes() {
+        willThrow(SomethingWasWrong.class, AnotherThingWasWrong.class).given(mock).voidMethod();
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_void_consecutively() {
+        willDoNothing().willThrow(new SomethingWasWrong()).given(mock).voidMethod();
+
+        mock.voidMethod();
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_void_consecutively_with_exception_class() {
+        willDoNothing().willThrow(SomethingWasWrong.class).given(mock).voidMethod();
+
+        mock.voidMethod();
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (SomethingWasWrong expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_using_do_return_style() {
+        willReturn("foo").given(mock).simpleMethod("bar");
+
+        assertThat(mock.simpleMethod("boooo")).isEqualTo(null);
+        assertThat(mock.simpleMethod("bar")).isEqualTo("foo");
+    }
+
+    @Test
+    public void should_stub_using_do_answer_style() {
+        willAnswer(
+                        (Answer<String>)
+                                invocation -> {
+                                    return invocation.getArgument(0);
+                                })
+                .given(mock)
+                .simpleMethod(anyString());
+
+        assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+    }
+
+    @Test
+    public void should_stub_by_delegating_to_real_method() {
+        // given
+        Dog dog = mock(Dog.class);
+        // when
+        willCallRealMethod().given(dog).bark();
+        // then
+        assertThat(dog.bark()).isEqualTo("woof");
+    }
+
+    @Test
+    public void should_stub_by_delegating_to_real_method_using_typical_stubbing_syntax() {
+        // given
+        Dog dog = mock(Dog.class);
+        // when
+        given(dog.bark()).willCallRealMethod();
+        // then
+        assertThat(dog.bark()).isEqualTo("woof");
+    }
+
+    @Test
+    public void should_all_stubbed_mock_reference_access() {
+        Set<?> expectedMock = mock(Set.class);
+
+        Set<?> returnedMock = given(expectedMock.isEmpty()).willReturn(false).getMock();
+
+        assertThat(returnedMock).isEqualTo(expectedMock);
+    }
+
+    @Test
+    public void should_validate_mock_when_verifying() {
+        assertThatThrownBy(
+                        () -> {
+                            then("notMock").should();
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContainingAll(
+                        "Argument passed to verify() is of type String and is not a mock!",
+                        "Make sure you place the parenthesis correctly!",
+                        "See the examples of correct verifications:",
+                        "    verify(mock).someMethod();",
+                        "    verify(mock, times(10)).someMethod();",
+                        "    verify(mock, atLeastOnce()).someMethod();");
+    }
+
+    @Test
+    public void should_validate_mock_when_verifying_with_expected_number_of_invocations() {
+        assertThatThrownBy(
+                        () -> {
+                            then("notMock").should(times(19));
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContainingAll(
+                        "Argument passed to verify() is of type String and is not a mock!",
+                        "Make sure you place the parenthesis correctly!",
+                        "See the examples of correct verifications:",
+                        "    verify(mock).someMethod();",
+                        "    verify(mock, times(10)).someMethod();",
+                        "    verify(mock, atLeastOnce()).someMethod();");
+    }
+
+    @Test
+    public void should_validate_mock_when_verifying_no_more_interactions() {
+        assertThatThrownBy(
+                        () -> {
+                            then("notMock").shouldHaveNoMoreInteractions();
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContainingAll(
+                        "Argument(s) passed is not a mock!",
+                        "Examples of correct verifications:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+
+    @Test
+    public void should_fail_for_expected_behavior_that_did_not_happen() {
+        assertThatThrownBy(
+                        () -> {
+                            then(mock).should().booleanObjectReturningMethod();
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll(
+                        "Wanted but not invoked:", "mock.booleanObjectReturningMethod();");
+    }
+
+    @Test
+    public void should_pass_for_expected_behavior_that_happened() {
+        mock.booleanObjectReturningMethod();
+
+        then(mock).should().booleanObjectReturningMethod();
+        then(mock).shouldHaveNoMoreInteractions();
+    }
+
+    @Test
+    public void should_validate_that_mock_had_no_interactions() {
+        then(mock).shouldHaveNoInteractions();
+    }
+
+    @Test
+    public void should_fail_when_mock_had_more_interactions_than_expected() {
+        mock.booleanObjectReturningMethod();
+        mock.byteObjectReturningMethod();
+
+        then(mock).should().booleanObjectReturningMethod();
+        try {
+            then(mock).shouldHaveNoMoreInteractions();
+            fail("should have reported that no more interactions were wanted");
+        } catch (NoInteractionsWanted expected) {
+        }
+    }
+
+    @Test
+    public void should_pass_for_interactions_that_happened_in_correct_order() {
+        mock.booleanObjectReturningMethod();
+        mock.arrayReturningMethod();
+
+        InOrder inOrder = inOrder(mock);
+        then(mock).should(inOrder).booleanObjectReturningMethod();
+        then(mock).should(inOrder).arrayReturningMethod();
+    }
+
+    @Test
+    public void should_fail_for_interactions_that_were_in_wrong_order() {
+        InOrder inOrder = inOrder(mock);
+
+        mock.arrayReturningMethod();
+        mock.booleanObjectReturningMethod();
+
+        then(mock).should(inOrder).booleanObjectReturningMethod();
+        try {
+            then(mock).should(inOrder).arrayReturningMethod();
+            fail("should have raise in order verification failure on second verify call");
+        } catch (VerificationInOrderFailure expected) {
+        }
+    }
+
+    @Test
+    public void should_fail_when_checking_order_of_interactions_that_did_not_happen() {
+        assertThatThrownBy(
+                        () -> {
+                            then(mock).should(inOrder(mock)).booleanObjectReturningMethod();
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll(
+                        "Wanted but not invoked:",
+                        "mock.booleanObjectReturningMethod();",
+                        "Actually, there were zero interactions with this mock.");
+    }
+
+    @Test
+    public void should_pass_fluent_bdd_scenario() {
+        Bike bike = new Bike();
+        Person person = mock(Person.class);
+        Police police = mock(Police.class);
+
+        person.ride(bike);
+        person.ride(bike);
+
+        then(person).should(times(2)).ride(bike);
+        then(police).shouldHaveNoInteractions();
+    }
+
+    @Test
+    public void should_pass_fluent_bdd_scenario_with_ordered_verification() {
+        Bike bike = new Bike();
+        Car car = new Car();
+        Person person = mock(Person.class);
+
+        person.drive(car);
+        person.ride(bike);
+        person.ride(bike);
+
+        InOrder inOrder = inOrder(person);
+        then(person).should(inOrder).drive(car);
+        then(person).should(inOrder, times(2)).ride(bike);
+    }
+
+    @Test
+    public void should_pass_fluent_bdd_scenario_with_ordered_verification_for_two_mocks() {
+        Car car = new Car();
+        Person person = mock(Person.class);
+        Police police = mock(Police.class);
+
+        person.drive(car);
+        person.drive(car);
+        police.chase(car);
+
+        InOrder inOrder = inOrder(person, police);
+        then(person).should(inOrder, times(2)).drive(car);
+        then(police).should(inOrder).chase(car);
+    }
+
+    static class Person {
+
+        void ride(Bike bike) {}
+
+        void drive(Car car) {}
+    }
+
+    static class Bike {}
+
+    static class Car {}
+
+    static class Police {
+
+        void chase(Car car) {}
+    }
+
+    class Dog {
+
+        public String bark() {
+            return "woof";
+        }
+    }
+
+    private class SomethingWasWrong extends RuntimeException {}
+
+    private class AnotherThingWasWrong extends RuntimeException {}
+}
diff --git a/src/test/java/org/mockitousage/debugging/Foo.java b/mockito-core/src/test/java/org/mockitousage/debugging/Foo.java
similarity index 99%
rename from src/test/java/org/mockitousage/debugging/Foo.java
rename to mockito-core/src/test/java/org/mockitousage/debugging/Foo.java
index be52a983af..6a3c747fc2 100644
--- a/src/test/java/org/mockitousage/debugging/Foo.java
+++ b/mockito-core/src/test/java/org/mockitousage/debugging/Foo.java
@@ -6,5 +6,6 @@
 
 interface Foo {
     String giveMeSomeString(String param);
+
     void doSomething(String param);
 }
diff --git a/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java b/mockito-core/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
similarity index 96%
rename from src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
rename to mockito-core/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
index d74a6f022a..be69b70920 100644
--- a/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
@@ -24,7 +24,6 @@
 import org.mockito.listeners.InvocationListener;
 import org.mockito.listeners.MethodInvocationReport;
 
-
 /**
  * Ensures that custom listeners can be registered and will be called every time
  * a method on a mock is invoked.
@@ -113,7 +112,8 @@ public void should_call_all_listener_when_mock_throws_exception() throws Excepti
         }
     }
 
-    private static Condition<RememberingListener> notifiedFor(final Object returned, final String location) {
+    private static Condition<RememberingListener> notifiedFor(
+            final Object returned, final String location) {
         return new Condition<RememberingListener>() {
             public boolean matches(RememberingListener toBeAsserted) {
                 assertThat(toBeAsserted.returnValue).isEqualTo(returned);
@@ -142,9 +142,9 @@ public void reportInvocation(MethodInvocationReport mcr) {
             this.invocation = mcr.getInvocation();
             this.returnValue = mcr.getReturnedValue();
             this.locationOfStubbing = mcr.getLocationOfStubbing();
-            listenerContainer.add(this); //so that we can assert on order
+            listenerContainer.add(this); // so that we can assert on order
         }
     }
 
-    private static class OvenNotWorking extends RuntimeException { }
+    private static class OvenNotWorking extends RuntimeException {}
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java b/mockito-core/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
new file mode 100644
index 0000000000..41761ef7fe
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.debugging;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.debugging.InvocationsPrinter;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class InvocationsPrinterTest extends TestBase {
+
+    @Mock IMethods mock;
+
+    @Test
+    public void no_invocations() {
+        assertThat(new InvocationsPrinter().printInvocations(mock))
+                .isEqualTo("No interactions and stubbings found for mock: mock");
+    }
+
+    @Test
+    public void prints_invocations() {
+        mock.simpleMethod(100);
+        triggerInteraction();
+
+        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
+                .isEqualTo(
+                        filterLineNo(
+                                "[Mockito] Interactions of: mock\n"
+                                        + " 1. mock.simpleMethod(100);\n"
+                                        + "  -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations(InvocationsPrinterTest.java:0)\n"
+                                        + " 2. mock.otherMethod();\n"
+                                        + "  -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:0)\n"));
+    }
+
+    @Test
+    public void prints_stubbings() {
+        triggerStubbing();
+
+        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
+                .isEqualTo(
+                        filterLineNo(
+                                "[Mockito] Unused stubbings of: mock\n"
+                                        + " 1. mock.simpleMethod(\"a\");\n"
+                                        + "  - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:70)\n"));
+    }
+
+    @Test
+    public void prints_invocations_and_stubbings() {
+        triggerStubbing();
+
+        mock.simpleMethod("a");
+        triggerInteraction();
+
+        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
+                .isEqualTo(
+                        filterLineNo(
+                                "[Mockito] Interactions of: mock\n"
+                                        + " 1. mock.simpleMethod(\"a\");\n"
+                                        + "  -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_stubbings(InvocationsPrinterTest.java:49)\n"
+                                        + "   - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:73)\n"
+                                        + " 2. mock.otherMethod();\n"
+                                        + "  -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n"));
+    }
+
+    @Test
+    public void prints_invocations_and_unused_stubbings() {
+        triggerStubbing();
+
+        mock.simpleMethod("b");
+        triggerInteraction();
+
+        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
+                .isEqualTo(
+                        filterLineNo(
+                                "[Mockito] Interactions of: mock\n"
+                                        + " 1. mock.simpleMethod(\"b\");\n"
+                                        + "  -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_unused_stubbings(InvocationsPrinterTest.java:55)\n"
+                                        + " 2. mock.otherMethod();\n"
+                                        + "  -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n"
+                                        + "[Mockito] Unused stubbings of: mock\n"
+                                        + " 1. mock.simpleMethod(\"a\");\n"
+                                        + "  - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:62)\n"));
+    }
+
+    private void triggerInteraction() {
+        mock.otherMethod();
+    }
+
+    private void triggerStubbing() {
+        when(mock.simpleMethod("a")).thenReturn("x");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java b/mockito-core/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java
new file mode 100644
index 0000000000..aa22e538a2
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.debugging;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InOrder;
+import org.mockito.listeners.StubbingLookupEvent;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockitousage.IMethods;
+import org.mockitoutil.ConcurrentTesting;
+import org.mockitoutil.TestBase;
+
+public class StubbingLookupListenerCallbackTest extends TestBase {
+
+    StubbingLookupListener listener = mock(StubbingLookupListener.class);
+    StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
+    Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener));
+
+    @Test
+    public void should_call_listener_when_mock_return_normally_with_stubbed_answer() {
+        // given
+        doReturn("coke").when(mock).giveMeSomeString("soda");
+        doReturn("java").when(mock).giveMeSomeString("coffee");
+
+        // when
+        mock.giveMeSomeString("soda");
+
+        // then
+        verify(listener)
+                .onStubbingLookup(
+                        argThat(
+                                new ArgumentMatcher<StubbingLookupEvent>() {
+                                    @Override
+                                    public boolean matches(StubbingLookupEvent argument) {
+                                        assertEquals(
+                                                "soda", argument.getInvocation().getArgument(0));
+                                        assertEquals(
+                                                "mock",
+                                                argument.getMockSettings()
+                                                        .getMockName()
+                                                        .toString());
+                                        assertEquals(2, argument.getAllStubbings().size());
+                                        assertNotNull(argument.getStubbingFound());
+                                        return true;
+                                    }
+                                }));
+    }
+
+    @Test
+    public void should_call_listener_when_mock_return_normally_with_default_answer() {
+        // given
+        doReturn("java").when(mock).giveMeSomeString("coffee");
+
+        // when
+        mock.giveMeSomeString("soda");
+
+        // then
+        verify(listener)
+                .onStubbingLookup(
+                        argThat(
+                                new ArgumentMatcher<StubbingLookupEvent>() {
+                                    @Override
+                                    public boolean matches(StubbingLookupEvent argument) {
+                                        assertEquals(
+                                                "soda", argument.getInvocation().getArgument(0));
+                                        assertEquals(
+                                                "mock",
+                                                argument.getMockSettings()
+                                                        .getMockName()
+                                                        .toString());
+                                        assertEquals(1, argument.getAllStubbings().size());
+                                        assertNull(argument.getStubbingFound());
+                                        return true;
+                                    }
+                                }));
+    }
+
+    @Test
+    public void should_not_call_listener_when_mock_is_not_called() {
+        // when stubbing is recorded
+        doReturn("java").when(mock).giveMeSomeString("coffee");
+
+        // then
+        verifyNoInteractions(listener);
+    }
+
+    @Test
+    public void should_allow_same_listener() {
+        // given
+        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener));
+
+        // when
+        mock.giveMeSomeString("tea");
+        mock.giveMeSomeString("coke");
+
+        // then each listener was notified 2 times (notified 4 times in total)
+        verify(listener, times(4)).onStubbingLookup(any(StubbingLookupEvent.class));
+    }
+
+    @Test
+    public void should_call_all_listeners_in_order() {
+        // given
+        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+        doReturn("sprite").when(mock).giveMeSomeString("soda");
+
+        // when
+        mock.giveMeSomeString("soda");
+
+        // then
+        InOrder inOrder = inOrder(listener, listener2);
+        inOrder.verify(listener).onStubbingLookup(any(StubbingLookupEvent.class));
+        inOrder.verify(listener2).onStubbingLookup(any(StubbingLookupEvent.class));
+    }
+
+    @Test
+    public void should_call_all_listeners_when_mock_throws_exception() {
+        // given
+        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+        doThrow(new NoWater()).when(mock).giveMeSomeString("tea");
+
+        // when
+        try {
+            mock.giveMeSomeString("tea");
+            fail();
+        } catch (NoWater e) {
+            // then
+            verify(listener).onStubbingLookup(any(StubbingLookupEvent.class));
+            verify(listener2).onStubbingLookup(any(StubbingLookupEvent.class));
+        }
+    }
+
+    @Test
+    public void should_delete_listener() {
+        // given
+        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+
+        // when
+        mock.doSomething("1");
+        mockingDetails(mock)
+                .getMockCreationSettings()
+                .getStubbingLookupListeners()
+                .remove(listener2);
+        mock.doSomething("2");
+
+        // then
+        verify(listener, times(2)).onStubbingLookup(any(StubbingLookupEvent.class));
+        verify(listener2, times(1)).onStubbingLookup(any(StubbingLookupEvent.class));
+    }
+
+    @Test
+    public void should_clear_listeners() {
+        // given
+        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+
+        // when
+        mockingDetails(mock).getMockCreationSettings().getStubbingLookupListeners().clear();
+        mock.doSomething("foo");
+
+        // then
+        verifyNoInteractions(listener, listener2);
+    }
+
+    @Test
+    public void add_listeners_concurrently_sanity_check() throws Exception {
+        // given
+        final IMethods mock = mock(IMethods.class);
+        final MockCreationSettings<?> settings = mockingDetails(mock).getMockCreationSettings();
+
+        List<Runnable> runnables = new LinkedList<Runnable>();
+        for (int i = 0; i < 50; i++) {
+            runnables.add(
+                    new Runnable() {
+                        public void run() {
+                            StubbingLookupListener listener1 = mock(StubbingLookupListener.class);
+                            StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
+                            settings.getStubbingLookupListeners().add(listener1);
+                            settings.getStubbingLookupListeners().add(listener2);
+                            settings.getStubbingLookupListeners().remove(listener1);
+                        }
+                    });
+        }
+
+        // when
+        ConcurrentTesting.concurrently(runnables.toArray(new Runnable[runnables.size()]));
+
+        // then
+        // This assertion may be flaky. If it is let's fix it or remove the test. For now, I'm
+        // keeping the test.
+        assertEquals(50, settings.getStubbingLookupListeners().size());
+    }
+
+    private static class NoWater extends RuntimeException {}
+}
diff --git a/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java b/mockito-core/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
similarity index 93%
rename from src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
rename to mockito-core/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
index 1c0d7a28d4..6696c12a5b 100644
--- a/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
@@ -123,8 +123,8 @@ public void shouldPrintThrowingInvocationOnMockToStdOut() {
     @Test
     public void shouldPrintRealInvocationOnSpyToStdOut() {
         // given
-        FooImpl fooSpy = mock(FooImpl.class,
-                withSettings().spiedInstance(new FooImpl()).verboseLogging());
+        FooImpl fooSpy =
+                mock(FooImpl.class, withSettings().spiedInstance(new FooImpl()).verboseLogging());
         doCallRealMethod().when(fooSpy).doSomething("Klipsch");
 
         // when
@@ -142,8 +142,7 @@ public void shouldPrintRealInvocationOnSpyToStdOut() {
     public void usage() {
         // given
         Foo foo = mock(Foo.class, withSettings().verboseLogging());
-        given(foo.giveMeSomeString("Apple")).willReturn(
-                "earbuds");
+        given(foo.giveMeSomeString("Apple")).willReturn("earbuds");
 
         // when
         foo.giveMeSomeString("Shure");
@@ -160,8 +159,7 @@ private String mockName(Object mock) {
     }
 
     private static class UnrelatedClass {
-        void unrelatedMethod(String anotherStringValue) {
-        }
+        void unrelatedMethod(String anotherStringValue) {}
     }
 
     /**
@@ -177,7 +175,6 @@ public String giveMeSomeString(String param) {
             return null;
         }
 
-        public void doSomething(String param) {
-        }
+        public void doSomething(String param) {}
     }
 }
diff --git a/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java b/mockito-core/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
similarity index 91%
rename from src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
rename to mockito-core/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
index b995f7a8a0..7ce75f1ece 100644
--- a/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
@@ -33,7 +33,7 @@ public void clearListeners() {
 
     @Test
     public void should_call_single_listener_on_verify() throws NoSuchMethodException {
-        //given
+        // given
         RememberingListener listener = new RememberingListener();
         MockitoFramework mockitoFramework = Mockito.framework();
         mockitoFramework.addListener(listener);
@@ -41,17 +41,17 @@ public void should_call_single_listener_on_verify() throws NoSuchMethodException
         Method invocationWanted = Foo.class.getDeclaredMethod("doSomething", String.class);
         Foo foo = mock(Foo.class);
 
-        //when
+        // when
         VerificationMode never = never();
         verify(foo, never).doSomething("");
 
-        //then
+        // then
         assertThat(listener).is(notifiedFor(foo, never, invocationWanted));
     }
 
     @Test
     public void should_call_all_listeners_on_verify() throws NoSuchMethodException {
-        //given
+        // given
         RememberingListener listener1 = new RememberingListener();
         RememberingListener2 listener2 = new RememberingListener2();
         Mockito.framework().addListener(listener1).addListener(listener2);
@@ -59,18 +59,18 @@ public void should_call_all_listeners_on_verify() throws NoSuchMethodException {
         Method invocationWanted = Foo.class.getDeclaredMethod("doSomething", String.class);
         Foo foo = mock(Foo.class);
 
-        //when
+        // when
         VerificationMode never = never();
         verify(foo, never).doSomething("");
 
-        //then
+        // then
         assertThat(listener1).is(notifiedFor(foo, never, invocationWanted));
         assertThat(listener2).is(notifiedFor(foo, never, invocationWanted));
     }
 
     @Test
     public void should_not_call_listener_when_verify_was_called_incorrectly() {
-        //when
+        // when
         VerificationListener listener = mock(VerificationListener.class);
         framework().addListener(listener);
         Foo foo = null;
@@ -79,59 +79,59 @@ public void should_not_call_listener_when_verify_was_called_incorrectly() {
             verify(foo).doSomething("");
             fail("Exception expected.");
         } catch (Exception e) {
-            //then
+            // then
             verify(listener, never()).onVerification(any(VerificationEvent.class));
         }
     }
 
     @Test
     public void should_notify_when_verification_throws_type_error() {
-        //given
+        // given
         RememberingListener listener = new RememberingListener();
         MockitoFramework mockitoFramework = Mockito.framework();
         mockitoFramework.addListener(listener);
         Foo foo = mock(Foo.class);
 
-        //when
+        // when
         try {
             verify(foo).doSomething("");
             fail("Exception expected.");
         } catch (Throwable e) {
-            //then
+            // then
             assertThat(listener.cause).isInstanceOf(MockitoAssertionError.class);
         }
     }
 
     @Test
     public void should_notify_when_verification_throws_runtime_exception() {
-        //given
+        // given
         RememberingListener listener = new RememberingListener();
         MockitoFramework mockitoFramework = Mockito.framework();
         mockitoFramework.addListener(listener);
         Foo foo = mock(Foo.class);
 
-        //when
+        // when
         try {
             verify(foo, new RuntimeExceptionVerificationMode()).doSomething("");
             fail("Exception expected.");
         } catch (Throwable e) {
-            //then
+            // then
             assertThat(listener.cause).isInstanceOf(RuntimeException.class);
         }
     }
 
     @Test
     public void should_call_verification_listeners() {
-        //given
+        // given
         RememberingListener listener = new RememberingListener();
         MockitoFramework mockitoFramework = Mockito.framework();
         mockitoFramework.addListener(listener);
         JUnitCore runner = new JUnitCore();
 
-        //when
+        // when
         runner.run(VerificationListenerSample.class);
 
-        //then
+        // then
         assertThat(listener.mock).isNotNull();
         assertThat(listener.mode).isEqualToComparingFieldByField(times(1));
     }
@@ -160,16 +160,16 @@ public void onVerification(VerificationEvent verificationEvent) {
         }
     }
 
-    private static class RememberingListener2 extends RememberingListener {
+    private static class RememberingListener2 extends RememberingListener {}
 
-    }
-
-    private static Condition<RememberingListener> notifiedFor(final Object mock, final VerificationMode mode, final Method wantedMethod) {
+    private static Condition<RememberingListener> notifiedFor(
+            final Object mock, final VerificationMode mode, final Method wantedMethod) {
         return new Condition<RememberingListener>() {
             public boolean matches(RememberingListener listener) {
                 assertThat(listener.mock).isEqualTo(mock);
                 assertThat(listener.mode).isEqualTo(mode);
-                assertThat(listener.data.getTarget().getInvocation().getMethod()).isEqualTo(wantedMethod);
+                assertThat(listener.data.getTarget().getInvocation().getMethod())
+                        .isEqualTo(wantedMethod);
 
                 return true;
             }
diff --git a/src/test/java/org/mockitousage/examples/use/Article.java b/mockito-core/src/test/java/org/mockitousage/examples/use/Article.java
similarity index 100%
rename from src/test/java/org/mockitousage/examples/use/Article.java
rename to mockito-core/src/test/java/org/mockitousage/examples/use/Article.java
diff --git a/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java b/mockito-core/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
similarity index 86%
rename from src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
rename to mockito-core/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
index 826733a5d0..b3b54125c3 100644
--- a/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
+++ b/mockito-core/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
@@ -6,7 +6,10 @@
 
 public interface ArticleCalculator {
     int countArticles(String newspaper);
+
     int countArticlesInPolish(String newspaper);
+
     int countNumberOfRelatedArticles(Article article);
-    int countAllArticles(String ... publications);
+
+    int countAllArticles(String... publications);
 }
diff --git a/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java b/mockito-core/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
similarity index 82%
rename from src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
rename to mockito-core/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
index f69ede718a..f45990218a 100644
--- a/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
+++ b/mockito-core/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
@@ -8,19 +8,15 @@
 
 public class ArticleDatabase {
 
-    public void updateNumberOfArticles(String newspaper, int articles) {
-    }
+    public void updateNumberOfArticles(String newspaper, int articles) {}
 
-    public void updateNumberOfPolishArticles(String newspaper, int polishArticles) {
-    }
+    public void updateNumberOfPolishArticles(String newspaper, int polishArticles) {}
 
-    public void updateNumberOfEnglishArticles(String newspaper, int i) {
-    }
+    public void updateNumberOfEnglishArticles(String newspaper, int i) {}
 
     public List<Article> getArticlesFor(String string) {
         return null;
     }
 
-    public void save(Article article) {
-    }
+    public void save(Article article) {}
 }
diff --git a/src/test/java/org/mockitousage/examples/use/ArticleManager.java b/mockito-core/src/test/java/org/mockitousage/examples/use/ArticleManager.java
similarity index 100%
rename from src/test/java/org/mockitousage/examples/use/ArticleManager.java
rename to mockito-core/src/test/java/org/mockitousage/examples/use/ArticleManager.java
diff --git a/src/test/java/org/mockitousage/examples/use/ExampleTest.java b/mockito-core/src/test/java/org/mockitousage/examples/use/ExampleTest.java
similarity index 89%
rename from src/test/java/org/mockitousage/examples/use/ExampleTest.java
rename to mockito-core/src/test/java/org/mockitousage/examples/use/ExampleTest.java
index 077a12341c..4a068e388c 100644
--- a/src/test/java/org/mockitousage/examples/use/ExampleTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/examples/use/ExampleTest.java
@@ -64,7 +64,8 @@ public void managerUpdatesNumberOfRelatedArticles() {
         when(mockCalculator.countNumberOfRelatedArticles(articleTwo)).thenReturn(12);
         when(mockCalculator.countNumberOfRelatedArticles(articleThree)).thenReturn(0);
 
-        when(mockDatabase.getArticlesFor("Guardian")).thenReturn(Arrays.asList(articleOne, articleTwo, articleThree));
+        when(mockDatabase.getArticlesFor("Guardian"))
+                .thenReturn(Arrays.asList(articleOne, articleTwo, articleThree));
 
         articleManager.updateRelatedArticlesCounters("Guardian");
 
@@ -81,13 +82,14 @@ public void shouldPersistRecalculatedArticle() {
         when(mockCalculator.countNumberOfRelatedArticles(articleOne)).thenReturn(1);
         when(mockCalculator.countNumberOfRelatedArticles(articleTwo)).thenReturn(12);
 
-        when(mockDatabase.getArticlesFor("Guardian")).thenReturn(Arrays.asList(articleOne, articleTwo));
+        when(mockDatabase.getArticlesFor("Guardian"))
+                .thenReturn(Arrays.asList(articleOne, articleTwo));
 
         articleManager.updateRelatedArticlesCounters("Guardian");
 
         InOrder inOrder = inOrder(mockDatabase, mockCalculator);
 
-        inOrder.verify(mockCalculator).countNumberOfRelatedArticles((Article) anyObject());
-        inOrder.verify(mockDatabase, atLeastOnce()).save((Article) anyObject());
+        inOrder.verify(mockCalculator).countNumberOfRelatedArticles(any());
+        inOrder.verify(mockDatabase, atLeastOnce()).save(any());
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/internal/debugging/LocationFactoryTest.java b/mockito-core/src/test/java/org/mockitousage/internal/debugging/LocationFactoryTest.java
new file mode 100644
index 0000000000..072c13fc02
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/internal/debugging/LocationFactoryTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.internal.debugging;
+
+import org.junit.Test;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockitoutil.TestBase;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class LocationFactoryTest extends TestBase {
+
+    @Test
+    public void shouldLocationNotContainGetStackTraceMethod() {
+        assertThat(LocationFactory.create().toString())
+                .contains("shouldLocationNotContainGetStackTraceMethod");
+    }
+
+    @Test
+    public void provides_location_class() {
+        // when
+        final List<String> files = new ArrayList<String>();
+        new Runnable() { // anonymous inner class adds stress to the check
+            public void run() {
+                files.add(LocationFactory.create().getSourceFile());
+            }
+        }.run();
+
+        // then
+        assertEquals("LocationFactoryTest.java", files.get(0));
+    }
+}
diff --git a/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java b/mockito-core/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
similarity index 81%
rename from src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
rename to mockito-core/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
index 99a6f80359..8713c12b8c 100644
--- a/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
@@ -26,6 +26,9 @@
  * Long term, it would be nice to have more configurability in TestBase
  *  to make it easy to write such unit tests in 'org.mockito.*' packages.
  */
+// This test contains emulation of same-line stubbings.
+// The formatter would put them on a separate line.
+// spotless:off
 public class UnusedStubbingsFinderTest extends TestBase {
 
     UnusedStubbingsFinder finder = new UnusedStubbingsFinder();
@@ -34,38 +37,38 @@ public class UnusedStubbingsFinderTest extends TestBase {
 
     @Test
     public void no_interactions() throws Exception {
-        //expect
+        // expect
         assertEquals(0, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
         assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
     }
 
     @Test
     public void no_stubbings() throws Exception {
-        //when
+        // when
         mock1.simpleMethod();
 
-        //then
+        // then
         assertEquals(0, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
         assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
     }
 
     @Test
     public void no_unused_stubbings() throws Exception {
-        //when
+        // when
         when(mock1.simpleMethod()).thenReturn("1");
         mock1.simpleMethod();
 
-        //then
+        // then
         assertEquals(0, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
         assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
     }
 
     @Test
     public void unused_stubbings() throws Exception {
-        //when
+        // when
         when(mock1.simpleMethod()).thenReturn("1");
 
-        //then
+        // then
         assertEquals(1, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
         assertEquals(1, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
     }
@@ -78,12 +81,13 @@ public void some_unused_stubbings() throws Exception {
 
         mock2.simpleMethod(2);
 
-        //when
+        // when
         UnusedStubbings stubbings = finder.getUnusedStubbings((List) asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(2, stubbings.size());
-        assertEquals("[mock1.simpleMethod(1); stubbed with: [Returns: 1], mock2.simpleMethod(3); stubbed with: [Returns: 3]]",
+        assertEquals(
+                "[mock1.simpleMethod(1); stubbed with: [Returns: 1], mock2.simpleMethod(3); stubbed with: [Returns: 3]]",
                 stubbings.toString());
     }
 
@@ -95,13 +99,12 @@ public void unused_and_lenient_stubbings() throws Exception {
 
         mock1.simpleMethod(1);
 
-        //when
+        // when
         UnusedStubbings stubbings = finder.getUnusedStubbings((List) asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(1, stubbings.size());
-        assertEquals("[mock1.simpleMethod(2); stubbed with: [Returns: 2]]",
-                stubbings.toString());
+        assertEquals("[mock1.simpleMethod(2); stubbed with: [Returns: 2]]", stubbings.toString());
     }
 
     @Test
@@ -109,43 +112,44 @@ 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
+        lenient().when(mock2.differentMethod()).thenReturn("4"); // will not be included in results
 
         mock2.simpleMethod(2);
 
-        //when
+        // when
         Collection stubbings = finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(2, stubbings.size());
         assertEquals("[mock1.simpleMethod(1);, mock2.simpleMethod(3);]", stubbings.toString());
     }
 
     @Test
     public void stubbing_used_by_location() throws Exception {
-        //when
-        //Emulating stubbing in the same location by putting stubbing in the same line:
+        // when
+        // Emulating stubbing in the same location by putting stubbing in the same line:
         when(mock1.simpleMethod(1)).thenReturn("1"); when(mock2.simpleMethod(1)).thenReturn("1");
-        //End of emulation
+        // End of emulation
         mock1.simpleMethod(1);
 
-        //then technically unused stubbings exist
+        // then technically unused stubbings exist
         assertEquals(1, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
-        //however if we consider stubbings in the same location as the same stubbing, all is used:
+        // however if we consider stubbings in the same location as the same stubbing, all is used:
         assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
     }
 
     @Test
     public void deduplicates_stubbings_by_location() throws Exception {
-        //when
-        //Emulating stubbing in the same location by putting stubbing in the same line:
+        // when
+        // Emulating stubbing in the same location by putting stubbing in the same line:
         when(mock1.simpleMethod(1)).thenReturn("1"); when(mock2.simpleMethod(1)).thenReturn("1");
-        //End of emulation
+        // End of emulation
 
-        //when
+        // when
         Collection stubbings = finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2));
 
-        //then
+        // then
         assertEquals(1, stubbings.size());
     }
 }
+// spotless:on
diff --git a/src/test/java/org/mockitousage/internal/package-info.java b/mockito-core/src/test/java/org/mockitousage/internal/package-info.java
similarity index 100%
rename from src/test/java/org/mockitousage/internal/package-info.java
rename to mockito-core/src/test/java/org/mockitousage/internal/package-info.java
diff --git a/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java b/mockito-core/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
similarity index 76%
rename from src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
rename to mockito-core/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
index 470f8101c4..1c3dcb5494 100644
--- a/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
+++ b/mockito-core/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
@@ -19,7 +19,6 @@
 import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 
-
 /**
  * Illustrate differences in the JLS depending on the Java version.
  */
@@ -46,8 +45,10 @@ public class JLS_15_12_2_5Test {
     public static class JLS_15_12_2_5_Java6_Java7_Test {
         @Before
         public void setUp() throws Exception {
-            Assume.assumeTrue(ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class).equals(JAVA_V6)
-                              || ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class).equals(JAVA_V7));
+            Assume.assumeTrue(
+                    ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class).equals(JAVA_V6)
+                            || ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class)
+                                    .equals(JAVA_V7));
         }
 
         @Test
@@ -56,10 +57,12 @@ public void with_single_arg() throws Exception {
 
             when(mock.oneArg(isNull())).thenReturn("ok");
 
-            assertThat(mock.oneArg(null)).describedAs("Most generic method chosen for matcher " +
-                                                      "(isNull generic upper bound is Object), but null applies " +
-                                                      "to select most specific method")
-                                         .isEqualTo(null);
+            assertThat(mock.oneArg(null))
+                    .describedAs(
+                            "Most generic method chosen for matcher "
+                                    + "(isNull generic upper bound is Object), but null applies "
+                                    + "to select most specific method")
+                    .isEqualTo(null);
         }
 
         @Test
@@ -68,7 +71,9 @@ public void with_single_arg_and_matcher_cast() throws Exception {
 
             when(mock.oneArg((String) isNull())).thenReturn("ok");
 
-            assertThat(mock.oneArg(null)).describedAs("Most specific method enforced for matcher via cast").isEqualTo("ok");
+            assertThat(mock.oneArg(null))
+                    .describedAs("Most specific method enforced for matcher via cast")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -78,7 +83,9 @@ public void with_single_arg_and_null_Object_reference() throws Exception {
             when(mock.oneArg(isNull())).thenReturn("ok");
 
             Object arg = null;
-            assertThat(mock.oneArg(arg)).describedAs("Most generic method chosen for matcher").isEqualTo("ok");
+            assertThat(mock.oneArg(arg))
+                    .describedAs("Most generic method chosen for matcher")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -87,10 +94,12 @@ public void with_variable_arg() throws Exception {
 
             when(mock.varargs(isNull())).thenReturn("ok");
 
-            assertThat(mock.varargs(null)).describedAs("Most generic method chosen for matcher " +
-                                                       "(isNull generic upper bound is Object), but null applies " +
-                                                       "to select most specific method")
-                                          .isEqualTo(null);
+            assertThat(mock.varargs(null))
+                    .describedAs(
+                            "Most generic method chosen for matcher "
+                                    + "(isNull generic upper bound is Object), but null applies "
+                                    + "to select most specific method")
+                    .isEqualTo(null);
         }
 
         @Test
@@ -99,7 +108,9 @@ public void with_variable_arg_and_matcher_String_cast() throws Exception {
 
             when(mock.varargs((String) isNull())).thenReturn("ok");
 
-            assertThat(mock.varargs(null)).describedAs("Most specific method enforced for matcher via String cast").isEqualTo("ok");
+            assertThat(mock.varargs(null))
+                    .describedAs("Most specific method enforced for matcher via String cast")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -108,7 +119,9 @@ public void with_variable_arg_and_matcher_String_array_cast() throws Exception {
 
             when(mock.varargs((String[]) isNull())).thenReturn("ok");
 
-            assertThat(mock.varargs(null)).describedAs("Most specific method enforced for matcher via String[] cast").isEqualTo("ok");
+            assertThat(mock.varargs(null))
+                    .describedAs("Most specific method enforced for matcher via String[] cast")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -118,7 +131,9 @@ public void with_variable_arg_and_null_Object_array() throws Exception {
             when(mock.varargs(isNull())).thenReturn("ok");
 
             Object[] args = null;
-            assertThat(mock.varargs(args)).describedAs("isNull matcher generic upper bound is Object").isEqualTo("ok");
+            assertThat(mock.varargs(args))
+                    .describedAs("isNull matcher generic upper bound is Object")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -128,7 +143,9 @@ public void with_variable_arg_and_null_Object_arg() throws Exception {
             when(mock.varargs(isNull())).thenReturn("ok");
 
             Object arg = null;
-            assertThat(mock.varargs(arg)).describedAs("isNull matcher generic upper bound is Object").isEqualTo("ok");
+            assertThat(mock.varargs(arg))
+                    .describedAs("isNull matcher generic upper bound is Object")
+                    .isEqualTo("ok");
         }
     }
 
@@ -181,7 +198,8 @@ public void with_variable_arg_and_null_Object_arg() throws Exception {
     public static class JLS_15_12_2_5_Java8_Test {
         @Before
         public void setUp() throws Exception {
-            Assume.assumeTrue(ClassFileVersion.of(JLS_15_12_2_5_Java8_Test.class).isAtLeast(JAVA_V8));
+            Assume.assumeTrue(
+                    ClassFileVersion.of(JLS_15_12_2_5_Java8_Test.class).isAtLeast(JAVA_V8));
         }
 
         @Test
@@ -190,7 +208,9 @@ public void with_single_arg() throws Exception {
 
             when(mock.oneArg(isNull())).thenReturn("ok");
 
-            assertThat(mock.oneArg(null)).describedAs("Most specific method chosen for matcher and for null").isEqualTo("ok");
+            assertThat(mock.oneArg(null))
+                    .describedAs("Most specific method chosen for matcher and for null")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -209,7 +229,9 @@ public void with_variable_arg() throws Exception {
 
             when(mock.varargs(isNull())).thenReturn("ok");
 
-            assertThat(mock.varargs(null)).describedAs("Most specific method chosen for matcher and for null").isEqualTo("ok");
+            assertThat(mock.varargs(null))
+                    .describedAs("Most specific method chosen for matcher and for null")
+                    .isEqualTo("ok");
         }
 
         @Test
@@ -219,7 +241,9 @@ public void with_variable_arg_and_null_Object_array() throws Exception {
             when(mock.varargs(isNull())).thenReturn("ok");
 
             Object[] args = null;
-            assertThat(mock.varargs(args)).describedAs("Most specific method chosen for matcher").isEqualTo(null);
+            assertThat(mock.varargs(args))
+                    .describedAs("Most specific method chosen for matcher")
+                    .isEqualTo(null);
         }
 
         @Test
@@ -229,16 +253,19 @@ public void with_variable_arg_and_null_Object_arg() throws Exception {
             when(mock.varargs(isNull())).thenReturn("ok");
 
             Object arg = null;
-            assertThat(mock.varargs(arg)).describedAs("Most specific method chosen for matcher").isEqualTo(null);
+            assertThat(mock.varargs(arg))
+                    .describedAs("Most specific method chosen for matcher")
+                    .isEqualTo(null);
         }
-
     }
 
     interface SingleOverload {
         String oneArg(Object arg);
+
         String oneArg(String arg);
+
         String varargs(Object... args);
+
         String varargs(String... args);
     }
-
 }
diff --git a/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
similarity index 79%
rename from src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
index 943361e907..b20615170f 100644
--- a/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
@@ -15,14 +15,11 @@
 
 public class InvalidTargetMockitoJUnitRuleTest {
 
-    @Rule
-    public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
+    @Rule public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
 
-    @Mock
-    private Injected injected;
+    @Mock private Injected injected;
 
-    @InjectMocks
-    private InjectInto injectInto;
+    @InjectMocks private InjectInto injectInto;
 
     @Test
     public void shouldInjectWithInvalidReference() throws Exception {
@@ -30,7 +27,7 @@ public void shouldInjectWithInvalidReference() throws Exception {
         assertNotNull("Test object created", injectInto);
     }
 
-    public static class Injected { }
+    public static class Injected {}
 
     public static class InjectInto {
         private Injected injected;
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java
new file mode 100644
index 0000000000..498d2bc890
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.RuleChain;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runners.model.Statement;
+import org.mockito.Mock;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+
+public class JUnitTestRuleIntegratesWithRuleChainTest {
+
+    JUnitCore runner = new JUnitCore();
+
+    @Test
+    public void rule_can_be_changed_to_strict() {
+        // when
+        Result result = runner.run(StrictByDefault.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+    }
+
+    @Test
+    public void rule_can_be_changed_to_lenient() {
+        // when
+        Result result = runner.run(LenientByDefault.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).isSuccessful();
+    }
+
+    public static class LenientByDefault {
+        @Rule
+        public final RuleChain chain =
+                RuleChain.outerRule(MockitoJUnit.testRule(this))
+                        .around(
+                                (base, description) ->
+                                        new Statement() {
+                                            @Override
+                                            public void evaluate() throws Throwable {
+                                                assertThat(MockUtil.isMock(mock)).isTrue();
+                                                called.set(true);
+                                                base.evaluate();
+                                            }
+                                        });
+
+        @Mock public IMethods mock;
+
+        private AtomicBoolean called = new AtomicBoolean(false);
+
+        @Test
+        public void creates_mocks_in_correct_rulechain_ordering() {
+            assertThat(MockUtil.isMock(mock)).isTrue();
+            assertThat(called.get()).isTrue();
+        }
+    }
+
+    public static class StrictByDefault {
+        @Rule
+        public final RuleChain chain =
+                RuleChain.outerRule(MockitoJUnit.testRule(this).strictness(Strictness.STRICT_STUBS))
+                        .around(
+                                (base, description) ->
+                                        new Statement() {
+                                            @Override
+                                            public void evaluate() throws Throwable {
+                                                assertThat(MockUtil.isMock(mock)).isTrue();
+                                                called.set(true);
+                                                base.evaluate();
+                                            }
+                                        });
+
+        @Mock public IMethods mock;
+
+        private AtomicBoolean called = new AtomicBoolean(false);
+
+        @Test
+        public void creates_mocks_in_correct_rulechain_ordering() {
+            assertThat(MockUtil.isMock(mock)).isTrue();
+            assertThat(called.get()).isTrue();
+        }
+
+        @Test
+        public void unused_stub() throws Throwable {
+            when(mock.simpleMethod()).thenReturn("1");
+            assertThat(called.get()).isTrue();
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
new file mode 100644
index 0000000000..617090a750
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.mockito.Mockito.when;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.junit.JUnitRule;
+import org.mockito.junit.MockitoRule;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+
+public class LenientJUnitRuleTest {
+
+    private MockitoLogger explosiveLogger =
+            what -> {
+                throw new RuntimeException("Silent rule should not write anything to the logger");
+            };
+    @Mock private IMethods mock;
+
+    @Rule public MockitoRule mockitoRule = new JUnitRule(explosiveLogger, Strictness.LENIENT);
+
+    @Test
+    public void no_warning_for_unused_stubbing() {
+        when(mock.simpleMethod(1)).thenReturn("1");
+    }
+
+    @Test
+    public void no_warning_for_stubbing_arg_mismatch() {
+        when(mock.simpleMethod(1)).thenReturn("1");
+        mock.simpleMethod(2);
+    }
+
+    @Test
+    public void no_warning_for_stubbing_arg_mismatch_on_failure() {
+        when(mock.simpleMethod(1)).thenReturn("1");
+        mock.simpleMethod(2);
+    }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
similarity index 78%
rename from src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
index e25f011466..1c6930e2cb 100644
--- a/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
@@ -16,18 +16,14 @@
 
 public class MockitoJUnitRuleTest {
 
-    @Rule
-    public MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
 
     // Fixes #1578: Protect against multiple execution.
-    @Rule
-    public MockitoRule mockitoRule2 = mockitoRule;
+    @Rule public MockitoRule mockitoRule2 = mockitoRule;
 
-    @Mock
-    private Injected injected;
+    @Mock private Injected injected;
 
-    @InjectMocks
-    private InjectInto injectInto;
+    @InjectMocks private InjectInto injectInto;
 
     @Test
     public void testInjectMocks() throws Exception {
@@ -36,7 +32,7 @@ public void testInjectMocks() throws Exception {
         assertEquals("A injected into B", injected, injectInto.getInjected());
     }
 
-    public static class Injected { }
+    public static class Injected {}
 
     public static class InjectInto {
         private Injected injected;
diff --git a/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
similarity index 77%
rename from src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
index c533039a33..122b3c1972 100644
--- a/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
@@ -16,18 +16,14 @@
 
 public class MockitoJUnitTestRuleTest {
 
-    @Rule
-    public MockitoTestRule mockitoRule = MockitoJUnit.testRule(this);
+    @Rule public MockitoTestRule mockitoRule = MockitoJUnit.testRule(this);
 
     // Fixes #1578: Protect against multiple execution.
-    @Rule
-    public MockitoTestRule mockitoRule2 = mockitoRule;
+    @Rule public MockitoTestRule mockitoRule2 = mockitoRule;
 
-    @Mock
-    private Injected injected;
+    @Mock private Injected injected;
 
-    @InjectMocks
-    private InjectInto injectInto;
+    @InjectMocks private InjectInto injectInto;
 
     @Test
     public void testInjectMocks() throws Exception {
@@ -36,7 +32,7 @@ public void testInjectMocks() throws Exception {
         assertEquals("A injected into B", injected, injectInto.getInjected());
     }
 
-    public static class Injected { }
+    public static class Injected {}
 
     public static class InjectInto {
         private Injected injected;
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
new file mode 100644
index 0000000000..b0efc2cb2e
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.mockito.Mockito.when;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+
+public class MutableStrictJUnitRuleTest {
+
+    JUnitCore runner = new JUnitCore();
+
+    @Test
+    public void rule_can_be_changed_to_strict() throws Throwable {
+        // when
+        Result result = runner.run(LenientByDefault.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+    }
+
+    @Test
+    public void rule_can_be_changed_to_lenient() throws Throwable {
+        // when
+        Result result = runner.run(StrictByDefault.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+    }
+
+    public static class LenientByDefault {
+        @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.LENIENT);
+        @Mock IMethods mock;
+
+        @Test
+        public void unused_stub() throws Throwable {
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+
+        @Test
+        public void unused_stub_with_strictness() throws Throwable {
+            // making Mockito strict only for this test method
+            mockito.strictness(Strictness.STRICT_STUBS);
+
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+    }
+
+    public static class StrictByDefault {
+        @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+        @Mock IMethods mock;
+
+        @Test
+        public void unused_stub() throws Throwable {
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+
+        @Test
+        public void unused_stub_with_lenient() throws Throwable {
+            // making Mockito lenient only for this test method
+            mockito.strictness(Strictness.LENIENT);
+
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java
new file mode 100644
index 0000000000..1e2faac199
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.mockito.Mockito.when;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoTestRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+
+public class MutableStrictJUnitTestRuleTest {
+
+    JUnitCore runner = new JUnitCore();
+
+    @Test
+    public void rule_can_be_changed_to_strict() throws Throwable {
+        // when
+        Result result = runner.run(LenientByDefault.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+    }
+
+    @Test
+    public void rule_can_be_changed_to_lenient() throws Throwable {
+        // when
+        Result result = runner.run(StrictByDefault.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+    }
+
+    public static class LenientByDefault {
+        @Rule
+        public MockitoTestRule mockito = MockitoJUnit.testRule(this).strictness(Strictness.LENIENT);
+
+        @Mock IMethods mock;
+
+        @Test
+        public void unused_stub() throws Throwable {
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+
+        @Test
+        public void unused_stub_with_strictness() throws Throwable {
+            // making Mockito strict only for this test method
+            mockito.strictness(Strictness.STRICT_STUBS);
+
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+    }
+
+    public static class StrictByDefault {
+        @Rule
+        public MockitoTestRule mockito =
+                MockitoJUnit.testRule(this).strictness(Strictness.STRICT_STUBS);
+
+        @Mock IMethods mock;
+
+        @Test
+        public void unused_stub() throws Throwable {
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+
+        @Test
+        public void unused_stub_with_lenient() throws Throwable {
+            // making Mockito lenient only for this test method
+            mockito.strictness(Strictness.LENIENT);
+
+            when(mock.simpleMethod()).thenReturn("1");
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
similarity index 81%
rename from src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
index 8f5830bf84..e7d613080a 100644
--- a/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
@@ -16,25 +16,20 @@
 
 public class RuleTestWithFactoryMethodTest {
 
-    @Rule
-    public MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
 
-    @Mock
-    private Injected injected;
+    @Mock private Injected injected;
 
-    @InjectMocks
-    private InjectInto injectInto;
+    @InjectMocks private InjectInto injectInto;
 
     @Test
     public void testInjectMocks() throws Exception {
         assertNotNull("Mock created", injected);
         assertNotNull("Object created", injectInto);
         assertEquals("A injected into B", injected, injectInto.getInjected());
-
     }
 
-    public static class Injected {
-    }
+    public static class Injected {}
 
     public static class InjectInto {
 
diff --git a/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
similarity index 81%
rename from src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
index ed2aa036f9..be56e876b6 100644
--- a/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
@@ -16,25 +16,20 @@
 
 public class RuleTestWithParameterConstructorTest {
 
-     @Rule
-     public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
+    @Rule public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
 
-    @Mock
-    private Injected injected;
+    @Mock private Injected injected;
 
-    @InjectMocks
-    private InjectInto injectInto;
+    @InjectMocks private InjectInto injectInto;
 
     @Test
     public void testInjectMocks() throws Exception {
         assertNotNull("Mock created", injected);
         assertNotNull("Object created", injectInto);
         assertEquals("A injected into B", injected, injectInto.getInjected());
-
     }
 
-    public static class Injected {
-    }
+    public static class Injected {}
 
     public static class InjectInto {
 
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
new file mode 100644
index 0000000000..6c6d1acd6c
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.TestBase.filterLineNo;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnfinishedVerificationException;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitousage.strictness.ProductionCode;
+import org.mockitoutil.SafeJUnitRule;
+
+public class StrictJUnitRuleTest {
+
+    @Rule
+    public SafeJUnitRule rule =
+            new SafeJUnitRule(MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS));
+
+    @Mock IMethods mock;
+    @Mock IMethods mock2;
+
+    @Test
+    public void ok_when_no_stubbings() throws Throwable {
+        mock.simpleMethod();
+        verify(mock).simpleMethod();
+    }
+
+    @Test
+    public void ok_when_all_stubbings_used() throws Throwable {
+        given(mock.simpleMethod(10)).willReturn("foo");
+        mock.simpleMethod(10);
+    }
+
+    @Test
+    public void ok_when_used_and_mismatched_argument() throws Throwable {
+        given(mock.simpleMethod(10)).willReturn("foo");
+        mock.simpleMethod(10);
+        mock.simpleMethod(15);
+    }
+
+    @Test
+    public void fails_when_unused_stubbings() throws Throwable {
+        // expect
+        rule.expectFailure(UnnecessaryStubbingException.class);
+
+        // when
+        given(mock.simpleMethod(10)).willReturn("foo");
+        mock2.simpleMethod(10);
+    }
+
+    @Test
+    public void test_failure_trumps_unused_stubbings() throws Throwable {
+        // expect
+        rule.expectFailure(AssertionError.class, "x");
+
+        // when
+        given(mock.simpleMethod(10)).willReturn("foo");
+        mock.otherMethod();
+
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void why_do_return_syntax_is_useful() throws Throwable {
+        // Trade-off of Mockito strictness documented in test
+
+        // expect
+        rule.expectFailure(PotentialStubbingProblem.class);
+
+        // when
+        when(mock.simpleMethod(10)).thenReturn("10");
+        ProductionCode.simpleMethod(mock, 20);
+    }
+
+    @Test
+    public void fails_fast_when_stubbing_invoked_with_different_argument() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        Assertions.assertThat(t).isInstanceOf(PotentialStubbingProblem.class);
+                        assertEquals(
+                                filterLineNo(
+                                        "\n"
+                                                + "Strict stubbing argument mismatch. Please check:\n"
+                                                + " - this invocation of 'simpleMethod' method:\n"
+                                                + "    mock.simpleMethod(15);\n"
+                                                + "    -> at org.mockitousage.strictness.ProductionCode.simpleMethod(ProductionCode.java:0)\n"
+                                                + " - has following stubbing(s) with different arguments:\n"
+                                                + "    1. mock.simpleMethod(20);\n"
+                                                + "      -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n"
+                                                + "    2. mock.simpleMethod(30);\n"
+                                                + "      -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n"
+                                                + "Typically, stubbing argument mismatch indicates user mistake when writing tests.\n"
+                                                + "Mockito fails early so that you can debug potential problem easily.\n"
+                                                + "However, there are legit scenarios when this exception generates false negative signal:\n"
+                                                + "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API\n"
+                                                + "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.\n"
+                                                + "  - stubbed method is intentionally invoked with different arguments by code under test\n"
+                                                + "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).\n"
+                                                + "For more information see javadoc for PotentialStubbingProblem class."),
+                                filterLineNo(t.getMessage()));
+                    }
+                });
+
+        // when stubbings in the test code:
+        willReturn("10").given(mock).simpleMethod(10); // used
+        willReturn("20").given(mock).simpleMethod(20); // unused
+        willReturn("30").given(mock).simpleMethod(30); // unused
+
+        // then
+        mock.otherMethod(); // ok, different method
+        mock.simpleMethod(10); // ok, stubbed with this argument
+
+        // invocation in the code under test uses different argument and should fail immediately
+        // this helps with debugging and is essential for Mockito strictness
+        ProductionCode.simpleMethod(mock, 15);
+    }
+
+    @Test
+    public void verify_no_more_interactions_ignores_stubs() throws Throwable {
+        // when stubbing in test:
+        given(mock.simpleMethod(10)).willReturn("foo");
+
+        // and code under test does:
+        mock.simpleMethod(10); // implicitly verifies the stubbing
+        mock.otherMethod();
+
+        // and in test we:
+        verify(mock).otherMethod();
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void unused_stubs_with_multiple_mocks() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals(
+                                filterLineNo(
+                                        "\n"
+                                                + "Unnecessary stubbings detected.\n"
+                                                + "Clean & maintainable test code requires zero unnecessary code.\n"
+                                                + "Following stubbings are unnecessary (click to navigate to relevant line of code):\n"
+                                                + "  1. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n"
+                                                + "  2. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n"
+                                                + "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."),
+                                filterLineNo(t.getMessage()));
+                    }
+                });
+
+        // when test has
+        given(mock.simpleMethod(10)).willReturn("foo");
+        given(mock2.simpleMethod(20)).willReturn("foo");
+
+        given(mock.otherMethod()).willReturn("foo"); // used and should not be reported
+
+        // and code has
+        mock.otherMethod();
+        mock2.booleanObjectReturningMethod();
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void rule_validates_mockito_usage() throws Throwable {
+        // expect
+        rule.expectFailure(UnfinishedVerificationException.class);
+
+        // when test contains unfinished verification
+        verify(mock);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
new file mode 100644
index 0000000000..7f77eeb59f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.TestBase.filterLineNo;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.junit.JUnitRule;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.SafeJUnitRule;
+
+public class StubbingWarningsJUnitRuleTest {
+
+    private SimpleMockitoLogger logger = new SimpleMockitoLogger();
+    @Rule public SafeJUnitRule rule = new SafeJUnitRule(new JUnitRule(logger, Strictness.WARN));
+    @Mock IMethods mock;
+
+    @Test
+    public void no_unused_stubs_reported_on_failure() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals("x", t.getMessage());
+                        assertTrue(logger.getLoggedInfo().isEmpty());
+                    }
+                });
+
+        // when
+        declareStubbing(mock);
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void stubbing_arg_mismatch_on_failure() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals("x", t.getMessage());
+                        assertEquals(
+                                "[MockitoHint] StubbingWarningsJUnitRuleTest.stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n"
+                                        + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+                                filterLineNo(logger.getLoggedInfo()));
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a");
+        useStubbingWithArg(mock, "b");
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void no_stubbing_arg_mismatch_when_no_mismatch_on_fail() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals("x", t.getMessage());
+                        assertTrue(logger.getLoggedInfo().isEmpty());
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a");
+        useStubbingWithArg(mock, "a");
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void no_stubbing_warning_on_pass() throws Throwable {
+        // expect
+        rule.expectSuccess(
+                new Runnable() {
+                    public void run() {
+                        assertTrue(logger.isEmpty());
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a");
+        useStubbingWithArg(mock, "a");
+    }
+
+    @Test
+    public void multiple_stubbing_arg_mismatch_on_failure() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals("x", t.getMessage());
+                        assertEquals(
+                                "[MockitoHint] StubbingWarningsJUnitRuleTest.multiple_stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n"
+                                        + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint] 2. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+                                filterLineNo(logger.getLoggedInfo()));
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a");
+        declareStubbingWithArg(mock, "b");
+
+        useStubbingWithArg(mock, "c");
+        useStubbingWithArg(mock, "d");
+
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void reports_only_mismatching_stubs() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals("x", t.getMessage());
+                        assertEquals(
+                                "[MockitoHint] StubbingWarningsJUnitRuleTest.reports_only_mismatching_stubs (see javadoc for MockitoHint):\n"
+                                        + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+                                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+                                filterLineNo(logger.getLoggedInfo()));
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a"); // <-- used
+        declareStubbingWithArg(mock, "b"); // <-- unused
+
+        useStubbingWithArg(mock, "a");
+        useStubbingWithArg(mock, "d"); // <-- arg mismatch
+
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void no_mismatch_when_stub_was_used() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertEquals("x", t.getMessage());
+                        assertTrue(logger.getLoggedInfo().isEmpty());
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a");
+
+        useStubbingWithArg(mock, "a");
+        useStubbingWithArg(mock, "d"); // <-- arg mismatch, but the stub was already used
+
+        throw new AssertionError("x");
+    }
+
+    @Test
+    public void no_stubbing_arg_mismatch_on_pass() throws Throwable {
+        // expect
+        rule.expectSuccess(
+                new Runnable() {
+                    public void run() {
+                        assertEquals(
+                                "[MockitoHint] StubbingWarningsJUnitRuleTest.no_stubbing_arg_mismatch_on_pass (see javadoc for MockitoHint):\n"
+                                        + "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+                                filterLineNo(logger.getLoggedInfo()));
+                    }
+                });
+
+        // when
+        declareStubbingWithArg(mock, "a");
+        useStubbingWithArg(mock, "b");
+    }
+
+    @Test
+    public void warns_about_unused_stubs_when_passed() throws Throwable {
+        // expect
+        rule.expectSuccess(
+                new Runnable() {
+                    public void run() {
+                        assertEquals(
+                                "[MockitoHint] StubbingWarningsJUnitRuleTest.warns_about_unused_stubs_when_passed (see javadoc for MockitoHint):\n"
+                                        + "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbing(StubbingWarningsJUnitRuleTest.java:0)\n",
+                                filterLineNo(logger.getLoggedInfo()));
+                    }
+                });
+
+        // when
+        declareStubbing(mock);
+    }
+
+    private static void declareStubbingWithArg(IMethods mock, String arg) {
+        when(mock.simpleMethod(arg)).thenReturn("bar");
+    }
+
+    private static void declareStubbing(IMethods mock) {
+        when(mock.simpleMethod("foo")).thenReturn("bar");
+    }
+
+    private void useStubbingWithArg(IMethods mock, String arg) {
+        mock.simpleMethod(arg);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
new file mode 100644
index 0000000000..683a9e8857
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.TestBase.filterLineNo;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.junit.JUnitRule;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.ConcurrentTesting;
+import org.mockitoutil.SafeJUnitRule;
+
+public class StubbingWarningsMultiThreadingTest {
+
+    private SimpleMockitoLogger logger = new SimpleMockitoLogger();
+    @Rule public SafeJUnitRule rule = new SafeJUnitRule(new JUnitRule(logger, Strictness.WARN));
+    @Mock IMethods mock;
+
+    @Test
+    public void using_stubbing_from_different_thread() throws Throwable {
+        // expect no warnings
+        rule.expectSuccess(
+                new Runnable() {
+                    public void run() {
+                        assertTrue(logger.getLoggedInfo().isEmpty());
+                    }
+                });
+
+        // when stubbing is declared
+        when(mock.simpleMethod()).thenReturn("1");
+        // and used from a different thread
+        ConcurrentTesting.inThread(
+                new Runnable() {
+                    public void run() {
+                        mock.simpleMethod();
+                    }
+                });
+    }
+
+    @Test
+    public void unused_stub_from_different_thread() throws Throwable {
+        // expect warnings
+        rule.expectSuccess(
+                new Runnable() {
+                    public void run() {
+                        assertEquals(
+                                "[MockitoHint] StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread (see javadoc for MockitoHint):\n"
+                                        + "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread(StubbingWarningsMultiThreadingTest.java:0)\n",
+                                filterLineNo(logger.getLoggedInfo()));
+                    }
+                });
+
+        // when stubbings are declared
+        when(mock.simpleMethod(1)).thenReturn("1");
+        when(mock.simpleMethod(2)).thenReturn("2");
+
+        // and one of the stubbings is used from a different thread
+        ConcurrentTesting.inThread(
+                new Runnable() {
+                    public void run() {
+                        mock.simpleMethod(1);
+                    }
+                });
+    }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java b/mockito-core/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
similarity index 76%
rename from src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
index ab4def4d7c..271c2135de 100644
--- a/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
@@ -5,14 +5,18 @@
 package org.mockitousage.junitrule;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.longThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.shortThat;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.JUnitCore;
 import org.junit.runner.Result;
-import org.mockito.ArgumentMatcher;
 import org.mockito.exceptions.base.MockitoAssertionError;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.VerificationCollector;
@@ -31,14 +35,23 @@ public void should_not_throw_any_exceptions_when_verifications_are_successful()
         collector.collectAndReport();
     }
 
-    @Test(expected = MockitoAssertionError.class)
+    @Test
     public void should_collect_verification_failures() {
         VerificationCollector collector = MockitoJUnit.collector().assertLazily();
 
         IMethods methods = mock(IMethods.class);
 
         verify(methods).simpleMethod();
-        collector.collectAndReport();
+        assertThatThrownBy(
+                        () -> {
+                            collector.collectAndReport();
+                        })
+                .isInstanceOf(MockitoAssertionError.class)
+                .hasMessageContainingAll(
+                        "There were multiple verification failures:",
+                        "1. Wanted but not invoked:",
+                        "iMethods.simpleMethod();",
+                        "Actually, there were zero interactions with this mock.");
     }
 
     @Test
@@ -72,21 +85,16 @@ public void should_collect_matching_error_from_non_matching_arguments() {
 
         methods.intArgumentMethod(6);
         methods.longArg(8L);
-        methods.forShort((short)6);
+        methods.forShort((short) 6);
 
         verify(methods).intArgumentMethod(8);
-        verify(methods).longArg(longThat(new ArgumentMatcher<Long>() {
-            @Override
-            public boolean matches(Long argument) {
-                throw new AssertionError("custom error message");
-            }
-        }));
-        verify(methods).forShort(shortThat(new ArgumentMatcher<Short>() {
-            @Override
-            public boolean matches(Short argument) {
-                return false;
-            }
-        }));
+        verify(methods)
+                .longArg(
+                        longThat(
+                                argument -> {
+                                    throw new AssertionError("custom error message");
+                                }));
+        verify(methods).forShort(shortThat(argument -> false));
 
         try {
             collector.collectAndReport();
@@ -139,17 +147,19 @@ public void should_invoke_collector_rule_after_test() {
         Result result = runner.run(VerificationCollectorRuleInner.class);
 
         assertThat(result.getFailureCount()).as("failureCount").isEqualTo(2);
-        assertThat(result.getFailures().get(0).getMessage()).as("failure1").contains("1. Wanted but not invoked:");
-        assertThat(result.getFailures().get(1).getMessage()).as("failure2")
-            .contains("1. Argument(s) are different! Wanted:")
-            .contains("2. Wanted but not invoked:");
+        assertThat(result.getFailures().get(0).getMessage())
+                .as("failure1")
+                .contains("1. Wanted but not invoked:");
+        assertThat(result.getFailures().get(1).getMessage())
+                .as("failure2")
+                .contains("1. Argument(s) are different! Wanted:")
+                .contains("2. Wanted but not invoked:");
     }
 
     // This class is picked up when running a test suite using an IDE. It fails on purpose.
     public static class VerificationCollectorRuleInner {
 
-        @Rule
-        public VerificationCollector collector = MockitoJUnit.collector();
+        @Rule public VerificationCollector collector = MockitoJUnit.collector();
 
         @Test
         public void should_fail() {
diff --git a/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
similarity index 82%
rename from src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
index be42213248..7236f1b9b0 100644
--- a/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
@@ -15,14 +15,15 @@ public class DeepStubbingWithJUnitRunnerTest {
 
     private final SomeClass someClass = new SomeClass();
 
-    @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Root root;
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private Root root;
 
     @Test
     public void deep_stubs_dont_trigger_unnecessary_stubbing_exception() {
-        //when
+        // when
         someClass.someMethod(root);
 
-        //then unnecessary stubbing exception is not thrown
+        // then unnecessary stubbing exception is not thrown
     }
 
     public static class SomeClass {
@@ -39,7 +40,5 @@ interface Foo {
         Bar getBar();
     }
 
-    interface Bar {
-
-    }
+    interface Bar {}
 }
diff --git a/src/test/java/org/mockitousage/junitrunner/Filters.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/Filters.java
similarity index 100%
rename from src/test/java/org/mockitousage/junitrunner/Filters.java
rename to mockito-core/src/test/java/org/mockitousage/junitrunner/Filters.java
diff --git a/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
index ed5a531480..bd9b485a5a 100644
--- a/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
@@ -35,7 +35,7 @@ public void shouldInjectMocksUsingRunner() {
     }
 
     @Test
-    public void shouldFilterTestMethodsCorrectly() throws Exception{
+    public void shouldFilterTestMethodsCorrectly() throws Exception {
         MockitoJUnitRunner runner = new MockitoJUnitRunner(this.getClass());
 
         runner.filter(methodNameContains("shouldInitMocksUsingRunner"));
diff --git a/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
similarity index 79%
rename from src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
rename to mockito-core/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
index 980300e594..193a30baef 100644
--- a/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
@@ -18,7 +18,7 @@
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-//@RunWith(ConsoleSpammingMockitoJUnitRunner.class)
+// @RunWith(ConsoleSpammingMockitoJUnitRunner.class)
 @RunWith(MockitoJUnitRunner.class)
 @Ignore
 public class ModellingVerboseMockitoTest extends TestBase {
@@ -36,22 +36,23 @@ public void shouldLogUnusedStubbingWarningWhenTestFails() throws Exception {
         when(mock.otherMethod()).thenReturn("foo");
         when(mock.booleanObjectReturningMethod()).thenReturn(false);
 
-        //TODO: stubbed with those args here -> stubbed with certain args here
+        // TODO: stubbed with those args here -> stubbed with certain args here
         String ret = mock.simpleMethod(2);
 
         assertEquals("foo", ret);
-        //TODO: should show message from actual failure not at the bottom but at least below 'the actual failure is ...'
+        // TODO: should show message from actual failure not at the bottom but at least below 'the
+        // actual failure is ...'
     }
 
     @Test
     public void shouldNotLogAnythingWhenNoWarnings() throws Exception {
-        //stub
+        // stub
         when(mock.simpleMethod()).thenReturn("foo");
-        //use stub:
+        // use stub:
         mock.simpleMethod();
-        //verify:
+        // verify:
         verify(mock).simpleMethod();
-        //should be no warnings:
+        // should be no warnings:
         fail();
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
new file mode 100644
index 0000000000..afb375debb
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.UnfinishedStubbingException;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+import org.mockitoutil.TestBase;
+
+public class SilentRunnerTest extends TestBase {
+
+    JUnitCore runner = new JUnitCore();
+
+    @Test
+    public void passing_test() {
+        // when
+        Result result = runner.run(SomeFeature.class);
+        // then
+        JUnitResultAssert.assertThat(result).isSuccessful();
+    }
+
+    @Test
+    public void failing_test() {
+        // when
+        Result result = runner.run(SomeFailingFeature.class);
+        // then
+        JUnitResultAssert.assertThat(result).fails(1, TooFewActualInvocations.class);
+    }
+
+    @Test
+    public void failing_test_in_constructor() {
+        // when
+        Result result = runner.run(FailsInConstructor.class);
+        // then
+        JUnitResultAssert.assertThat(result).fails(1, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void validates_framework_usage() {
+        // when
+        Result result = runner.run(UsesFrameworkIncorrectly.class);
+        // then
+        JUnitResultAssert.assertThat(result)
+                .fails(1, "unfinished_stubbing_test_method", UnfinishedStubbingException.class);
+    }
+
+    @Test
+    public void ignores_unused_stubs() {
+        JUnitCore runner = new JUnitCore();
+        // when
+        Result result = runner.run(HasUnnecessaryStubs.class);
+        // then
+        JUnitResultAssert.assertThat(result).isSuccessful();
+    }
+
+    @RunWith(MockitoJUnitRunner.Silent.class)
+    public static class SomeFeature {
+        @Mock List<String> list;
+
+        @Test
+        public void some_behavior() {
+            when(list.get(0)).thenReturn("0");
+            assertEquals("0", list.get(0));
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.Silent.class)
+    public static class SomeFailingFeature {
+        @Mock List<String> list;
+
+        @Test
+        public void some_failing_behavior() {
+            list.clear();
+            verify(list, times(2)).clear();
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.Silent.class)
+    public static class FailsInConstructor {
+        {
+            if (System.currentTimeMillis() > 0) {
+                throw new IllegalArgumentException("Boo!");
+            }
+        }
+
+        @Mock List<String> list;
+
+        @Test
+        public void some_behavior() {}
+    }
+
+    @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
+        }
+    }
+
+    /**
+     * The test class itself is passing but it has some unnecessary stubs
+     */
+    @RunWith(MockitoJUnitRunner.Silent.class)
+    public static class HasUnnecessaryStubs {
+        IMethods mock1 = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
+        IMethods mock2 = when(mock(IMethods.class).simpleMethod(2)).thenReturn("2").getMock();
+        IMethods mock3 = when(mock(IMethods.class).simpleMethod(3)).thenReturn("3").getMock();
+
+        @Test
+        public void usesStub() {
+            assertEquals("1", mock1.simpleMethod(1));
+        }
+
+        @Test
+        public void usesStubWithDifferentArg() {
+            assertEquals(null, mock2.simpleMethod(200));
+            assertEquals(null, mock3.simpleMethod(300));
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
new file mode 100644
index 0000000000..87700bd43a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.manipulation.Filter;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.MockitoRule;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+import org.mockitoutil.TestBase;
+
+public class StrictRunnerTest extends TestBase {
+
+    JUnitCore runner = new JUnitCore();
+
+    @Test
+    public void succeeds_when_all_stubs_were_used() {
+        // when
+        Result result =
+                runner.run(
+                        StubbingInConstructorUsed.class,
+                        StubbingInBeforeUsed.class,
+                        StubbingInTestUsed.class);
+        // then
+        JUnitResultAssert.assertThat(result).isSuccessful();
+    }
+
+    @Test
+    public void fails_when_stubs_were_not_used() {
+        Class[] tests = {
+            StubbingInConstructorUnused.class,
+            StubbingInBeforeUnused.class,
+            StubbingInTestUnused.class
+        };
+
+        // when
+        Result result = runner.run(tests);
+
+        // then
+        JUnitResultAssert.assertThat(result).fails(3, UnnecessaryStubbingException.class);
+    }
+
+    @Test
+    public void does_not_report_unused_stubs_when_different_failure_is_present() {
+        // when
+        Result result = runner.run(WithUnrelatedAssertionFailure.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).fails(1, MyAssertionError.class);
+    }
+
+    @Test
+    public void runner_can_coexist_with_rule() {
+        // I don't believe that this scenario is useful
+        // I only wish that Mockito does not break awkwardly when both: runner & rule is used
+
+        // when
+        Result result = runner.run(RunnerAndRule.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).fails(1, UnnecessaryStubbingException.class);
+    }
+
+    @Test
+    public void runner_in_multi_threaded_tests() {
+        // when
+        Result result = runner.run(StubUsedFromDifferentThread.class);
+
+        // then
+        JUnitResultAssert.assertThat(result).isSuccessful();
+    }
+
+    @Test
+    public void does_not_report_unused_stubs_when_test_is_filtered() {
+        // This class has two test methods; run only the test method that does not use the stubbing
+        // set up in before
+        Request request = Request.method(StubbingInBeforeUsed.class, "dummy");
+
+        // when
+        Result result = runner.run(request);
+
+        // then
+        JUnitResultAssert.assertThat(result).isSuccessful();
+    }
+
+    @Test
+    public void fails_when_stubs_were_not_used_with_noop_filter() {
+        Class[] tests = {
+            StubbingInConstructorUnused.class,
+            StubbingInBeforeUnused.class,
+            StubbingInTestUnused.class
+        };
+
+        // when
+        Result result = runner.run(Request.classes(tests).filterWith(new NoOpFilter()));
+
+        // then
+        JUnitResultAssert.assertThat(result).fails(3, UnnecessaryStubbingException.class);
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class StubbingInConstructorUsed extends StubbingInConstructorUnused {
+        @Test
+        public void test() {
+            assertEquals("1", mock.simpleMethod(1));
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.Strict.class) // using Strict to make sure it does the right thing
+    public static class StubbingInConstructorUnused {
+        IMethods mock = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
+
+        @Test
+        public void dummy() {}
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class StubbingInBeforeUsed extends StubbingInBeforeUnused {
+        @Test
+        public void test() {
+            assertEquals("1", mock.simpleMethod(1));
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class StubbingInBeforeUnused {
+        @Mock IMethods mock;
+
+        @Before
+        public void before() {
+            when(mock.simpleMethod(1)).thenReturn("1");
+        }
+
+        @Test
+        public void dummy() {}
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class StubbingInTestUsed {
+        @Test
+        public void test() {
+            IMethods mock = mock(IMethods.class);
+            when(mock.simpleMethod(1)).thenReturn("1");
+            assertEquals("1", mock.simpleMethod(1));
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class StubbingInTestUnused {
+        @Test
+        public void test() {
+            IMethods mock = mock(IMethods.class);
+            when(mock.simpleMethod(1)).thenReturn("1");
+            mock.simpleMethod(2); // different arg
+        }
+    }
+
+    private static class MyAssertionError extends AssertionError {}
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class WithUnrelatedAssertionFailure {
+
+        IMethods mock = mock(IMethods.class);
+        IMethods mock2 = mock(IMethods.class);
+
+        @Before
+        public void before() {
+            when(mock2.simpleMethod("unused stubbing")).thenReturn("");
+        }
+
+        @Test
+        public void passing_test() {
+            when(mock.simpleMethod(1)).thenReturn("1");
+            assertEquals("1", mock.simpleMethod(1));
+        }
+
+        @Test
+        public void failing_test() {
+            throw new MyAssertionError();
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class RunnerAndRule {
+
+        public @Rule MockitoRule rule = MockitoJUnit.rule();
+        IMethods mock = mock(IMethods.class);
+
+        @Test
+        public void passing_test() {
+            when(mock.simpleMethod(1)).thenReturn("1");
+            mock.simpleMethod(2);
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.class)
+    public static class StubUsedFromDifferentThread {
+
+        IMethods mock = mock(IMethods.class);
+
+        @Test
+        public void passing_test() throws Exception {
+            // stubbing is done in main thread:
+            when(mock.simpleMethod(1)).thenReturn("1");
+
+            // stubbing is used in a different thread
+            // stubbing should not be reported as unused by the runner
+            Thread t =
+                    new Thread() {
+                        public void run() {
+                            mock.simpleMethod(1);
+                        }
+                    };
+            t.start();
+            t.join();
+        }
+    }
+
+    private static class NoOpFilter extends Filter {
+
+        @Override
+        public boolean shouldRun(Description description) {
+            return true;
+        }
+
+        @Override
+        public String describe() {
+            return "No-op filter";
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
new file mode 100644
index 0000000000..efe2f74b9d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrunner;
+
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+import org.mockitousage.strictness.ProductionCode;
+import org.mockitoutil.JUnitResultAssert;
+import org.mockitoutil.TestBase;
+
+public class StrictStubsRunnerTest extends TestBase {
+
+    JUnitCore runner = new JUnitCore();
+
+    @Test
+    public void detects_unnecessary_stubbings() {
+        // when
+        Result result = runner.run(UnnecessaryStubbing.class);
+        // then
+        JUnitResultAssert.assertThat(result)
+                .fails(1, UnnecessaryStubbingException.class)
+                .succeeds(2);
+    }
+
+    @Test
+    public void fails_fast_on_argument_mismatch() {
+        // when
+        Result result = runner.run(StubbingArgMismatch.class);
+        // then
+        JUnitResultAssert.assertThat(result).succeeds(2).fails(1, PotentialStubbingProblem.class);
+    }
+
+    @RunWith(MockitoJUnitRunner.StrictStubs.class)
+    public static class UnnecessaryStubbing {
+        @Mock IMethods mock;
+
+        @Test
+        public void unused_stubbing_1() {
+            when(mock.simpleMethod()).thenReturn("");
+        }
+
+        @Test
+        public void unused_stubbing_2() {
+            when(mock.simpleMethod()).thenReturn("");
+        }
+
+        @Test
+        public void correct_stubbing() {
+            when(mock.simpleMethod()).thenReturn("");
+            mock.simpleMethod();
+        }
+    }
+
+    @RunWith(MockitoJUnitRunner.StrictStubs.class)
+    public static class StubbingArgMismatch {
+        @Mock IMethods mock;
+
+        @Test
+        public void passing1() {}
+
+        @Test
+        public void passing2() {
+            when(mock.simpleMethod()).thenReturn("");
+            mock.simpleMethod();
+        }
+
+        @Test
+        public void argument_mismatch() {
+            when(mock.simpleMethod(10)).thenReturn("");
+            ProductionCode.simpleMethod(mock, 20);
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
new file mode 100644
index 0000000000..05be05d5fc
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.JUnitResultAssert.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.UnfinishedStubbingException;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.junit.TestableJUnitRunner;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class StubbingWarningsJUnitRunnerTest extends TestBase {
+
+    JUnitCore runner = new JUnitCore();
+    SimpleMockitoLogger logger = TestableJUnitRunner.refreshedLogger();
+
+    @Test
+    public void no_arg_mismatch_warnings() {
+        // when
+        runner.run(
+                PassingArgMismatch.class,
+                FailingWithMatchingArgs.class,
+                MismatchButStubAlreadyUsed.class);
+
+        // then
+        assertEquals("", filterLineNo(logger.getLoggedInfo()));
+    }
+
+    @Test
+    public void shows_arg_mismatch_warnings_when_test_fails() {
+        // when
+        runner.run(FailingWithArgMismatch.class);
+
+        // then
+        assertEquals(
+                "[MockitoHint] FailingWithArgMismatch.test (see javadoc for MockitoHint):\n"
+                        + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n"
+                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n",
+                filterLineNo(logger.getLoggedInfo()));
+    }
+
+    @Test
+    public void shows_arg_mismatch_warnings_only_for_mismatches() {
+        // when
+        runner.run(FailingWithSomeStubMismatches.class);
+
+        // then
+        assertEquals(
+                "[MockitoHint] FailingWithSomeStubMismatches.test (see javadoc for MockitoHint):\n"
+                        + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n"
+                        + "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n",
+                filterLineNo(logger.getLoggedInfo()));
+    }
+
+    @Test
+    public void validates_mockito_usage() {
+        // when
+        Result result = runner.run(InvalidMockitoUsage.class);
+
+        // then
+        assertThat(result).fails(1, UnfinishedStubbingException.class);
+    }
+
+    @RunWith(TestableJUnitRunner.class)
+    public static class PassingArgMismatch {
+        IMethods mock = mock(IMethods.class);
+
+        @Test
+        public void test() throws Exception {
+            when(mock.simpleMethod(1)).thenReturn("1");
+            mock.simpleMethod(2);
+        }
+    }
+
+    @RunWith(TestableJUnitRunner.class)
+    public static class FailingWithArgMismatch {
+        @Mock IMethods mock;
+
+        @Test
+        public void test() throws Exception {
+            when(mock.simpleMethod(1)).thenReturn("1");
+            mock.simpleMethod(2);
+            throw new RuntimeException("x");
+        }
+    }
+
+    @RunWith(TestableJUnitRunner.class)
+    public static class FailingWithMatchingArgs {
+        @Mock IMethods mock;
+
+        @Test
+        public void test() throws Exception {
+            when(mock.simpleMethod(1)).thenReturn("1");
+            mock.simpleMethod(1);
+            throw new RuntimeException("x");
+        }
+    }
+
+    @RunWith(TestableJUnitRunner.class)
+    public static class FailingWithSomeStubMismatches {
+        @Mock IMethods mock;
+
+        @Test
+        public void test() throws Exception {
+            when(mock.simpleMethod(1)).thenReturn("1"); // <- used
+            when(mock.simpleMethod(2)).thenReturn("2"); // <- unused
+
+            mock.simpleMethod(1); // <- not reported
+            mock.simpleMethod(3); // <- reported
+
+            throw new RuntimeException("x");
+        }
+    }
+
+    @RunWith(TestableJUnitRunner.class)
+    public static class MismatchButStubAlreadyUsed {
+        @Mock IMethods mock;
+
+        @Test
+        public void test() throws Exception {
+            when(mock.simpleMethod(1)).thenReturn("1");
+            mock.simpleMethod(1); // <-- used
+            mock.simpleMethod(2); // <-- arg mismatch, but the stub was already used
+
+            throw new RuntimeException("x");
+        }
+    }
+
+    @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/mockito-core/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java b/mockito-core/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
new file mode 100644
index 0000000000..db804f856c
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.Failure;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class UnusedStubsExceptionMessageTest extends TestBase {
+
+    // Moving the code around this class is tricky and may cause the test to fail
+    // We're asserting on full exception message which contains line numbers
+    // Let's leave it for now, updating the test is cheap and if it turns out hindrance we can make
+    // the assertion smarter.
+    @RunWith(MockitoJUnitRunner.class)
+    public static class HasUnnecessaryStubs {
+        IMethods mock1 = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
+        IMethods mock2 = when(mock(IMethods.class).simpleMethod(2)).thenReturn("2").getMock();
+        IMethods mock3 = when(mock(IMethods.class).simpleMethod(3)).thenReturn("3").getMock();
+
+        @Test
+        public void usesStub() {
+            assertEquals("1", mock1.simpleMethod(1));
+        }
+
+        @Test
+        public void usesStubWithDifferentArg() {
+            assertEquals(null, mock2.simpleMethod(200));
+            assertEquals(null, mock3.simpleMethod(300));
+        }
+    }
+
+    @Test
+    public void lists_all_unused_stubs_cleanly() {
+        JUnitCore runner = new JUnitCore();
+        // when
+        Result result = runner.run(HasUnnecessaryStubs.class);
+        // then
+        Failure failure = result.getFailures().get(0);
+        assertEquals(
+                "\n"
+                        + "Unnecessary stubbings detected in test class: HasUnnecessaryStubs\n"
+                        + "Clean & maintainable test code requires zero unnecessary code.\n"
+                        + "Following stubbings are unnecessary (click to navigate to relevant line of code):\n"
+                        + "  1. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n"
+                        + "  2. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n"
+                        + "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.",
+                filterLineNo(failure.getException().getMessage()));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/AdditionalMatcherTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/AdditionalMatcherTest.java
new file mode 100644
index 0000000000..4130b0c3f2
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/AdditionalMatcherTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.mockito.AdditionalMatchers.and;
+import static org.mockito.AdditionalMatchers.or;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class AdditionalMatcherTest {
+
+    interface Foo {
+        int doSomeThing(Object param);
+    }
+
+    @Test
+    public void shouldMatchArgumentsSequentiallyWithAnd() {
+        Foo foo = mock(Foo.class);
+
+        when(foo.doSomeThing(and(any(String.class), argThat(String::isEmpty)))).thenReturn(1);
+
+        assertNotEquals(foo.doSomeThing(1), 1);
+    }
+
+    @Test
+    public void shouldMatchArgumentsSequentiallyWithOr() {
+        Foo foo = mock(Foo.class);
+
+        when(foo.doSomeThing(
+                        or(any(Integer.class), and(any(Object.class), argThat(String::isEmpty)))))
+                .thenReturn(1);
+
+        assertEquals(foo.doSomeThing(1), 1);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
new file mode 100644
index 0000000000..2f93ea1b36
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.when;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class AnyXMatchersAcceptNullsTest extends TestBase {
+
+    private IMethods mock;
+
+    @Before
+    public void setUp() {
+        mock = Mockito.mock(IMethods.class);
+    }
+
+    @Test
+    public void shouldAcceptNullsInAnyMatcher() {
+        when(mock.oneArg((Object) any())).thenReturn("matched");
+
+        assertEquals(null, mock.forObject(null));
+    }
+
+    @Test
+    public void shouldNotAcceptNullInAllAnyPrimitiveWrapperMatchers() {
+        when(mock.forInteger(anyInt())).thenReturn("0");
+        when(mock.forCharacter(anyChar())).thenReturn("1");
+        when(mock.forShort(anyShort())).thenReturn("2");
+        when(mock.forByte(anyByte())).thenReturn("3");
+        when(mock.forBoolean(anyBoolean())).thenReturn("4");
+        when(mock.forLong(anyLong())).thenReturn("5");
+        when(mock.forFloat(anyFloat())).thenReturn("6");
+        when(mock.forDouble(anyDouble())).thenReturn("7");
+
+        assertEquals(null, mock.forInteger(null));
+        assertEquals(null, mock.forCharacter(null));
+        assertEquals(null, mock.forShort(null));
+        assertEquals(null, mock.forByte(null));
+        assertEquals(null, mock.forBoolean(null));
+        assertEquals(null, mock.forLong(null));
+        assertEquals(null, mock.forFloat(null));
+        assertEquals(null, mock.forDouble(null));
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
new file mode 100644
index 0000000000..e0146de780
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class CapturingArgumentsTest extends TestBase {
+
+    private static class Person {
+
+        private final Integer age;
+
+        public Person(Integer age) {
+            this.age = age;
+        }
+
+        public int getAge() {
+            return age;
+        }
+    }
+
+    private static class BulkEmailService {
+
+        private final EmailService service;
+
+        public BulkEmailService(EmailService service) {
+            this.service = service;
+        }
+
+        public void email(Integer... personId) {
+            for (Integer i : personId) {
+                Person person = new Person(i);
+                service.sendEmailTo(person);
+            }
+        }
+    }
+
+    interface EmailService {
+        boolean sendEmailTo(Person person);
+    }
+
+    private final EmailService emailService = mock(EmailService.class);
+    private final BulkEmailService bulkEmailService = new BulkEmailService(emailService);
+    private final IMethods mock = mock(IMethods.class);
+    @Captor private ArgumentCaptor<List<?>> listCaptor;
+
+    @Test
+    public void should_allow_assertions_on_captured_argument() {
+        // given
+        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
+
+        // when
+        bulkEmailService.email(12);
+
+        // then
+        verify(emailService).sendEmailTo(argument.capture());
+        assertEquals(12, argument.getValue().getAge());
+    }
+
+    @Test
+    public void should_allow_assertions_on_all_captured_arguments() {
+        // given
+        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
+
+        // when
+        bulkEmailService.email(11, 12);
+
+        // then
+        verify(emailService, times(2)).sendEmailTo(argument.capture());
+        assertEquals(11, argument.getAllValues().get(0).getAge());
+        assertEquals(12, argument.getAllValues().get(1).getAge());
+    }
+
+    @Test
+    public void should_allow_assertions_on_last_argument() {
+        // given
+        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
+
+        // when
+        bulkEmailService.email(11, 12, 13);
+
+        // then
+        verify(emailService, times(3)).sendEmailTo(argument.capture());
+        assertEquals(13, argument.getValue().getAge());
+    }
+
+    @Test
+    public void should_print_captor_matcher() {
+        // given
+        ArgumentCaptor<Person> person = ArgumentCaptor.forClass(Person.class);
+
+        try {
+            // when
+            verify(emailService).sendEmailTo(person.capture());
+            fail();
+        } catch (WantedButNotInvoked e) {
+            // then
+            assertThat(e).hasMessageContaining("<Capturing argument: Person>");
+        }
+    }
+
+    @Test
+    public void should_allow_assertions_on_captured_null() {
+        // given
+        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
+
+        // when
+        emailService.sendEmailTo(null);
+
+        // then
+        verify(emailService).sendEmailTo(argument.capture());
+        assertNull(argument.getValue());
+    }
+
+    @Test
+    public void should_allow_construction_of_captor_for_parameterized_type_in_a_convenient_way() {
+        // the test passes if this expression compiles
+        @SuppressWarnings("unchecked")
+        ArgumentCaptor<List<Person>> argument = ArgumentCaptor.forClass(List.class);
+        assertNotNull(argument);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void should_allow_construction_of_captor_for_a_more_specific_type() {
+        // the test passes if this expression compiles
+        ArgumentCaptor<List<?>> argument = ArgumentCaptor.forClass(ArrayList.class);
+        assertNotNull(argument);
+    }
+
+    @Test
+    public void should_allow_capturing_for_stubbing() {
+        // given
+        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
+        when(emailService.sendEmailTo(argument.capture())).thenReturn(false);
+
+        // when
+        emailService.sendEmailTo(new Person(10));
+
+        // then
+        assertEquals(10, argument.getValue().getAge());
+    }
+
+    @Test
+    public void should_capture_when_stubbing_only_when_entire_invocation_matches() {
+        // given
+        ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
+        when(mock.simpleMethod(argument.capture(), eq(2))).thenReturn("blah");
+
+        // when
+        mock.simpleMethod("foo", 200);
+        mock.simpleMethod("bar", 2);
+
+        // then
+        assertThat(argument.getAllValues()).containsOnly("bar");
+    }
+
+    @Test
+    public void should_say_something_smart_when_misused() {
+        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
+        try {
+            argument.getValue();
+            fail();
+        } catch (MockitoException expected) {
+        }
+    }
+
+    @Test
+    public void should_capture_when_full_arg_list_matches() {
+        // given
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.simpleMethod("foo", 1);
+        mock.simpleMethod("bar", 2);
+
+        // then
+        verify(mock).simpleMethod(captor.capture(), eq(1));
+        assertEquals(1, captor.getAllValues().size());
+        assertEquals("foo", captor.getValue());
+    }
+
+    @Test
+    public void should_capture_int_by_creating_captor_with_primitive_wrapper() {
+        // given
+        ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(Integer.class);
+
+        // when
+        mock.intArgumentMethod(10);
+
+        // then
+        verify(mock).intArgumentMethod(argument.capture());
+        assertEquals(10, (int) argument.getValue());
+    }
+
+    @Test
+    public void should_capture_int_by_creating_captor_with_primitive() {
+        // given
+        ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(int.class);
+
+        // when
+        mock.intArgumentMethod(10);
+
+        // then
+        verify(mock).intArgumentMethod(argument.capture());
+        assertEquals(10, (int) argument.getValue());
+    }
+
+    @Test
+    public void should_not_capture_int_by_creating_captor_with_primitive() {
+        // given
+        ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(int.class);
+
+        // when
+        mock.forObject(10L);
+
+        // then
+        verify(mock, never()).forObject(argument.capture());
+    }
+
+    @Test
+    public void should_capture_byte_vararg_by_creating_captor_with_primitive() {
+        // given
+        ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(byte.class);
+
+        // when
+        mock.varargsbyte((byte) 1);
+
+        // then
+        verify(mock).varargsbyte(argumentCaptor.capture());
+        assertEquals((byte) 1, (byte) argumentCaptor.getValue());
+        assertThat(argumentCaptor.getAllValues()).containsExactly((byte) 1);
+    }
+
+    @Test
+    public void should_capture_byte_vararg_by_creating_captor_with_primitive_2_args() {
+        // given
+        ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(byte.class);
+
+        // when
+        mock.varargsbyte((byte) 1, (byte) 2);
+
+        // then
+        verify(mock).varargsbyte(argumentCaptor.capture(), argumentCaptor.capture());
+        assertEquals((byte) 2, (byte) argumentCaptor.getValue());
+        assertThat(argumentCaptor.getAllValues()).containsExactly((byte) 1, (byte) 2);
+    }
+
+    @Test
+    public void should_capture_byte_vararg_by_creating_captor_with_primitive_array() {
+        // given
+        ArgumentCaptor<byte[]> argumentCaptor = ArgumentCaptor.forClass(byte[].class);
+
+        // when
+        mock.varargsbyte();
+        mock.varargsbyte((byte) 1, (byte) 2);
+
+        // then
+        verify(mock, times(2)).varargsbyte(argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue()).containsExactly(new byte[] {1, 2});
+        assertThat(argumentCaptor.getAllValues()).containsExactly(new byte[] {}, new byte[] {1, 2});
+    }
+
+    @Test
+    public void should_capture_byte_vararg_by_creating_captor_with_primitive_wrapper() {
+        // given
+        ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(Byte.class);
+
+        // when
+        mock.varargsbyte((byte) 1);
+
+        // then
+        verify(mock).varargsbyte(argumentCaptor.capture());
+        assertEquals((byte) 1, (byte) argumentCaptor.getValue());
+        assertThat(argumentCaptor.getAllValues()).containsExactly((byte) 1);
+    }
+
+    @Test
+    public void should_not_capture_empty_vararg_with_single_captor() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42);
+
+        // then
+        verify(mock, never()).mixedVarargs(any(), argumentCaptor.capture());
+    }
+
+    @Test
+    public void should_capture_single_vararg_with_single_captor() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42, "a");
+
+        // then
+        verify(mock).mixedVarargs(any(), argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue()).isEqualTo("a");
+    }
+
+    @Test
+    public void should_not_capture_multiple_vararg_with_single_captor() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42, "a", "b");
+
+        // then
+        verify(mock, never()).mixedVarargs(any(), argumentCaptor.capture());
+    }
+
+    @Test
+    public void should_capture_multiple_vararg_with_multiple_captor() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42, "a", "b");
+
+        // then
+        verify(mock).mixedVarargs(any(), argumentCaptor.capture(), argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue()).isEqualTo("b");
+        assertThat(argumentCaptor.getAllValues()).isEqualTo(asList("a", "b"));
+    }
+
+    @Test
+    public void should_not_capture_multiple_vararg_some_null_with_single_captor() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42, "a", null);
+
+        // then
+        verify(mock, never()).mixedVarargs(any(), argumentCaptor.capture());
+    }
+
+    @Test
+    public void should_capture_empty_vararg_with_array_captor() {
+        // given
+        ArgumentCaptor<String[]> argumentCaptor = ArgumentCaptor.forClass(String[].class);
+
+        // when
+        mock.mixedVarargs(42);
+
+        // then
+        verify(mock).mixedVarargs(any(), argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue()).isEqualTo(new String[] {});
+        assertThat(argumentCaptor.getAllValues()).containsExactly(new String[] {});
+    }
+
+    @Test
+    public void should_capture_single_vararg_with_array_captor() {
+        // given
+        ArgumentCaptor<String[]> argumentCaptor = ArgumentCaptor.forClass(String[].class);
+
+        // when
+        mock.mixedVarargs(42, "a");
+
+        // then
+        verify(mock).mixedVarargs(any(), argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue()).isEqualTo(new String[] {"a"});
+        assertThat(argumentCaptor.getAllValues()).containsExactly(new String[] {"a"});
+    }
+
+    @Test
+    public void should_capture_multiple_vararg_with_array_captor() {
+        // given
+        ArgumentCaptor<String[]> argumentCaptor = ArgumentCaptor.forClass(String[].class);
+
+        // when
+        mock.mixedVarargs(42, "a", "b", "c");
+
+        // then
+        verify(mock).mixedVarargs(any(), argumentCaptor.capture());
+        assertThat(argumentCaptor.getAllValues()).containsExactly(new String[] {"a", "b", "c"});
+    }
+
+    @Test
+    public void should_capture_multiple_vararg_some_null_with_array_captor() {
+        // given
+        ArgumentCaptor<String[]> argumentCaptor = ArgumentCaptor.forClass(String[].class);
+
+        // when
+        mock.mixedVarargs(42, "a", null, "c");
+
+        // then
+        verify(mock).mixedVarargs(any(), argumentCaptor.capture());
+        assertThat(argumentCaptor.getAllValues()).containsExactly(new String[] {"a", null, "c"});
+    }
+
+    @Test
+    public void should_capture_multiple_invocations_with_captor() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42, "a", "b");
+        mock.mixedVarargs(42, "c", "d");
+
+        // then
+        verify(mock, times(2))
+                .mixedVarargs(any(), argumentCaptor.capture(), argumentCaptor.capture());
+
+        assertThat(argumentCaptor.getValue()).isEqualTo("d");
+        assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c", "d");
+    }
+
+    @Test
+    public void should_capture_multiple_invocations_with_array_captor() {
+        // given
+        ArgumentCaptor<String[]> argumentCaptor = ArgumentCaptor.forClass(String[].class);
+
+        // when
+        mock.mixedVarargs(42, "a", "b");
+        mock.mixedVarargs(42, "c", "d");
+
+        // then
+        verify(mock, times(2)).mixedVarargs(any(), argumentCaptor.capture());
+
+        assertThat(argumentCaptor.getValue()).isEqualTo(new String[] {"c", "d"});
+        assertThat(argumentCaptor.getAllValues())
+                .containsExactly(new String[] {"a", "b"}, new String[] {"c", "d"});
+    }
+
+    @Test
+    public void should_capture_one_arg_even_when_using_vararg_captor_on_nonvararg_method() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.simpleMethod("a", 2);
+
+        // then
+        verify(mock).simpleMethod(argumentCaptor.capture(), eq(2));
+        assertThat(argumentCaptor.getAllValues()).containsExactly("a");
+    }
+
+    @Test
+    public void captures_correctly_when_captor_used_multiple_times() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.mixedVarargs(42, "a", "b", "c");
+
+        // then
+        // this is only for backwards compatibility. It does not make sense in real to do so.
+        verify(mock)
+                .mixedVarargs(
+                        any(),
+                        argumentCaptor.capture(),
+                        argumentCaptor.capture(),
+                        argumentCaptor.capture());
+        assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c");
+    }
+
+    @Test
+    public void captures_correctly_when_captor_used_on_pure_vararg_method() {
+        // given
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+
+        // when
+        mock.varargs(42, "capturedValue");
+
+        // then
+        verify(mock).varargs(eq(42), argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue()).contains("capturedValue");
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void should_capture_by_type() {
+        // When:
+        mock.simpleMethod(Set.of());
+        mock.simpleMethod(new ArrayList<>(0));
+
+        // Then:
+        ArgumentCaptor<Collection<?>> captor = ArgumentCaptor.forClass(ArrayList.class);
+        verify(mock).simpleMethod(captor.capture());
+        assertThat(captor.getAllValues()).containsExactly(List.of());
+    }
+
+    @Test
+    public void should_capture_by_type_using_annotation() {
+        // When:
+        mock.simpleMethod(Set.of());
+        mock.simpleMethod(new ArrayList<>(0));
+
+        // Then:
+        verify(mock).simpleMethod(listCaptor.capture());
+        assertThat(listCaptor.getAllValues()).containsExactly(List.of());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void should_always_capture_nulls() {
+        // When:
+        mock.simpleMethod((Set<?>) null);
+        mock.simpleMethod((List<?>) null);
+
+        // Then:
+        ArgumentCaptor<Collection<?>> captor = ArgumentCaptor.forClass(ArrayList.class);
+        verify(mock, times(2)).simpleMethod(captor.capture());
+        assertThat(captor.getAllValues()).containsExactly(null, null);
+    }
+}
diff --git a/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java b/mockito-core/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
similarity index 93%
rename from src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
rename to mockito-core/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
index ff6362d707..66e6a20109 100644
--- a/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
@@ -5,7 +5,7 @@
 package org.mockitousage.matchers;
 
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.argThat;
+import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.Mockito.verify;
 
 import org.junit.Test;
@@ -17,8 +17,7 @@
 
 public class CustomMatcherDoesYieldCCETest extends TestBase {
 
-    @Mock
-    private IMethods mock;
+    @Mock private IMethods mock;
 
     @Test
     public void shouldNotThrowCCE() {
diff --git a/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
similarity index 87%
rename from src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
rename to mockito-core/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
index 42d73dd84a..c8dc40de2a 100644
--- a/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
@@ -7,7 +7,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -145,15 +145,20 @@ public void shouldAnonymousCustomMatcherPrintDefaultDescription() {
         mock.simpleMethod("foo");
 
         try {
-            verify(mock).simpleMethod((String) argThat(new ArgumentMatcher<Object>() {
-                public boolean matches(Object argument) {
-                    return false;
-                }}));
+            verify(mock)
+                    .simpleMethod(
+                            (String)
+                                    argThat(
+                                            new ArgumentMatcher<Object>() {
+                                                public boolean matches(Object argument) {
+                                                    return false;
+                                                }
+                                            }));
             fail();
         } catch (AssertionError e) {
             assertThat(e)
-                .hasMessageContaining("<custom argument matcher>")
-                .hasMessageContaining("foo");
+                    .hasMessageContaining("<custom argument matcher>")
+                    .hasMessageContaining("foo");
         }
     }
 }
diff --git a/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
similarity index 80%
rename from src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
rename to mockito-core/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
index 1194c26b83..c779c5bd4c 100644
--- a/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
@@ -4,7 +4,7 @@
  */
 package org.mockitousage.matchers;
 
-import static org.mockito.Matchers.anyObject;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
 import java.util.Date;
@@ -19,6 +19,7 @@ public class GenericMatchersTest extends TestBase {
 
     private interface Foo {
         List<String> sort(List<String> otherList);
+
         String convertDate(Date date);
     }
 
@@ -28,9 +29,9 @@ private interface Foo {
     @Test
     public void shouldCompile() {
         when(sorter.convertDate(new Date())).thenReturn("one");
-        when(sorter.convertDate((Date) anyObject())).thenReturn("two");
+        when(sorter.convertDate((Date) any())).thenReturn("two");
 
-        //following requires warning suppression but allows setting anyList()
+        // following requires warning suppression but allows setting anyList()
         when(sorter.sort(ArgumentMatchers.<String>anyList())).thenReturn(null);
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
new file mode 100644
index 0000000000..261a3c3c96
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.isA;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.hamcrest.MockitoHamcrest.*;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class HamcrestMatchersTest extends TestBase {
+
+    private final class ContainsX extends BaseMatcher<String> {
+        public boolean matches(Object o) {
+            return ((String) o).contains("X");
+        }
+
+        public void describeTo(Description d) {
+            d.appendText("contains 'X'");
+        }
+    }
+
+    @Mock private IMethods mock;
+
+    @Test
+    public void stubs_with_hamcrest_matcher() {
+        when(mock.simpleMethod(argThat(new ContainsX()))).thenReturn("X");
+        assertNull(mock.simpleMethod("blah"));
+        assertEquals("X", mock.simpleMethod("blah X blah"));
+    }
+
+    @Test
+    public void verifies_with_hamcrest_matcher() {
+        mock.simpleMethod("blah");
+
+        try {
+            verify(mock).simpleMethod(argThat(new ContainsX()));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e).hasMessageContaining("contains 'X'");
+        }
+    }
+
+    @Test
+    public void does_not_verify_vararg_with_no_items() {
+        mock.varargs();
+
+        verify(mock, never()).varargs(argThat(isA(String.class)));
+    }
+
+    @Test
+    public void verifies_vararg_with_single_item() {
+        mock.varargs("a");
+
+        verify(mock).varargs(argThat(isA(String.class)));
+    }
+
+    @Test
+    public void does_not_verify_vararg_with_multiple_items() {
+        mock.varargs("a", "b");
+
+        verify(mock, never()).varargs(argThat(isA(String.class)));
+    }
+
+    @Test
+    public void verify_vararg_with_multiple_item() {
+        mock.varargs("a", "b");
+
+        verify(mock).varargs(argThat(isA(String.class)), argThat(isA(String.class)));
+    }
+
+    @Test
+    public void verifies_vararg_with_any_num_items() {
+        mock.varargs();
+        mock.varargs("a");
+        mock.varargs("a", "b");
+
+        verify(mock, times(3)).varargs(argThat(isA(String[].class), String[].class));
+    }
+
+    private final class IntMatcher extends BaseMatcher<Integer> {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    @Test
+    public void supports_primitive_matchers() {
+        when(mock.intArgumentReturningInt(argThat(new IntMatcher()))).thenReturn(5);
+        assertEquals(5, mock.intArgumentReturningInt(10));
+    }
+
+    @Test
+    public void supports_primitive_matchers_from_core_library() {
+        mock.oneArg(true);
+        mock.oneArg((byte) 1);
+        mock.oneArg(2);
+        mock.oneArg(3L);
+        mock.oneArg('4');
+        mock.oneArg(5.0D);
+        mock.oneArg(6.0F);
+
+        verify(mock).oneArg(booleanThat(is(true)));
+        verify(mock).oneArg(byteThat(is((byte) 1)));
+        verify(mock).oneArg(intThat(is(2)));
+        verify(mock).oneArg(longThat(is(3L)));
+        verify(mock).oneArg(charThat(is('4')));
+        verify(mock).oneArg(doubleThat(is(5.0D)));
+        verify(mock).oneArg(floatThat(is(6.0F)));
+    }
+
+    @SuppressWarnings("rawtypes")
+    private class NonGenericMatcher extends BaseMatcher {
+        public boolean matches(Object o) {
+            return true;
+        }
+
+        public void describeTo(Description description) {}
+    }
+
+    @Test
+    public void supports_non_generic_matchers() {
+        when(mock.intArgumentReturningInt(nonGenericMatcher())).thenReturn(5);
+        assertEquals(5, mock.intArgumentReturningInt(10));
+    }
+
+    @SuppressWarnings("unchecked")
+    private int nonGenericMatcher() {
+        argThat(new NonGenericMatcher());
+        return 0;
+    }
+
+    @Test
+    public void coexists_with_mockito_matcher() {
+        when(mock.simpleMethod(
+                        Mockito.argThat(
+                                new ArgumentMatcher<String>() {
+                                    public boolean matches(String argument) {
+                                        return true;
+                                    }
+                                })))
+                .thenReturn("x");
+
+        assertEquals("x", mock.simpleMethod("x"));
+    }
+}
diff --git a/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
similarity index 78%
rename from src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
rename to mockito-core/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
index 59977e25b2..ecd77cada4 100644
--- a/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
@@ -7,7 +7,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.when;
 
@@ -34,17 +34,15 @@ public void should_detect_wrong_number_of_matchers_when_stubbing() {
             when(mock.threeArgumentMethod(1, eq("2"), "3")).thenReturn(null);
             fail();
         } catch (InvalidUseOfMatchersException e) {
-            assertThat(e.getMessage())
-                    .contains("3 matchers expected")
-                    .contains("1 recorded");
+            assertThat(e.getMessage()).contains("3 matchers expected").contains("1 recorded");
         }
     }
 
     @Test
     public void should_detect_stupid_use_of_matchers_when_verifying() {
         mock.oneArg(true);
-        eq("that's the stupid way");
-        eq("of using matchers");
+        Object ignored = eq("that's the stupid way");
+        ignored = eq("of using matchers");
         try {
             Mockito.verify(mock).oneArg(true);
             fail();
@@ -92,9 +90,7 @@ public void should_scream_when_Matchers_count_dont_match_parameter_count() {
             mock.threeArgumentMethod(1, "asd", eq("asd"));
             fail();
         } catch (InvalidUseOfMatchersException e) {
-            assertThat(e.getMessage())
-                    .contains("3 matchers expected")
-                    .contains("1 recorded");
+            assertThat(e.getMessage()).contains("3 matchers expected").contains("1 recorded");
         }
     }
 
@@ -102,19 +98,18 @@ public void should_scream_when_Matchers_count_dont_match_parameter_count() {
     public void should_mention_matcher_when_misuse_detected() {
         // Given
 
-
         // When
         Result run = new JUnitCore().run(ObjectMatcherMisuseOnPrimitiveSite.class);
 
         // Then
 
         assertThat(run.getFailures()).hasSize(2);
-        assertThat(run.getFailures().get(0).getException()).isInstanceOf(NullPointerException.class)
-                                                           .hasMessage(null);
-        assertThat(run.getFailures().get(1).getException()).isInstanceOf(InvalidUseOfMatchersException.class)
-                                                           .hasMessageContaining("primitive alternatives");
+        assertThat(run.getFailures().get(0).getException())
+                .isInstanceOf(NullPointerException.class);
+        assertThat(run.getFailures().get(1).getException())
+                .isInstanceOf(InvalidUseOfMatchersException.class)
+                .hasMessageContaining("primitive alternatives");
         new StateMaster().reset();
-
     }
 
     @RunWith(MockitoJUnitRunner.class)
@@ -122,10 +117,9 @@ public static class ObjectMatcherMisuseOnPrimitiveSite {
         @Test
         public void fails_with_NPE() {
             IMethods mock = Mockito.mock(IMethods.class);
-            doNothing().when(mock)
-                       .twoArgumentMethod(eq(73),
-                                          (Integer) any()); // <= Raise NPE on this call site
+            doNothing()
+                    .when(mock)
+                    .twoArgumentMethod(eq(73), (Integer) any()); // <= Raise NPE on this call site
         }
-
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
new file mode 100644
index 0000000000..b90b547b67
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class MatchersMixedWithRawArgumentsTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    // description of an idea:
+    // types of arguments and descriptor value that identifies matcher:
+    // Object: objenesis instance to check for identity
+    // boolean: false
+    // byte: max-1
+    // short: max-1
+    // int: max-1
+    // long: max-1
+    // char: 'x'
+    // double: max-1
+    // float: max-1
+
+    // 1. how objenesis deal with primitive arrays (like byte[])?
+    // 2. Analisys of all matchers used by R2 project finished before any() and so far proves
+    // it's a good idea.
+
+    @Ignore("prototyping new feature that allows to avoid eq() matchers when raw args passed")
+    @Test
+    public void shouldAllowMixingRawArgumentsWithMatchers() {
+        mock.varargs("1", "2", "3");
+        verify(mock).varargs("1", anyString(), "3");
+
+        verify(mock).varargs(anyBoolean(), false);
+    }
+}
diff --git a/src/test/java/org/mockitousage/matchers/MatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/MatchersTest.java
similarity index 76%
rename from src/test/java/org/mockitousage/matchers/MatchersTest.java
rename to mockito-core/src/test/java/org/mockitousage/matchers/MatchersTest.java
index 8c4b45afed..967fb017ed 100644
--- a/src/test/java/org/mockitousage/matchers/MatchersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/MatchersTest.java
@@ -5,6 +5,7 @@
 package org.mockitousage.matchers;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.fail;
@@ -19,8 +20,9 @@
 import static org.mockito.AdditionalMatchers.lt;
 import static org.mockito.AdditionalMatchers.not;
 import static org.mockito.AdditionalMatchers.or;
+import static org.mockito.ArgumentMatchers.assertArg;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.nullable;
-import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.anyBoolean;
 import static org.mockito.Mockito.anyByte;
@@ -29,10 +31,10 @@
 import static org.mockito.Mockito.anyFloat;
 import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.anyLong;
-import static org.mockito.Mockito.anyObject;
 import static org.mockito.Mockito.anyShort;
 import static org.mockito.Mockito.anyString;
 import static org.mockito.Mockito.contains;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.endsWith;
 import static org.mockito.Mockito.isA;
 import static org.mockito.Mockito.isNotNull;
@@ -46,21 +48,22 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import java.io.IOException;
 import java.math.BigDecimal;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.RandomAccess;
 import java.util.regex.Pattern;
 
+import org.junit.ComparisonFailure;
 import org.junit.Test;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 import org.mockito.exceptions.verification.WantedButNotInvoked;
 import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-
 @SuppressWarnings("unchecked")
 public class MatchersTest extends TestBase {
     private IMethods mock = Mockito.mock(IMethods.class);
@@ -285,9 +288,7 @@ public void any_T_matcher() {
         when(mock.oneArg(anyInt())).thenReturn("5");
         when(mock.oneArg(anyLong())).thenReturn("6");
         when(mock.oneArg(anyShort())).thenReturn("7");
-        when(mock.oneArg((String) anyObject())).thenReturn("8");
-        when(mock.oneArg(Mockito.<Object>anyObject())).thenReturn("9");
-        when(mock.oneArg(any(RandomAccess.class))).thenReturn("10");
+        when(mock.oneArg(any(RandomAccess.class))).thenReturn("8");
 
         assertEquals("0", mock.oneArg(true));
         assertEquals("0", mock.oneArg(false));
@@ -299,12 +300,8 @@ public void any_T_matcher() {
         assertEquals("5", mock.oneArg(1));
         assertEquals("6", mock.oneArg(1L));
         assertEquals("7", mock.oneArg((short) 1));
-        assertEquals("8", mock.oneArg("Test"));
-
-        assertEquals("9", mock.oneArg(new Object()));
-        assertEquals("9", mock.oneArg(new HashMap()));
 
-        assertEquals("10", mock.oneArg(new ArrayList()));
+        assertEquals("8", mock.oneArg(new ArrayList()));
     }
 
     @Test
@@ -326,59 +323,70 @@ public void should_array_equals_deal_with_null_array() throws Exception {
 
     @Test
     public void should_use_smart_equals_for_arrays() throws Exception {
-        //issue 143
-        mock.arrayMethod(new String[]{"one"});
-        verify(mock).arrayMethod(eq(new String[]{"one"}));
-        verify(mock).arrayMethod(new String[]{"one"});
+        // issue 143
+        mock.arrayMethod(new String[] {"one"});
+        verify(mock).arrayMethod(eq(new String[] {"one"}));
+        verify(mock).arrayMethod(new String[] {"one"});
     }
 
     @Test
     public void should_use_smart_equals_for_primitive_arrays() throws Exception {
-        //issue 143
-        mock.objectArgMethod(new int[]{1, 2});
-        verify(mock).objectArgMethod(eq(new int[]{1, 2}));
-        verify(mock).objectArgMethod(new int[]{1, 2});
+        // issue 143
+        mock.objectArgMethod(new int[] {1, 2});
+        verify(mock).objectArgMethod(eq(new int[] {1, 2}));
+        verify(mock).objectArgMethod(new int[] {1, 2});
     }
 
-    @Test(expected = ArgumentsAreDifferent.class)
-    public void array_equals_should_throw_ArgumentsAreDifferentException_for_non_matching_arguments() {
+    @SuppressWarnings("ReturnValueIgnored")
+    @Test
+    public void
+            array_equals_should_throw_ArgumentsAreDifferentException_for_non_matching_arguments() {
         List<Object> list = Mockito.mock(List.class);
 
         list.add("test"); // testing fix for issue 20
-        list.contains(new Object[]{"1"});
+        list.contains(new Object[] {"1"});
 
-        Mockito.verify(list).contains(new Object[]{"1", "2", "3"});
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.verify(list).contains(new Object[] {"1", "2", "3"});
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "list.contains([\"1\", \"2\", \"3\"]);",
+                        "Actual invocations have different arguments:",
+                        "list.add(\"test\");");
     }
 
     @Test
     public void array_equals_matcher() {
-        when(mock.oneArray(aryEq(new boolean[]{true, false, false}))).thenReturn("0");
-        when(mock.oneArray(aryEq(new byte[]{1}))).thenReturn("1");
-        when(mock.oneArray(aryEq(new char[]{1}))).thenReturn("2");
-        when(mock.oneArray(aryEq(new double[]{1}))).thenReturn("3");
-        when(mock.oneArray(aryEq(new float[]{1}))).thenReturn("4");
-        when(mock.oneArray(aryEq(new int[]{1}))).thenReturn("5");
-        when(mock.oneArray(aryEq(new long[]{1}))).thenReturn("6");
-        when(mock.oneArray(aryEq(new short[]{1}))).thenReturn("7");
-        when(mock.oneArray(aryEq(new String[]{"Test"}))).thenReturn("8");
-        when(mock.oneArray(aryEq(new Object[]{"Test", new Integer(4)}))).thenReturn("9");
-
-        assertEquals("0", mock.oneArray(new boolean[]{true, false, false}));
-        assertEquals("1", mock.oneArray(new byte[]{1}));
-        assertEquals("2", mock.oneArray(new char[]{1}));
-        assertEquals("3", mock.oneArray(new double[]{1}));
-        assertEquals("4", mock.oneArray(new float[]{1}));
-        assertEquals("5", mock.oneArray(new int[]{1}));
-        assertEquals("6", mock.oneArray(new long[]{1}));
-        assertEquals("7", mock.oneArray(new short[]{1}));
-        assertEquals("8", mock.oneArray(new String[]{"Test"}));
-        assertEquals("9", mock.oneArray(new Object[]{"Test", new Integer(4)}));
-
-        assertEquals(null, mock.oneArray(new Object[]{"Test", new Integer(999)}));
-        assertEquals(null, mock.oneArray(new Object[]{"Test", new Integer(4), "x"}));
-
-        assertEquals(null, mock.oneArray(new boolean[]{true, false}));
-        assertEquals(null, mock.oneArray(new boolean[]{true, true, false}));
+        when(mock.oneArray(aryEq(new boolean[] {true, false, false}))).thenReturn("0");
+        when(mock.oneArray(aryEq(new byte[] {1}))).thenReturn("1");
+        when(mock.oneArray(aryEq(new char[] {1}))).thenReturn("2");
+        when(mock.oneArray(aryEq(new double[] {1}))).thenReturn("3");
+        when(mock.oneArray(aryEq(new float[] {1}))).thenReturn("4");
+        when(mock.oneArray(aryEq(new int[] {1}))).thenReturn("5");
+        when(mock.oneArray(aryEq(new long[] {1}))).thenReturn("6");
+        when(mock.oneArray(aryEq(new short[] {1}))).thenReturn("7");
+        when(mock.oneArray(aryEq(new String[] {"Test"}))).thenReturn("8");
+        when(mock.oneArray(aryEq(new Object[] {"Test", new Integer(4)}))).thenReturn("9");
+
+        assertEquals("0", mock.oneArray(new boolean[] {true, false, false}));
+        assertEquals("1", mock.oneArray(new byte[] {1}));
+        assertEquals("2", mock.oneArray(new char[] {1}));
+        assertEquals("3", mock.oneArray(new double[] {1}));
+        assertEquals("4", mock.oneArray(new float[] {1}));
+        assertEquals("5", mock.oneArray(new int[] {1}));
+        assertEquals("6", mock.oneArray(new long[] {1}));
+        assertEquals("7", mock.oneArray(new short[] {1}));
+        assertEquals("8", mock.oneArray(new String[] {"Test"}));
+        assertEquals("9", mock.oneArray(new Object[] {"Test", new Integer(4)}));
+
+        assertEquals(null, mock.oneArray(new Object[] {"Test", new Integer(999)}));
+        assertEquals(null, mock.oneArray(new Object[] {"Test", new Integer(4), "x"}));
+
+        assertEquals(null, mock.oneArray(new boolean[] {true, false}));
+        assertEquals(null, mock.oneArray(new boolean[] {true, true, false}));
     }
 
     @Test
@@ -454,14 +462,14 @@ public void null_matcher() {
 
     @Test
     public void null_matcher_for_primitive_wrappers() {
-        when(mock.forBoolean(isNull(Boolean.class))).thenReturn("ok");
-        when(mock.forInteger(isNull(Integer.class))).thenReturn("ok");
-        when(mock.forLong(isNull(Long.class))).thenReturn("ok");
-        when(mock.forByte(isNull(Byte.class))).thenReturn("ok");
-        when(mock.forShort(isNull(Short.class))).thenReturn("ok");
-        when(mock.forCharacter(isNull(Character.class))).thenReturn("ok");
-        when(mock.forDouble(isNull(Double.class))).thenReturn("ok");
-        when(mock.forFloat(isNull(Float.class))).thenReturn("ok");
+        when(mock.forBoolean(ArgumentMatchers.<Boolean>isNull())).thenReturn("ok");
+        when(mock.forInteger(ArgumentMatchers.<Integer>isNull())).thenReturn("ok");
+        when(mock.forLong(ArgumentMatchers.<Long>isNull())).thenReturn("ok");
+        when(mock.forByte(ArgumentMatchers.<Byte>isNull())).thenReturn("ok");
+        when(mock.forShort(ArgumentMatchers.<Short>isNull())).thenReturn("ok");
+        when(mock.forCharacter(ArgumentMatchers.<Character>isNull())).thenReturn("ok");
+        when(mock.forDouble(ArgumentMatchers.<Double>isNull())).thenReturn("ok");
+        when(mock.forFloat(ArgumentMatchers.<Float>isNull())).thenReturn("ok");
 
         assertEquals("ok", mock.forBoolean(null));
         assertEquals("ok", mock.forInteger(null));
@@ -511,6 +519,14 @@ public void matches_Pattern_matcher() {
         assertEquals(null, mock.oneArg("blah"));
     }
 
+    @Test
+    public void matches_Pattern_matcher_in_subregion() {
+        when(mock.oneArg(matches(Pattern.compile("[a-z]")))).thenReturn("1");
+
+        assertEquals("1", mock.oneArg("3a45"));
+        assertEquals(null, mock.oneArg("3445"));
+    }
+
     @Test
     public void contains_matcher() {
         when(mock.oneArg(contains("ell"))).thenReturn("1");
@@ -608,8 +624,73 @@ public void same_matcher_and_nulls() {
     public void nullable_matcher() throws Exception {
         // imagine a Stream.of(...).map(c -> mock.oneArg(c))...
         mock.oneArg((Character) null);
-        mock.oneArg(Character.valueOf('€'));
+        mock.oneArg(Character.valueOf('\u20AC'));
 
         verify(mock, times(2)).oneArg(nullable(Character.class));
     }
+
+    @Test
+    public void assertArg_matcher() throws Exception {
+        mock.oneArg("hello");
+
+        verify(mock).oneArg(assertArg((String it) -> assertEquals("hello", it)));
+    }
+
+    @Test
+    public void assertArg_matcher_fails_when_assertion_fails() throws Exception {
+        mock.oneArg("hello");
+
+        try {
+            verify(mock).oneArg(assertArg((String it) -> assertEquals("not-hello", it)));
+            fail("Should throw an exception");
+        } catch (ComparisonFailure e) {
+            // do nothing
+        }
+    }
+
+    @Test
+    public void assertArg_matcher_can_accept_throwing_consumer() throws Exception {
+        mock.oneArg("hello");
+
+        try {
+            verify(mock)
+                    .oneArg(
+                            assertArg(
+                                    (String it) -> {
+                                        assertEquals("not-hello", it);
+                                        doThrow(new IOException()).when(mock).throwsIOException(0);
+                                    }));
+            fail("Should throw an exception");
+        } catch (ComparisonFailure e) {
+            // do nothing
+        }
+    }
+
+    @Test
+    public void can_invoke_method_on_mock_after_assert_arg() throws Exception {
+        mock.oneArg("hello");
+
+        try {
+            verify(mock).oneArg(assertArg((String it) -> assertEquals("not-hello", it)));
+            fail("Should throw an exception");
+        } catch (ComparisonFailure e) {
+            // do nothing
+        }
+
+        mock.oneArg("hello");
+    }
+
+    @Test
+    public void can_verify_on_mock_after_assert_arg() throws Exception {
+        mock.oneArg("hello");
+
+        try {
+            verify(mock).oneArg(assertArg((String it) -> assertEquals("not-hello", it)));
+            fail("Should throw an exception");
+        } catch (ComparisonFailure e) {
+            // do nothing
+        }
+
+        verify(mock).oneArg("hello");
+    }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
new file mode 100644
index 0000000000..c68d5482dd
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.*;
+
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class MoreMatchersTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    @Test
+    public void should_help_out_with_unnecessary_casting() {
+        when(mock.objectArgMethod(any(String.class))).thenReturn("string");
+
+        assertEquals("string", mock.objectArgMethod("foo"));
+    }
+
+    @Test
+    public void any_class_should_be_actual_alias_to_isA() {
+        mock.simpleMethod(new ArrayList());
+
+        verify(mock).simpleMethod(isA(List.class));
+        verify(mock).simpleMethod(any(List.class));
+
+        mock.simpleMethod((String) null);
+
+        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);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/NewMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
new file mode 100644
index 0000000000..69ff3c41ef
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class NewMatchersTest extends TestBase {
+
+    private IMethods mock;
+
+    @Before
+    public void setUp() {
+        mock = Mockito.mock(IMethods.class);
+    }
+
+    @Test
+    public void shouldAllowAnyList() {
+        when(mock.forList(anyList())).thenReturn("matched");
+
+        assertEquals("matched", mock.forList(Arrays.asList("x", "y")));
+        assertEquals(null, mock.forList(null));
+
+        verify(mock, times(1)).forList(anyList());
+    }
+
+    @Test
+    public void shouldAllowAnyCollection() {
+        when(mock.forCollection(anyCollection())).thenReturn("matched");
+
+        assertEquals("matched", mock.forCollection(Arrays.asList("x", "y")));
+        assertEquals(null, mock.forCollection(null));
+
+        verify(mock, times(1)).forCollection(anyCollection());
+    }
+
+    @Test
+    public void shouldAllowAnyMap() {
+        when(mock.forMap(anyMap())).thenReturn("matched");
+
+        assertEquals("matched", mock.forMap(new HashMap<String, String>()));
+        assertEquals(null, mock.forMap(null));
+
+        verify(mock, times(1)).forMap(anyMap());
+    }
+
+    @Test
+    public void shouldAllowAnySet() {
+        when(mock.forSet(anySet())).thenReturn("matched");
+
+        assertEquals("matched", mock.forSet(new HashSet<String>()));
+        assertEquals(null, mock.forSet(null));
+
+        verify(mock, times(1)).forSet(anySet());
+    }
+
+    @Test
+    public void shouldAllowAnyIterable() {
+        when(mock.forIterable(anyIterable())).thenReturn("matched");
+
+        assertEquals("matched", mock.forIterable(new HashSet<String>()));
+        assertEquals(null, mock.forIterable(null));
+
+        verify(mock, times(1)).forIterable(anyIterable());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
new file mode 100644
index 0000000000..5afd360c15
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.refEq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("all")
+public class ReflectionMatchersTest extends TestBase {
+
+    class Parent {
+        private int parentField;
+        protected String protectedParentField;
+
+        public Parent(int parentField, String protectedParentField) {
+            this.parentField = parentField;
+            this.protectedParentField = protectedParentField;
+        }
+    }
+
+    class Child extends Parent {
+        private int childFieldOne;
+        private Object childFieldTwo;
+
+        public Child(
+                int parentField,
+                String protectedParentField,
+                int childFieldOne,
+                Object childFieldTwo) {
+            super(parentField, protectedParentField);
+            this.childFieldOne = childFieldOne;
+            this.childFieldTwo = childFieldTwo;
+        }
+    }
+
+    interface MockMe {
+        void run(Child child);
+    }
+
+    MockMe mock;
+
+    @Before
+    public void setup() {
+        mock = mock(MockMe.class);
+
+        Child actual = new Child(1, "foo", 2, "bar");
+        mock.run(actual);
+    }
+
+    @Test
+    public void shouldMatchWhenFieldValuesEqual() throws Exception {
+        Child wanted = new Child(1, "foo", 2, "bar");
+        verify(mock).run(refEq(wanted));
+    }
+
+    @Test
+    public void shouldNotMatchWhenFieldValuesDiffer() throws Exception {
+        Child wanted = new Child(1, "foo", 2, "bar XXX");
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).run(refEq(wanted));
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mockMe.run(",
+                        "    refEq(org.mockitousage.matchers.ReflectionMatchersTest",
+                        "Actual invocations have different arguments:",
+                        "mockMe.run(",
+                        "    org.mockitousage.matchers.ReflectionMatchersTest");
+    }
+
+    @Test
+    public void shouldNotMatchAgain() throws Exception {
+        Child wanted = new Child(1, "foo", 999, "bar");
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).run(refEq(wanted));
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mockMe.run(",
+                        "    refEq(org.mockitousage.matchers.ReflectionMatchersTest",
+                        "Actual invocations have different arguments:",
+                        "mockMe.run(",
+                        "    org.mockitousage.matchers.ReflectionMatchersTest");
+    }
+
+    @Test
+    public void shouldNotMatchYetAgain() throws Exception {
+        Child wanted = new Child(1, "XXXXX", 2, "bar");
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).run(refEq(wanted));
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mockMe.run(",
+                        "    refEq(org.mockitousage.matchers.ReflectionMatchersTest",
+                        "Actual invocations have different arguments:",
+                        "mockMe.run(",
+                        "    org.mockitousage.matchers.ReflectionMatchersTest");
+    }
+
+    @Test
+    public void shouldNotMatch() throws Exception {
+        Child wanted = new Child(234234, "foo", 2, "bar");
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).run(refEq(wanted));
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mockMe.run(",
+                        "    refEq(org.mockitousage.matchers.ReflectionMatchersTest",
+                        "Actual invocations have different arguments:",
+                        "mockMe.run(",
+                        "    org.mockitousage.matchers.ReflectionMatchersTest");
+    }
+
+    @Test
+    public void shouldMatchWhenFieldValuesEqualWithOneFieldExcluded() throws Exception {
+        Child wanted = new Child(1, "foo", 2, "excluded");
+        verify(mock).run(refEq(wanted, "childFieldTwo"));
+    }
+
+    @Test
+    public void shouldMatchWhenFieldValuesEqualWithTwoFieldsExcluded() throws Exception {
+        Child wanted = new Child(234234, "foo", 2, "excluded");
+        verify(mock).run(refEq(wanted, "childFieldTwo", "parentField"));
+        verify(mock).run(refEq(wanted, "parentField", "childFieldTwo"));
+    }
+
+    @Test
+    public void shouldNotMatchWithFieldsExclusion() throws Exception {
+        Child wanted = new Child(234234, "foo", 2, "excluded");
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).run(refEq(wanted, "childFieldTwo"));
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "mockMe.run(",
+                        "    refEq(org.mockitousage.matchers.ReflectionMatchersTest",
+                        "Actual invocations have different arguments:",
+                        "mockMe.run(",
+                        "    org.mockitousage.matchers.ReflectionMatchersTest");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/matchers/VarargsTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/VarargsTest.java
new file mode 100644
index 0000000000..5daba370eb
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/VarargsTest.java
@@ -0,0 +1,587 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.matchers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalMatchers.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.isNotNull;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.assertj.core.api.AbstractListAssert;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.Condition;
+import org.assertj.core.api.ObjectAssert;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockitousage.IMethods;
+import org.mockitousage.IMethods.BaseType;
+
+public class VarargsTest {
+
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Captor private ArgumentCaptor<String> captor;
+    @Captor private ArgumentCaptor<String[]> arrayCaptor;
+    @Mock private IMethods mock;
+
+    private static final Condition<Object> NULL =
+            new Condition<Object>() {
+
+                @Override
+                public boolean matches(Object value) {
+                    return value == null;
+                }
+            };
+
+    @Test
+    public void shouldMatchVarArgs_noArgs() {
+        mock.varargs();
+
+        verify(mock).varargs();
+    }
+
+    @Test
+    public void shouldMatchEmptyVarArgs_noArgsIsNotNull() {
+        mock.varargs();
+
+        verify(mock).varargs(isNotNull(String[].class));
+    }
+
+    @Test
+    public void shouldMatchEmptyVarArgs_noArgsIsNull() {
+        mock.varargs((String[]) null);
+
+        verify(mock).varargs(isNull(String[].class));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_oneNullArg_eqNull() {
+        Object arg = null;
+        mock.varargs(arg);
+
+        verify(mock).varargs(ArgumentMatchers.<Object[]>eq(null));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_oneNullArg_isNull() {
+        mock.varargs((Object) null);
+
+        verify(mock).varargs(ArgumentMatchers.<Object>isNull());
+        verify(mock, never()).varargs(isNull(Object[].class));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_nullArrayArg() {
+        mock.varargs((Object[]) null);
+
+        verify(mock).varargs(isNull(Object[].class));
+        verify(mock).varargs(ArgumentMatchers.<Object>isNull());
+    }
+
+    @Test
+    public void shouldnotMatchVarArgs_twoArgsOneMatcher() {
+        mock.varargs("1", "1");
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).varargs(eq("1"));
+                        })
+                .hasMessageContaining("Argument(s) are different");
+    }
+
+    @Test
+    public void shouldMatchVarArgs_emptyVarArgsOneAnyMatcher() {
+        mock.varargs();
+
+        verify(mock).varargs(any(String[].class));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_oneArgsOneAnyMatcher() {
+        mock.varargs(1);
+
+        verify(mock).varargs(any(Object[].class));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_twoArgsOneAnyMatcher() {
+        mock.varargs(1, 2);
+
+        verify(mock).varargs(any(Object[].class));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_twoArgsTwoAnyMatcher() {
+        mock.varargs(1, 2);
+
+        verify(mock).varargs(any(), ArgumentMatchers.<Object>any());
+    }
+
+    @Test
+    public void shouldMatchVarArgs_twoArgsThreeAnyMatcher() {
+        mock.varargs(1, 2);
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).varargs(any(), any(), any());
+                        })
+                .hasMessageContaining("Argument(s) are different");
+    }
+
+    @Test
+    public void shouldMatchVarArgs_oneNullArgument() {
+        mock.varargs("1", null);
+
+        verify(mock).varargs(eq("1"), (String) isNull());
+    }
+
+    @Test
+    public void shouldMatchVarArgs_onebyte() {
+        mock.varargsbyte((byte) 1);
+
+        verify(mock).varargsbyte(eq((byte) 1));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_nullByteArray() {
+        mock.varargsbyte(null);
+
+        verify(mock).varargsbyte((byte[]) isNull());
+    }
+
+    @Test
+    public void shouldMatchVarArgs_emptyByteArray() {
+        mock.varargsbyte();
+
+        verify(mock).varargsbyte();
+    }
+
+    @Test
+    public void shouldMatchEmptyVarArgs_emptyArrayIsNotNull() {
+        mock.varargsbyte();
+
+        verify(mock).varargsbyte(isNotNull(byte[].class));
+    }
+
+    @Test
+    public void shouldMatchVarArgs_oneArgIsNotNull() {
+        mock.varargsbyte((byte) 1);
+
+        verify(mock).varargsbyte((byte[]) isNotNull());
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_noArgs() {
+        mock.varargs();
+
+        verify(mock).varargs(arrayCaptor.capture());
+
+        assertThatCaptor(arrayCaptor).contains(new String[] {});
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_oneNullArg_eqNull() {
+        String arg = null;
+        mock.varargs(arg);
+
+        verify(mock).varargs(captor.capture());
+
+        assertThatCaptor(captor).areExactly(1, NULL);
+    }
+
+    /**
+     * Relates to Github issue #583 "ArgumentCaptor: NPE when an null array is
+     * passed to a varargs method"
+     */
+    @Test
+    public void shouldCaptureVarArgs_nullArrayArg() {
+        String[] argArray = null;
+        mock.varargs(argArray);
+
+        verify(mock).varargs(captor.capture());
+        assertThatCaptor(captor).areExactly(1, NULL);
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_twoArgsOneCapture() {
+        mock.varargs("1", "2");
+
+        verify(mock).varargs(arrayCaptor.capture());
+
+        assertThatCaptor(arrayCaptor).contains(new String[] {"1", "2"});
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_twoArgsTwoCaptures() {
+        mock.varargs("1", "2");
+
+        verify(mock).varargs(captor.capture(), captor.capture());
+
+        assertThatCaptor(captor).contains("1", "2");
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_oneNullArgument2() {
+        mock.varargs("1", null);
+
+        verify(mock).varargs(captor.capture(), captor.capture());
+
+        assertThatCaptor(captor).contains("1", (String) null);
+    }
+
+    @Test
+    public void shouldNotCaptureVarArgs_3args2captures() {
+        mock.varargs("1", "2", "3");
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).varargs(captor.capture(), captor.capture());
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class);
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_3argsCaptorMatcherMix() {
+        mock.varargs("1", "2", "3");
+
+        verify(mock).varargs(captor.capture(), eq("2"), captor.capture());
+
+        assertThatCaptor(captor).containsExactly("1", "3");
+    }
+
+    @Test
+    public void shouldNotCaptureVarArgs_3argsCaptorMatcherMix() {
+        mock.varargs("1", "2", "3");
+
+        try {
+            verify(mock).varargs(captor.capture(), eq("X"), captor.capture());
+            fail("The verification must fail, cause the second arg was not 'X' as expected!");
+        } catch (ArgumentsAreDifferent expected) {
+        }
+
+        assertThatCaptor(captor).isEmpty();
+    }
+
+    @Test
+    public void shouldNotCaptureVarArgs_1args2captures() {
+        mock.varargs("1");
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).varargs(captor.capture(), captor.capture());
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class);
+    }
+
+    @Test
+    public void shouldCaptureVarArgsAsArray() {
+        mock.varargs("1", "2");
+
+        ArgumentCaptor<String[]> varargCaptor = ArgumentCaptor.forClass(String[].class);
+
+        verify(mock).varargs(varargCaptor.capture());
+
+        assertThatCaptor(varargCaptor).containsExactly(new String[] {"1", "2"});
+    }
+
+    @Test
+    public void shouldNotMatchRegualrAndVaraArgs() {
+        mock.varargsString(1, "a", "b");
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).varargsString(1);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class);
+    }
+
+    @Test
+    public void shouldNotMatchVaraArgs() {
+        when(mock.varargsObject(1, "a", "b")).thenReturn("OK");
+
+        Assertions.assertThat(mock.varargsObject(1)).isNull();
+    }
+
+    @Test
+    public void shouldDifferentiateNonVarargVariant() {
+        given(mock.methodWithVarargAndNonVarargVariants(any(String.class)))
+                .willReturn("single arg method");
+
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a")).isEqualTo("single arg method");
+        assertThat(mock.methodWithVarargAndNonVarargVariants(new String[] {"a"})).isNull();
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a", "b")).isNull();
+    }
+
+    @Test
+    public void shouldMockVarargsInvocation_single_vararg_matcher() {
+        given(mock.methodWithVarargAndNonVarargVariants(any(String[].class)))
+                .willReturn("var arg method");
+
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a")).isNull();
+        assertThat(mock.methodWithVarargAndNonVarargVariants(new String[] {"a"}))
+                .isEqualTo("var arg method");
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a", "b")).isEqualTo("var arg method");
+    }
+
+    @Test
+    public void shouldMockVarargsInvocation_multiple_vararg_matcher() {
+        given(mock.methodWithVarargAndNonVarargVariants(any(String.class), any(String.class)))
+                .willReturn("var arg method");
+
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a")).isNull();
+        assertThat(mock.methodWithVarargAndNonVarargVariants(new String[] {"a"})).isNull();
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a", "b")).isEqualTo("var arg method");
+        assertThat(mock.methodWithVarargAndNonVarargVariants(new String[] {"a", "b"}))
+                .isEqualTo("var arg method");
+        assertThat(mock.methodWithVarargAndNonVarargVariants("a", "b", "c")).isNull();
+    }
+
+    @Test
+    public void shouldMockVarargsInvocationForSuperType() {
+        given(mock.varargsReturningString(any(Object[].class))).willReturn("a");
+
+        assertThat(mock.varargsReturningString("a", "b")).isEqualTo("a");
+    }
+
+    @Test
+    public void shouldHandleArrayVarargsMethods() {
+        given(mock.arrayVarargsMethod(any(String[][].class))).willReturn(1);
+
+        assertThat(mock.arrayVarargsMethod(new String[] {})).isEqualTo(1);
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_NullArrayArg1() {
+        mock.varargs((String[]) null);
+        ArgumentCaptor<String[]> captor = ArgumentCaptor.forClass(String[].class);
+
+        verify(mock).varargs(captor.capture());
+
+        assertThat(captor.getValue()).isNull();
+    }
+
+    @Test
+    public void shouldCaptureVarArgs_NullArrayArg2() {
+        mock.varargs((String[]) null);
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+
+        verify(mock).varargs(captor.capture());
+
+        assertThat(captor.getValue()).isNull();
+    }
+
+    @Test
+    public void shouldVerifyVarArgs_any_NullArrayArg1() {
+        mock.varargs((String[]) null);
+
+        verify(mock).varargs(any());
+    }
+
+    @Test
+    public void shouldVerifyVarArgs_any_NullArrayArg2() {
+        mock.varargs((String) null);
+
+        verify(mock).varargs(any());
+    }
+
+    @Test
+    public void shouldVerifyVarArgs_eq_NullArrayArg1() {
+        mock.varargs((String[]) null);
+
+        verify(mock).varargs(eq(null));
+    }
+
+    @Test
+    public void shouldVerifyVarArgs_eq_NullArrayArg2() {
+        mock.varargs((String) null);
+
+        verify(mock).varargs(eq(null));
+    }
+
+    @Test
+    public void shouldVerifyVarArgs_isNull_NullArrayArg() {
+        mock.varargs((String) null);
+
+        verify(mock).varargs(isNull(String.class));
+    }
+
+    @Test
+    public void shouldVerifyVarArgs_isNull_NullArrayArg2() {
+        mock.varargs((String) null);
+
+        verify(mock).varargs(isNull());
+    }
+
+    @Test
+    public void shouldVerifyExactlyOneVarArg_isA() {
+        mock.varargs("one param");
+
+        verify(mock).varargs(isA(String.class));
+    }
+
+    @Test
+    public void shouldNotVerifyExactlyOneVarArg_isA() {
+        mock.varargs("two", "params");
+
+        verify(mock, never()).varargs(isA(String.class));
+    }
+
+    @Test
+    public void shouldVerifyVarArgArray_isA() {
+        mock.varargs("one param");
+
+        verify(mock).varargs(isA(String[].class));
+    }
+
+    @Test
+    public void shouldVerifyVarArgArray_isA2() {
+        mock.varargs("two", "params");
+
+        verify(mock).varargs(isA(String[].class));
+    }
+
+    @Test
+    public void shouldVerifyExactlyOneVarArg_any() {
+        mock.varargs("one param");
+
+        verify(mock).varargs(any(String.class));
+    }
+
+    @Test
+    @Ignore("Fails due to https://github.com/mockito/mockito/issues/1593")
+    public void shouldNotVerifyExactlyOneVarArg_any() {
+        mock.varargs("two", "params");
+
+        verify(mock, never()).varargs(any(String.class));
+    }
+
+    @Test
+    public void shouldMockVarargInvocation_eq() {
+        given(mock.varargs(eq("one param"))).willReturn(1);
+
+        assertThat(mock.varargs("one param")).isEqualTo(1);
+        assertThat(mock.varargs()).isEqualTo(0);
+        assertThat(mock.varargs("different")).isEqualTo(0);
+        assertThat(mock.varargs("one param", "another")).isEqualTo(0);
+    }
+
+    @Test
+    public void shouldVerifyInvocation_eq() {
+        mock.varargs("one param");
+
+        verify(mock).varargs(eq("one param"));
+        verify(mock, never()).varargs();
+        verify(mock, never()).varargs(eq("different"));
+        verify(mock, never()).varargs(eq("one param"), eq("another"));
+    }
+
+    @Test
+    public void shouldMockVarargInvocation_eq_raw() {
+        given(mock.varargs(eq(new String[] {"one param"}))).willReturn(1);
+
+        assertThat(mock.varargs("one param")).isEqualTo(1);
+        assertThat(mock.varargs()).isEqualTo(0);
+        assertThat(mock.varargs("different")).isEqualTo(0);
+        assertThat(mock.varargs("one param", "another")).isEqualTo(0);
+    }
+
+    @Test
+    public void shouldVerifyInvocation_eq_raw() {
+        mock.varargs("one param");
+
+        verify(mock).varargs(eq(new String[] {"one param"}));
+        verify(mock, never()).varargs(eq(new String[] {}));
+        verify(mock, never()).varargs(eq(new String[] {"different"}));
+        verify(mock, never()).varargs(eq(new String[] {"one param", "another"}));
+    }
+
+    @Test
+    public void shouldVerifyInvocation_not() {
+        mock.varargs("one param");
+
+        verify(mock).varargs(not(eq(new String[] {"diff"})));
+        verify(mock, never()).varargs(not(eq(new String[] {"one param"})));
+    }
+
+    @Test
+    public void shouldVerifyInvocation_same() {
+        String[] args = {"two", "params"};
+
+        mock.varargs(args);
+
+        verify(mock).varargs(same(args));
+        verify(mock, never()).varargs(same(new String[] {"two", "params"}));
+    }
+
+    @Test
+    public void shouldVerifySubTypes() {
+        mock.polyVararg(new SubType(), new SubType());
+
+        verify(mock).polyVararg(eq(new SubType()), eq(new SubType()));
+        verify(mock).polyVararg(eq(new SubType[] {new SubType(), new SubType()}));
+        verify(mock).polyVararg(eq(new BaseType[] {new SubType(), new SubType()}));
+    }
+
+    @Test
+    public void shouldVerifyInvocation_or() {
+        mock.polyVararg(new SubType(), new SubType());
+
+        verify(mock)
+                .polyVararg(
+                        or(
+                                eq(new BaseType[] {new SubType()}),
+                                eq(new SubType[] {new SubType(), new SubType()})));
+        verify(mock)
+                .polyVararg(
+                        or(
+                                eq(new BaseType[] {new SubType(), new SubType()}),
+                                eq(new SubType[] {new SubType()})));
+    }
+
+    @Test
+    public void shouldVerifyInvocation_and() {
+        mock.polyVararg(new SubType(), new SubType());
+
+        verify(mock)
+                .polyVararg(
+                        and(
+                                eq(new BaseType[] {new SubType(), new SubType()}),
+                                eq(new SubType[] {new SubType(), new SubType()})));
+    }
+
+    private static <T> AbstractListAssert<?, ?, T, ObjectAssert<T>> assertThatCaptor(
+            ArgumentCaptor<T> captor) {
+        return Assertions.assertThat(captor.getAllValues());
+    }
+
+    private static class SubType implements BaseType {
+        @Override
+        public boolean equals(final Object obj) {
+            return obj != null && obj.getClass().equals(getClass());
+        }
+
+        @Override
+        public int hashCode() {
+            return super.hashCode();
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
similarity index 94%
rename from src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
rename to mockito-core/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
index 3da81c586f..d0d9cf9be1 100644
--- a/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
@@ -44,7 +44,8 @@ public void shouldStubUsingMatchers() {
         try {
             three.simpleMethod("test three again");
             fail();
-        } catch (RuntimeException e) {}
+        } catch (RuntimeException e) {
+        }
     }
 
     @Test
@@ -55,7 +56,8 @@ public void shouldVerifyUsingMatchers() {
         try {
             one.oneArg(true);
             fail();
-        } catch (RuntimeException e) {}
+        } catch (RuntimeException e) {
+        }
 
         one.simpleMethod(100);
         two.simpleMethod("test Mockito");
@@ -74,6 +76,7 @@ public void shouldVerifyUsingMatchers() {
         try {
             verify(three).varargsObject(eq(10), eq("first arg"), startsWith("third"));
             fail();
-        } catch (WantedButNotInvoked e) {}
+        } catch (WantedButNotInvoked e) {
+        }
     }
 }
diff --git a/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
similarity index 87%
rename from src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
rename to mockito-core/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
index 56dd8a282d..7a67d7bb02 100644
--- a/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
@@ -45,10 +45,11 @@ public void shouldResetOngoingStubbingOnDoReturn() {
 
     private void assertOngoingStubbingIsReset() {
         try {
-            //In real, there might be a call to real object or a final method call
-            //I'm modelling it with null
+            // In real, there might be a call to real object or a final method call
+            // I'm modelling it with null
             when(null).thenReturn("anything");
             fail();
-        } catch (MissingMethodInvocationException e) {}
+        } catch (MissingMethodInvocationException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
new file mode 100644
index 0000000000..3cd9485b35
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.misuse;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class DescriptiveMessagesOnMisuseTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    class Foo {
+        public final String finalMethod() {
+            return null;
+        }
+    }
+
+    @SuppressWarnings("all")
+    @Test
+    public void tryDescriptiveMessagesOnMisuse() {
+        Foo foo = mock(Foo.class);
+
+        //        when(foo.finalMethod()).thenReturn("foo");
+        //        doReturn("foo").when(foo).finalMethod();
+        //        verify(foo).finalMethod();
+
+        //        doReturn("foo");
+        //        doReturn("bar");
+
+        //        verifyNoMoreInteractions();
+        //        verifyNoMoreInteractions(null);
+        //        verifyNoMoreInteractions("");
+        //
+        //        inOrder();
+        //        inOrder(null);
+        //        inOrder("test");
+        //        InOrder inOrder = inOrder(mock(List.class));
+        //        inOrder.verify(mock).simpleMethod();
+
+        //        verify(null);
+        //        verify(mock.booleanReturningMethod());
+
+        //        verify(mock).varargs("test", anyString());
+
+        //        when("x").thenReturn("x");
+
+        //        when(mock.simpleMethod());
+        //        when(mock.differentMethod()).thenReturn("");
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void shouldScreamWhenWholeMethodPassedToVerify() {
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock.booleanReturningMethod());
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContainingAll(
+                        "Argument passed to verify() is of type Boolean and is not a mock!",
+                        "Make sure you place the parenthesis correctly!",
+                        "See the examples of correct verifications:",
+                        "    verify(mock).someMethod();",
+                        "    verify(mock, times(10)).someMethod();",
+                        "    verify(mock, atLeastOnce()).someMethod();");
+    }
+
+    @Test
+    public void shouldScreamWhenWholeMethodPassedToVerifyNoMoreInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions(mock.byteReturningMethod());
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContainingAll(
+                        "Argument(s) passed is not a mock!",
+                        "Examples of correct verifications:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldScreamWhenInOrderCreatedWithDodgyMock() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder("not a mock");
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessageContainingAll(
+                        "Argument(s) passed is not a mock!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldScreamWhenInOrderCreatedWithNulls() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder(mock, null);
+                        })
+                .isInstanceOf(NullInsteadOfMockException.class)
+                .hasMessageContainingAll(
+                        "Argument(s) passed is null!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);");
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void shouldScreamNullPassedToVerify() {
+        assertThatThrownBy(
+                        () -> {
+                            verify(null);
+                        })
+                .isInstanceOf(NullInsteadOfMockException.class)
+                .hasMessageContainingAll(
+                        "Argument passed to verify() should be a mock but is null!",
+                        "Examples of correct verifications:",
+                        "    verify(mock).someMethod();",
+                        "    verify(mock, times(10)).someMethod();",
+                        "    verify(mock, atLeastOnce()).someMethod();",
+                        "    not: verify(mock.someMethod());",
+                        "Also, if you use @Mock annotation don't miss openMocks()");
+    }
+
+    @Test
+    public void shouldScreamWhenNotMockPassedToVerifyNoMoreInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions(null, "blah");
+                        })
+                .isInstanceOf(NullInsteadOfMockException.class)
+                .hasMessageContainingAll(
+                        "Argument(s) passed is null!",
+                        "Examples of correct verifications:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+
+    @SuppressWarnings("all")
+    @Test
+    public void shouldScreamWhenNullPassedToVerifyNoMoreInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions((Object[]) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Method requires argument(s)!",
+                        "Pass mocks that should be verified, e.g:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+}
diff --git a/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
similarity index 90%
rename from src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
rename to mockito-core/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
index 0b59c0b1ef..71b507ba2a 100644
--- a/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
@@ -31,7 +31,8 @@ public void shouldFailWithUnfinishedVerification() {
         try {
             verify(withFinal).foo();
             fail();
-        } catch (UnfinishedVerificationException e) {}
+        } catch (UnfinishedVerificationException e) {
+        }
     }
 
     @Test
@@ -41,6 +42,7 @@ public void shouldFailWithUnfinishedStubbing() {
         try {
             when(withFinal.foo()).thenReturn(null);
             fail();
-        } catch (MissingMethodInvocationException e) {}
+        } catch (MissingMethodInvocationException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
new file mode 100644
index 0000000000..a4b7294f2f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.misuse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.validateMockitoUsage;
+import static org.mockito.Mockito.verify;
+
+import java.util.Observer;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
+import org.mockito.exceptions.misusing.UnfinishedVerificationException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class DetectingMisusedMatchersTest extends TestBase {
+
+    class WithFinal {
+        final Object finalMethod(Object object) {
+            return null;
+        }
+    }
+
+    @Mock private WithFinal withFinal;
+
+    @After
+    public void resetState() {
+        super.resetState();
+    }
+
+    private void misplaced_any_argument_matcher() {
+        Object ignored = any();
+    }
+
+    private void misplaced_anyInt_argument_matcher() {
+        int ignored = anyInt();
+    }
+
+    private void misplaced_anyBoolean_argument_matcher() {
+        boolean ignored = anyBoolean();
+    }
+
+    @Test
+    public void should_fail_fast_when_argument_matchers_are_abused() {
+        misplaced_any_argument_matcher();
+        try {
+            mock(IMethods.class);
+            fail();
+        } catch (InvalidUseOfMatchersException e) {
+            assertThat(e).hasMessageContaining("Misplaced or misused argument matcher");
+        }
+    }
+
+    @Test
+    public void should_report_argument_locations_when_argument_matchers_misused() {
+        try {
+            Observer observer = mock(Observer.class);
+
+            misplaced_anyInt_argument_matcher();
+            misplaced_any_argument_matcher();
+            misplaced_anyBoolean_argument_matcher();
+
+            observer.update(null, null);
+
+            validateMockitoUsage();
+            fail();
+        } catch (InvalidUseOfMatchersException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "DetectingMisusedMatchersTest.misplaced_anyInt_argument_matcher")
+                    .hasMessageContaining(
+                            "DetectingMisusedMatchersTest.misplaced_any_argument_matcher")
+                    .hasMessageContaining(
+                            "DetectingMisusedMatchersTest.misplaced_anyBoolean_argument_matcher");
+        }
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void shouldSayUnfinishedVerificationButNotInvalidUseOfMatchers() {
+        assumeTrue("Does not apply for inline mocks", withFinal.getClass() != WithFinal.class);
+        verify(withFinal).finalMethod(any());
+        try {
+            verify(withFinal);
+            fail();
+        } catch (UnfinishedVerificationException e) {
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
similarity index 83%
rename from src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
rename to mockito-core/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
index 69be81614a..8e9e7599ef 100644
--- a/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
@@ -5,7 +5,7 @@
 package org.mockitousage.misuse;
 
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.anyObject;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -29,7 +29,8 @@ public void shouldValidateExplicitly() {
         try {
             Mockito.validateMockitoUsage();
             fail();
-        } catch (UnfinishedVerificationException e) {}
+        } catch (UnfinishedVerificationException e) {
+        }
     }
 
     @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
@@ -39,15 +40,17 @@ public void shouldDetectUnfinishedStubbing() {
         try {
             Mockito.validateMockitoUsage();
             fail();
-        } catch (UnfinishedStubbingException e) {}
+        } catch (UnfinishedStubbingException e) {
+        }
     }
 
     @Test
     public void shouldDetectMisplacedArgumentMatcher() {
-        anyObject();
+        Object ignored = any();
         try {
             Mockito.validateMockitoUsage();
             fail();
-        } catch (InvalidUseOfMatchersException e) {}
+        } catch (InvalidUseOfMatchersException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
new file mode 100644
index 0000000000..3da8c4cd1a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.misuse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import org.junit.After;
+import org.junit.Assume;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.MissingMethodInvocationException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.InlineMockMaker;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class InvalidUsageTest extends TestBase {
+
+    @Mock private IMethods mock;
+    @Mock private IMethods mockTwo;
+
+    @After
+    public void resetState() {
+        super.resetState();
+    }
+
+    @Test
+    public void shouldRequireArgumentsWhenVerifyingNoMoreInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Method requires argument(s)!",
+                        "Pass mocks that should be verified, e.g:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+
+    @Test
+    public void shouldRequireArgumentsWhenVerifyingNoInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoInteractions();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Method requires argument(s)!",
+                        "Pass mocks that should be verified, e.g:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldNotCreateInOrderObjectWithoutMocks() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Method requires argument(s)!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);");
+    }
+
+    @Test
+    public void shouldNotAllowVerifyingInOrderUnfamiliarMocks() {
+        InOrder inOrder = inOrder(mock);
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockTwo).simpleMethod();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "InOrder can only verify mocks that were passed in during creation of InOrder.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne);",
+                        "    inOrder.verify(mockOne).doStuff();");
+    }
+
+    @Test
+    public void shouldReportMissingMethodInvocationWhenStubbing() {
+        when(mock.simpleMethod())
+                .thenReturn("this stubbing is required to make sure Stubbable is pulled");
+        assertThatThrownBy(
+                        () -> {
+                            when("".toString()).thenReturn("x");
+                        })
+                .isInstanceOf(MissingMethodInvocationException.class)
+                .hasMessageContainingAll(
+                        "when() requires an argument which has to be 'a method call on a mock'.",
+                        "For example:",
+                        "    when(mock.getArticles()).thenReturn(articles);",
+                        "Also, this error might show up because:",
+                        "1. you stub either of: final/private/native/equals()/hashCode() methods.",
+                        "   Those methods *cannot* be stubbed/verified.",
+                        "   Mocking methods declared on non-public parent classes is not supported.",
+                        "2. inside when() you don't call method on mock but on some other object.");
+    }
+
+    @Test
+    public void shouldNotAllowSettingInvalidCheckedException() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.simpleMethod()).thenThrow(new Exception());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Checked exception is invalid for this method!",
+                        "Invalid: java.lang.Exception");
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullThrowable() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.simpleMethod()).thenThrow(new Throwable[] {null});
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Cannot stub with null throwable!");
+    }
+
+    @SuppressWarnings("all")
+    @Test
+    public void shouldNotAllowSettingNullThrowableVararg() throws Exception {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.simpleMethod()).thenThrow((Throwable) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Cannot stub with null throwable!");
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullConsecutiveThrowable() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.simpleMethod()).thenThrow(new RuntimeException(), null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Cannot stub with null throwable!");
+    }
+
+    final class FinalClass {}
+
+    @Test
+    public void shouldNotAllowMockingFinalClassesIfDisabled() {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
+        assertThatThrownBy(
+                        () -> {
+                            mock(FinalClass.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Cannot mock/spy class org.mockitousage.misuse.InvalidUsageTest$FinalClass",
+                        "Mockito cannot mock/spy because :",
+                        " - final class");
+    }
+
+    @Test
+    public void shouldAllowMockingFinalClassesIfEnabled() {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineMockMaker.class));
+        assertThat(mock(FinalClass.class)).isInstanceOf(FinalClass.class);
+    }
+
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldNotAllowMockingPrimitives() {
+        assertThatThrownBy(
+                        () -> {
+                            mock(Integer.TYPE);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Cannot mock/spy int",
+                        "Mockito cannot mock/spy because :",
+                        " - primitive type");
+    }
+
+    interface ObjectLikeInterface {
+        boolean equals(Object o);
+
+        String toString();
+
+        int hashCode();
+    }
+
+    @Test
+    public void shouldNotMockObjectMethodsOnInterfaceVerifyNoInteractions() {
+        ObjectLikeInterface inter = mock(ObjectLikeInterface.class);
+
+        Object ignored = inter.equals(null);
+        ignored = inter.toString();
+        ignored = inter.hashCode();
+
+        verifyNoInteractions(inter);
+    }
+
+    @Test
+    public void shouldNotMockObjectMethodsOnClassVerifyNoInteractions() {
+        Object clazz = mock(ObjectLikeInterface.class);
+
+        Object ignored = clazz.equals(null);
+        ignored = clazz.toString();
+        ignored = clazz.hashCode();
+
+        verifyNoInteractions(clazz);
+    }
+}
diff --git a/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java b/mockito-core/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
similarity index 79%
rename from src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
rename to mockito-core/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
index 39d054810a..01323400be 100644
--- a/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
@@ -39,24 +39,24 @@ public void shouldScreamWhenVerifyToString() {
 
     @Test
     public void shouldBeSilentWhenVerifyHashCode() {
-        //because it leads to really weird behavior sometimes
-        //it's because cglib & my code can occasionelly call those methods
+        // because it leads to really weird behavior sometimes
+        // it's because cglib & my code can occasionelly call those methods
         // and when user has verification started at that time there will be a mess
         verify(mock).hashCode();
     }
 
     @Test
     public void shouldBeSilentWhenVerifyEquals() {
-        //because it leads to really weird behavior sometimes
-        //it's because cglib & my code can occasionelly call those methods
+        // because it leads to really weird behavior sometimes
+        // it's because cglib & my code can occasionelly call those methods
         // and when user has verification started at that time there will be a mess
         verify(mock).equals(null);
     }
 
     @Test
     public void shouldBeSilentWhenVerifyEqualsInOrder() {
-        //because it leads to really weird behavior sometimes
-        //it's because cglib & my code can occasionelly call those methods
+        // because it leads to really weird behavior sometimes
+        // it's because cglib & my code can occasionelly call those methods
         // and when user has verification started at that time there will be a mess
         InOrder inOrder = inOrder(mock);
         inOrder.verify(mock).equals(null);
diff --git a/src/test/java/org/mockitousage/package-info.java b/mockito-core/src/test/java/org/mockitousage/package-info.java
similarity index 100%
rename from src/test/java/org/mockitousage/package-info.java
rename to mockito-core/src/test/java/org/mockitousage/package-info.java
diff --git a/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java b/mockito-core/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
rename to mockito-core/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
diff --git a/src/test/java/org/mockitousage/packageprotected/PackageProtected.java b/mockito-core/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
similarity index 85%
rename from src/test/java/org/mockitousage/packageprotected/PackageProtected.java
rename to mockito-core/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
index 0c1ed91ba4..627b0de463 100644
--- a/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
+++ b/mockito-core/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
@@ -4,6 +4,4 @@
  */
 package org.mockitousage.packageprotected;
 
-class PackageProtected {
-
-}
+class PackageProtected {}
diff --git a/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java b/mockito-core/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java
rename to mockito-core/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java
diff --git a/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java b/mockito-core/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
similarity index 91%
rename from src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
rename to mockito-core/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
index a2529c5210..60a08f2b9b 100644
--- a/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
@@ -17,7 +17,7 @@ public void using_stub_only_wont_thrown_an_OutOfMemoryError() {
         when(obj.toString()).thenReturn("asdf");
 
         for (int i = 0; i < 1000000; i++) {
-            obj.toString();
+            String ignored = obj.toString();
         }
     }
 
@@ -28,7 +28,7 @@ public void without_stub_only_mocks_will_store_invocations_leading_to_an_OutOfMe
         when(obj.toString()).thenReturn("asdf");
 
         for (int i = 0; i < 1000000; i++) {
-            obj.toString();
+            String ignored = obj.toString();
         }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java b/mockito-core/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
new file mode 100644
index 0000000000..dd5f390a53
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins;
+
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.plugins.AnnotationEngine;
+import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.plugins.MockitoPlugins;
+import org.mockito.plugins.PluginSwitch;
+import org.mockito.plugins.StackTraceCleanerProvider;
+import org.mockitoutil.TestBase;
+
+public class MockitoPluginsTest extends TestBase {
+
+    private final MockitoPlugins plugins = Mockito.framework().getPlugins();
+
+    @Test
+    public void provides_built_in_plugins() {
+        assertNotNull(plugins.getInlineMockMaker());
+        assertNotNull(plugins.getDefaultPlugin(MockMaker.class));
+        assertNotNull(plugins.getDefaultPlugin(StackTraceCleanerProvider.class));
+        assertNotNull(plugins.getDefaultPlugin(PluginSwitch.class));
+        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
+        assertNotNull(plugins.getDefaultPlugin(AnnotationEngine.class));
+        assertNotNull(plugins.getDefaultPlugin(MockitoLogger.class));
+    }
+}
diff --git a/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java b/mockito-core/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
similarity index 84%
rename from src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
rename to mockito-core/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
index 4f79419150..849a16a79c 100644
--- a/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
@@ -31,7 +31,7 @@ public String say(T t) {
 
     private class Sub extends Super<String> {
         @Override
-        public String say(String t)  {
+        public String say(String t) {
             return "Dummy says: " + t;
         }
     }
@@ -48,8 +48,8 @@ public void shouldHaveBridgeMethod() throws Exception {
 
     @Test
     public void shouldVerifyCorrectlyWhenBridgeMethodCalled() throws Exception {
-        //Super has following erasure: say(Object) which differs from Dummy.say(String)
-        //mock has to detect it and do the super.say()
+        // Super has following erasure: say(Object) which differs from Dummy.say(String)
+        // mock has to detect it and do the super.say()
         Sub s = mock(Sub.class);
         Super<String> s_down = s;
         s_down.say("Hello");
@@ -59,8 +59,8 @@ public void shouldVerifyCorrectlyWhenBridgeMethodCalled() throws Exception {
 
     @Test
     public void shouldVerifyCorrectlyWhenBridgeMethodVerified() throws Exception {
-        //Super has following erasure: say(Object) which differs from Dummy.say(String)
-        //mock has to detect it and do the super.say()
+        // Super has following erasure: say(Object) which differs from Dummy.say(String)
+        // mock has to detect it and do the super.say()
         Sub s = mock(Sub.class);
         Super<String> s_down = s;
         s.say("Hello");
diff --git a/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java b/mockito-core/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
similarity index 95%
rename from src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
rename to mockito-core/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
index 6018056062..981dee5156 100644
--- a/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
@@ -40,6 +40,7 @@ public void shouldUseArgumentTypeWhenOverloadingPuzzleDetected() throws Exceptio
         try {
             verify(sub).say("Hello");
             fail();
-        } catch (WantedButNotInvoked e) {}
+        } catch (WantedButNotInvoked e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java b/mockito-core/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
new file mode 100644
index 0000000000..d7863c82c1
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.serialization;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.ByteArrayInputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import net.bytebuddy.ClassFileVersion;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.creation.bytebuddy.codegen.InjectionBase;
+import org.mockito.mock.SerializableMode;
+import org.mockitousage.IMethods;
+import org.mockitoutil.SimplePerRealmReloadingClassLoader;
+import org.mockitoutil.SimpleSerializationUtil;
+
+public class AcrossClassLoaderSerializationTest {
+
+    public IMethods mock;
+
+    @Before
+    public void reproduce_CCE_by_creating_a_mock_with_IMethods_before() throws Exception {
+        mock = Mockito.mock(IMethods.class);
+    }
+
+    @Test
+    public void check_that_mock_can_be_serialized_in_a_classloader_and_deserialized_in_another()
+            throws Exception {
+        // No longer supported starting with JDK 16+
+        if (!ClassFileVersion.ofThisVm().isAtMost(ClassFileVersion.JAVA_V16)) {
+            return;
+        }
+        byte[] bytes = create_mock_and_serialize_it_in_class_loader_A();
+
+        Object the_deserialized_mock = read_stream_and_deserialize_it_in_class_loader_B(bytes);
+        assertThat(the_deserialized_mock.getClass().getName())
+                .startsWith(
+                        InjectionBase.class.getPackageName()
+                                + ".AClassToBeMockedInThisTestOnlyAndInCallablesOnly");
+    }
+
+    private Object read_stream_and_deserialize_it_in_class_loader_B(byte[] bytes) throws Exception {
+        return new SimplePerRealmReloadingClassLoader(
+                        this.getClass().getClassLoader(), isolating_test_classes())
+                .doInRealm(
+                        "org.mockitousage.serialization.AcrossClassLoaderSerializationTest$ReadStreamAndDeserializeIt",
+                        new Class<?>[] {byte[].class},
+                        new Object[] {bytes});
+    }
+
+    private byte[] create_mock_and_serialize_it_in_class_loader_A() throws Exception {
+        return (byte[])
+                new SimplePerRealmReloadingClassLoader(
+                                this.getClass().getClassLoader(), isolating_test_classes())
+                        .doInRealm(
+                                "org.mockitousage.serialization.AcrossClassLoaderSerializationTest$CreateMockAndSerializeIt");
+    }
+
+    private SimplePerRealmReloadingClassLoader.ReloadClassPredicate isolating_test_classes() {
+        return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
+            public boolean acceptReloadOf(String qualifiedName) {
+                return qualifiedName.contains("org.mockitousage")
+                        || qualifiedName.contains("org.mockitoutil");
+            }
+        };
+    }
+
+    // see create_mock_and_serialize_it_in_class_loader_A
+    public static class CreateMockAndSerializeIt implements Callable<byte[]> {
+        public byte[] call() throws Exception {
+            AClassToBeMockedInThisTestOnlyAndInCallablesOnly mock =
+                    Mockito.mock(
+                            AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class,
+                            Mockito.withSettings()
+                                    .serializable(SerializableMode.ACROSS_CLASSLOADERS));
+            // use MethodProxy before
+            mock.returningSomething();
+
+            return SimpleSerializationUtil.serializeMock(mock).toByteArray();
+        }
+    }
+
+    // see read_stream_and_deserialize_it_in_class_loader_B
+    public static class ReadStreamAndDeserializeIt implements Callable<Object> {
+        private byte[] bytes;
+
+        public ReadStreamAndDeserializeIt(byte[] bytes) {
+            this.bytes = bytes;
+        }
+
+        public Object call() throws Exception {
+            ByteArrayInputStream to_unserialize = new ByteArrayInputStream(bytes);
+            return SimpleSerializationUtil.deserializeMock(
+                    to_unserialize, AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class);
+        }
+    }
+
+    public static class AClassToBeMockedInThisTestOnlyAndInCallablesOnly {
+        List returningSomething() {
+            return Collections.emptyList();
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java b/mockito-core/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
new file mode 100644
index 0000000000..856e89b8d4
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.serialization;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Test;
+
+public class DeepStubsSerializableTest {
+
+    @Test
+    public void should_serialize_and_deserialize_mock_created_with_deep_stubs() throws Exception {
+        // given
+        SampleClass sampleClass =
+                mock(
+                        SampleClass.class,
+                        withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
+        when(sampleClass.getSample().isFalse()).thenReturn(true);
+        when(sampleClass.getSample().number()).thenReturn(999);
+
+        // when
+        SampleClass deserializedSample = serializeAndBack(sampleClass);
+
+        // then
+        assertThat(deserializedSample.getSample().isFalse()).isEqualTo(true);
+        assertThat(deserializedSample.getSample().number()).isEqualTo(999);
+    }
+
+    @Test
+    public void should_serialize_and_deserialize_parameterized_class_mocked_with_deep_stubs()
+            throws Exception {
+        // given
+        ListContainer deep_stubbed =
+                mock(
+                        ListContainer.class,
+                        withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
+        when(deep_stubbed.iterator().next().add("yes")).thenReturn(true);
+
+        // when
+        ListContainer deserialized_deep_stub = serializeAndBack(deep_stubbed);
+
+        // then
+        assertThat(
+                        deserialized_deep_stub
+                                .iterator()
+                                .next()
+                                .add("not stubbed but mock already previously resolved"))
+                .isEqualTo(false);
+        assertThat(deserialized_deep_stub.iterator().next().add("yes")).isEqualTo(true);
+    }
+
+    @Test
+    public void
+            should_discard_generics_metadata_when_serialized_then_disabling_deep_stubs_with_generics()
+                    throws Exception {
+        // given
+        ListContainer deep_stubbed =
+                mock(
+                        ListContainer.class,
+                        withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
+        when(deep_stubbed.iterator().hasNext()).thenReturn(true);
+
+        ListContainer deserialized_deep_stub = serializeAndBack(deep_stubbed);
+
+        assertThat(deserialized_deep_stub.iterator().next()).isNull();
+    }
+
+    static class SampleClass implements Serializable {
+
+        SampleClass2 getSample() {
+            return new SampleClass2();
+        }
+    }
+
+    static class SampleClass2 implements Serializable {
+
+        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 Iterator<E> iterator() {
+            return new Iterator<E>() {
+                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);
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java b/mockito-core/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
new file mode 100644
index 0000000000..e2caf7c275
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.serialization;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
+
+import java.nio.charset.CharacterCodingException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.*;
+
+import org.junit.Test;
+import org.mockitousage.IMethods;
+import org.mockitoutil.SimpleSerializationUtil;
+
+public class ParallelSerializationTest {
+
+    @Test
+    public void single_mock_being_serialized_in_different_classloaders_by_multiple_threads()
+            throws ExecutionException, InterruptedException {
+        // given
+        int iterations = 2;
+        int threadingFactor = 200;
+        final ExecutorService executorService = Executors.newFixedThreadPool(threadingFactor);
+        final IMethods iMethods_that_store_invocations =
+                mock(IMethods.class, withSettings().serializable());
+
+        // when
+        for (int i = 0; i <= iterations; i++) {
+            List<Future<?>> futures = new ArrayList<Future<?>>(threadingFactor);
+            final CyclicBarrier barrier_that_will_wait_until_threads_are_ready =
+                    new CyclicBarrier(threadingFactor);
+
+            // prepare all threads by submitting a callable
+            //  - that will serialize the mock a 'threadingFactor' times
+            //  - that will use the mock a 'threadingFactor' times
+            for (int j = 0; j < threadingFactor; j++) {
+                // submit a callable that will serialize the mock 'iMethods'
+                futures.add(
+                        executorService.submit(
+                                new Callable<Object>() {
+                                    public Object call() throws Exception {
+                                        barrier_that_will_wait_until_threads_are_ready.await();
+
+                                        randomCallOn(iMethods_that_store_invocations);
+
+                                        return SimpleSerializationUtil.serializeMock(
+                                                        iMethods_that_store_invocations)
+                                                .toByteArray();
+                                    }
+                                }));
+
+                // submit a callable that will only use the mock 'iMethods'
+                executorService.submit(
+                        new Callable<Object>() {
+                            public Object call() throws Exception {
+                                barrier_that_will_wait_until_threads_are_ready.await();
+                                return iMethods_that_store_invocations.longObjectReturningMethod();
+                            }
+                        });
+            }
+
+            // ensure we are getting the futures
+            for (Future<?> future : futures) {
+                future.get();
+            }
+        }
+    }
+
+    private void randomCallOn(IMethods iMethods) throws CharacterCodingException {
+        int random = new Random().nextInt(10);
+        switch (random) {
+            case 0:
+                iMethods.arrayReturningMethod();
+                break;
+            case 1:
+                iMethods.longObjectReturningMethod();
+                break;
+            case 2:
+                iMethods.linkedListReturningMethod();
+                break;
+            case 3:
+                iMethods.iMethodsReturningMethod();
+                break;
+            case 4:
+                iMethods.canThrowException();
+                break;
+            case 5:
+                iMethods.differentMethod();
+                break;
+            case 6:
+                iMethods.voidMethod();
+                break;
+            case 7:
+                iMethods.varargsString(1, "");
+                break;
+            case 8:
+                iMethods.forMap(null);
+                break;
+            case 9:
+                iMethods.throwsNothing(false);
+                break;
+            default:
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java b/mockito-core/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
similarity index 90%
rename from src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
rename to mockito-core/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
index fd24c61322..456cde2102 100644
--- a/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
@@ -18,10 +18,12 @@
 @RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class StrictStubsSerializableTest {
 
-    @Mock(serializable = true) private SampleClass sampleClass;
+    @Mock(serializable = true)
+    private SampleClass sampleClass;
 
     @Test
-    public void should_serialize_and_deserialize_mock_created_with_serializable_and_strict_stubs() throws Exception {
+    public void should_serialize_and_deserialize_mock_created_with_serializable_and_strict_stubs()
+            throws Exception {
         // given
         when(sampleClass.isFalse()).thenReturn(true);
 
diff --git a/mockito-core/src/test/java/org/mockitousage/session/MockitoSessionTest.java b/mockito-core/src/test/java/org/mockitousage/session/MockitoSessionTest.java
new file mode 100644
index 0000000000..958e569e32
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/session/MockitoSessionTest.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.session;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoSession;
+import org.mockito.exceptions.misusing.InjectMocksException;
+import org.mockito.exceptions.misusing.UnfinishedStubbingException;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+import org.mockitoutil.TestBase;
+
+public class MockitoSessionTest extends TestBase {
+
+    private JUnitCore junit = new JUnitCore();
+
+    @Test
+    public void session_without_any_configuration() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithoutAnyConfiguration.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test
+    public void session_without_init_mocks_configured() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithoutInitMocksConfigured.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test
+    public void session_without_strictness_configured() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithoutStrictnessConfigured.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test
+    public void session_with_incorrect_mockito_usage() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithIncorrectMockitoUsage.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).fails(1, UnfinishedStubbingException.class);
+    }
+
+    @Test
+    public void reports_other_failure_and_incorrect_mockito_usage() {
+        // when
+        Result result =
+                junit.run(MockitoSessionTest.SessionWithTestFailureAndIncorrectMockitoUsage.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result)
+                .failsExactly(AssertionError.class, UnfinishedStubbingException.class);
+    }
+
+    @Test
+    public void allows_initializing_mocks_manually() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithManuallyInitializedMock.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test
+    public void allows_updating_strictness() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithUpdatedStrictness.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).succeeds(1);
+    }
+
+    @Test
+    public void allows_overriding_failure() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithOverriddenFailure.class);
+
+        // expect
+        JUnitResultAssert.assertThat(result).isSuccessful();
+
+        // in order to demonstrate feature, we intentionally misuse Mockito and need to clean up
+        // state
+        resetState();
+    }
+
+    @Test
+    public void cleans_up_state_when_init_fails() {
+        // when
+        Result result = junit.run(MockitoSessionTest.SessionWithInitMocksFailure.class);
+
+        // expect that both failures are the same, indicating correct listener cleanup
+        // incorrect cleanup causes 1 failure to be InjectMocksException
+        //  but the next test method would have failed with unuseful error that session was not
+        // cleaned up
+        JUnitResultAssert.assertThat(result).fails(2, InjectMocksException.class);
+    }
+
+    public static class SessionWithoutAnyConfiguration {
+
+        @Mock IMethods mock;
+
+        // session without initMocks is not currently supported
+        MockitoSession mockito = Mockito.mockitoSession().startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void some_test() {
+            assertNull(mock); // initMocks() was not used when configuring session
+        }
+    }
+
+    public static class SessionWithoutInitMocksConfigured {
+
+        @Mock IMethods mock;
+
+        MockitoSession mockito =
+                Mockito.mockitoSession().strictness(Strictness.LENIENT).startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void some_test() {
+            assertNull(mock); // initMocks() was not used when configuring session
+        }
+    }
+
+    public static class SessionWithoutStrictnessConfigured {
+        @Mock IMethods mock;
+
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void some_test() {
+            assertNotNull(mock);
+        }
+    }
+
+    public static class SessionWithIncorrectMockitoUsage {
+        @Mock IMethods mock;
+
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+        @Test
+        public void unfinished_stubbing() {
+            when(mock.simpleMethod());
+        }
+    }
+
+    public static class SessionWithTestFailureAndIncorrectMockitoUsage {
+        @Mock IMethods mock;
+
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+        @Test
+        public void unfinished_stubbing_with_other_failure() {
+            when(mock.simpleMethod());
+            assertTrue(false);
+        }
+    }
+
+    public static class SessionWithManuallyInitializedMock {
+        @Mock IMethods mock;
+        IMethods mock2 = Mockito.mock(IMethods.class, "manual mock");
+
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void manual_mock_preserves_its_settings() {
+            assertEquals(
+                    "mock",
+                    mockingDetails(mock).getMockCreationSettings().getMockName().toString());
+            assertEquals(
+                    "manual mock",
+                    mockingDetails(mock2).getMockCreationSettings().getMockName().toString());
+        }
+    }
+
+    public static class SessionWithUpdatedStrictness {
+        @Mock IMethods mock;
+        MockitoSession mockito =
+                Mockito.mockitoSession()
+                        .initMocks(this)
+                        .strictness(Strictness.STRICT_STUBS)
+                        .startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void manual_mock_preserves_its_settings() {
+            when(mock.simpleMethod(1)).thenReturn("foo");
+
+            // when
+            mockito.setStrictness(Strictness.LENIENT);
+
+            // then no exception is thrown, even though the arg is different
+            mock.simpleMethod(2);
+        }
+    }
+
+    public static class SessionWithOverriddenFailure {
+        @Mock IMethods mock;
+        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking(new RuntimeException("Boo!"));
+        }
+
+        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+        @Test
+        public void invalid_mockito_usage() {
+            verify(mock);
+        }
+    }
+
+    public static class SessionWithInitMocksFailure {
+        @InjectMocks private ConstructorFail sut;
+        MockitoSession mockito;
+
+        @Before
+        public void before() {
+            mockito = Mockito.mockitoSession().initMocks(this).startMocking();
+        }
+
+        @After
+        public void after() {
+            if (mockito != null) {
+                // so that we reduce amount of exceptions for easier assertions
+                // otherwise we would get an NPE here
+                mockito.finishMocking();
+            }
+        }
+
+        @Test
+        public void test1() {
+            // should fail the same way
+        }
+
+        @Test
+        public void test2() {
+            // should fail the same way
+        }
+
+        static class ConstructorFail {
+            ConstructorFail() {
+                throw new RuntimeException("Boo!");
+            }
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java b/mockito-core/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
new file mode 100644
index 0000000000..ccd85c2b29
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.spies;
+
+import static net.bytebuddy.ClassFileVersion.JAVA_V21;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.Conditions.methodsInStackTrace;
+
+import net.bytebuddy.ClassFileVersion;
+import org.assertj.core.api.Assertions;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.internal.util.reflection.ReflectionMemberAccessor;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class PartialMockingWithSpiesTest extends TestBase {
+
+    @Before
+    public void pleaseMakeStackTracesClean() {
+        makeStackTracesClean();
+    }
+
+    class InheritMe {
+        private String inherited = "100$";
+
+        protected String getInherited() {
+            return inherited;
+        }
+    }
+
+    class Person extends InheritMe {
+        private final Name defaultName = new Name("Default name");
+
+        public String getName() {
+            return guessName().name;
+        }
+
+        Name guessName() {
+            return defaultName;
+        }
+
+        public String howMuchDidYouInherit() {
+            return getInherited();
+        }
+
+        public String getNameButDelegateToMethodThatThrows() {
+            throwSomeException();
+            return guessName().name;
+        }
+
+        private void throwSomeException() {
+            throw new RuntimeException("boo");
+        }
+    }
+
+    class Name {
+        private final String name;
+
+        public Name(String name) {
+            this.name = name;
+        }
+    }
+
+    Person spy = spy(new Person());
+
+    @Test
+    public void shouldCallRealMethdsEvenDelegatedToOtherSelfMethod() {
+        // when
+        String name = spy.getName();
+
+        // then
+        assertEquals("Default name", name);
+    }
+
+    @Test
+    public void shouldAllowStubbingOfMethodsThatDelegateToOtherMethods() {
+        // when
+        when(spy.getName()).thenReturn("foo");
+
+        // then
+        assertEquals("foo", spy.getName());
+    }
+
+    @Test
+    public void shouldAllowStubbingWithThrowablesMethodsThatDelegateToOtherMethods() {
+        // when
+        doThrow(new RuntimeException("appetite for destruction"))
+                .when(spy)
+                .getNameButDelegateToMethodThatThrows();
+
+        // then
+        try {
+            spy.getNameButDelegateToMethodThatThrows();
+            fail();
+        } catch (Exception e) {
+            assertEquals("appetite for destruction", e.getMessage());
+        }
+    }
+
+    @Test
+    public void shouldStackTraceGetFilteredOnUserExceptions() {
+        Assume.assumeThat(
+                Plugins.getMemberAccessor(), not(instanceOf(ReflectionMemberAccessor.class)));
+
+        try {
+            // when
+            spy.getNameButDelegateToMethodThatThrows();
+            fail();
+        } catch (Throwable t) {
+            // then
+            Assertions.assertThat(t)
+                    .has(
+                            methodsInStackTrace(
+                                    "throwSomeException",
+                                    "getNameButDelegateToMethodThatThrows",
+                                    "shouldStackTraceGetFilteredOnUserExceptions"));
+        }
+    }
+
+    @Test
+    public void shouldStackTraceGetFilteredOnUserExceptionsReflectionForJavaOfVersionLessThan21() {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineByteBuddyMockMaker.class));
+        Assume.assumeThat(Plugins.getMemberAccessor(), instanceOf(ReflectionMemberAccessor.class));
+        Assume.assumeTrue(ClassFileVersion.ofThisVm().isLessThan(JAVA_V21));
+
+        try {
+            // when
+            spy.getNameButDelegateToMethodThatThrows();
+            fail();
+        } catch (Throwable t) {
+            // then
+            Assertions.assertThat(t)
+                    .has(
+                            methodsInStackTrace(
+                                    "throwSomeException",
+                                    "invoke0",
+                                    "invoke",
+                                    "invoke",
+                                    "invoke",
+                                    "getNameButDelegateToMethodThatThrows",
+                                    "shouldStackTraceGetFilteredOnUserExceptionsReflectionForJavaOfVersionLessThan21"));
+        }
+    }
+
+    @Test
+    public void shouldStackTraceGetFilteredOnUserExceptionsReflectionForJava21AndHigher() {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineByteBuddyMockMaker.class));
+        Assume.assumeThat(Plugins.getMemberAccessor(), instanceOf(ReflectionMemberAccessor.class));
+        Assume.assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(JAVA_V21));
+
+        try {
+            // when
+            spy.getNameButDelegateToMethodThatThrows();
+            fail();
+        } catch (Throwable t) {
+            // then
+            Assertions.assertThat(t)
+                    .has(
+                            methodsInStackTrace(
+                                    "throwSomeException",
+                                    "invoke",
+                                    "invoke",
+                                    "getNameButDelegateToMethodThatThrows",
+                                    "shouldStackTraceGetFilteredOnUserExceptionsReflectionForJava21AndHigher"));
+        }
+    }
+
+    //    @Test //manual verification
+    public void verifyTheStackTrace() {
+        spy.getNameButDelegateToMethodThatThrows();
+    }
+
+    @Test
+    public void shouldVerify() {
+        // when
+        spy.getName();
+
+        // then
+        verify(spy).guessName();
+    }
+
+    @Test
+    public void shouldStub() {
+        // given
+        when(spy.guessName()).thenReturn(new Name("John"));
+        // when
+        String name = spy.getName();
+        // then
+        assertEquals("John", name);
+    }
+
+    @Test
+    public void shouldDealWithPrivateFieldsOfSubclasses() {
+        assertEquals("100$", spy.howMuchDidYouInherit());
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/spies/SpiesWithRealEqualsAndInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/spies/SpiesWithRealEqualsAndInOrderTest.java
new file mode 100644
index 0000000000..e2dabe9515
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/spies/SpiesWithRealEqualsAndInOrderTest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.spies;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.inOrder;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+// https://github.com/mockito/mockito/issues/2394
+public class SpiesWithRealEqualsAndInOrderTest {
+
+    @Test
+    public void should_be_able_to_handle_in_order_on_spies_with_equals() {
+        ToBeSpied mock1 = spy(new ToBeSpied());
+        ToBeSpied mock2 = spy(new ToBeSpied());
+        mock1.someMethod();
+        InOrder order = inOrder(mock1, mock2);
+        order.verify(mock1).someMethod();
+        order.verifyNoMoreInteractions();
+    }
+
+    static class ToBeSpied {
+        void someMethod() {}
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/spies/SpyAsDefaultMockUsageTest.java b/mockito-core/src/test/java/org/mockitousage/spies/SpyAsDefaultMockUsageTest.java
new file mode 100644
index 0000000000..463b9370d7
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/spies/SpyAsDefaultMockUsageTest.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.spies;
+
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+public class SpyAsDefaultMockUsageTest {
+
+    @Test
+    public void nestedWhenTest() {
+        Strategy mfoo = mock(Strategy.class);
+        Sampler mpoo = mock(Sampler.class);
+        Producer out = spy(new Producer(mfoo));
+
+        when(out.produce()).thenReturn(mpoo);
+        assertSame(mpoo, out.produce());
+    }
+
+    public class Sample {}
+
+    public class Strategy {
+        Sample getSample() {
+            return new Sample();
+        }
+    }
+
+    public class Sampler {
+        Sample sample;
+
+        Sampler(Strategy f) {
+            sample = f.getSample();
+        }
+    }
+
+    public class Producer {
+        Strategy strategy;
+
+        Producer(Strategy f) {
+            strategy = f;
+        }
+
+        Sampler produce() {
+            return new Sampler(strategy);
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java b/mockito-core/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
new file mode 100644
index 0000000000..409f43cede
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.spies;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.FixedValue;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings({"unchecked"})
+public class SpyingOnInterfacesTest extends TestBase {
+
+    @Test
+    public void shouldFailFastWhenCallingRealMethodOnInterface() throws Exception {
+        List<?> list = mock(List.class);
+        try {
+            // when
+            when(list.get(0)).thenCallRealMethod();
+            // then
+            fail();
+        } catch (MockitoException e) {
+        }
+    }
+
+    @Test
+    public void shouldFailInRuntimeWhenCallingRealMethodOnInterface() throws Exception {
+        // given
+        List<Object> list = mock(List.class);
+        when(list.get(0))
+                .thenAnswer(
+                        new Answer<Object>() {
+                            public Object answer(InvocationOnMock invocation) throws Throwable {
+                                return invocation.callRealMethod();
+                            }
+                        });
+        try {
+            // when
+            list.get(0);
+            // then
+            fail();
+        } catch (MockitoException e) {
+        }
+    }
+
+    @Test
+    public void shouldAllowDelegatingToDefaultMethod() throws Exception {
+        Class<?> type =
+                new ByteBuddy()
+                        .makeInterface()
+                        .defineMethod("foo", String.class, Visibility.PUBLIC)
+                        .intercept(FixedValue.value("bar"))
+                        .make()
+                        .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+                        .getLoaded();
+
+        Object object = mock(type);
+
+        // when
+        when(type.getMethod("foo").invoke(object)).thenCallRealMethod();
+        // then
+        Assertions.assertThat(type.getMethod("foo").invoke(object)).isEqualTo((Object) "bar");
+        type.getMethod("foo").invoke(verify(object));
+    }
+
+    @Test
+    public void shouldAllowSpyingOnDefaultMethod() throws Exception {
+        Class<?> iFace =
+                new ByteBuddy()
+                        .makeInterface()
+                        .defineMethod("foo", String.class, Visibility.PUBLIC)
+                        .intercept(FixedValue.value("bar"))
+                        .make()
+                        .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+                        .getLoaded();
+
+        Class<?> impl =
+                new ByteBuddy()
+                        .subclass(iFace)
+                        .make()
+                        .load(iFace.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+                        .getLoaded();
+
+        Object object = spy(impl.getConstructor().newInstance());
+
+        // when
+        Assertions.assertThat(impl.getMethod("foo").invoke(object)).isEqualTo((Object) "bar");
+        // then
+        impl.getMethod("foo").invoke(verify(object));
+    }
+}
diff --git a/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java b/mockito-core/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
similarity index 77%
rename from src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
rename to mockito-core/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
index 495686144d..30d3784582 100644
--- a/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
@@ -48,9 +48,7 @@ public void shouldBeAbleToMockObjectBecauseWhyNot() {
     @Test
     public void shouldStub() {
         spy.add("one");
-        when(spy.get(0))
-            .thenReturn("1")
-            .thenReturn("1 again");
+        when(spy.get(0)).thenReturn("1").thenReturn("1 again");
 
         assertEquals("1", spy.get(0));
         assertEquals("1 again", spy.get(0));
@@ -61,7 +59,7 @@ public void shouldStub() {
 
     @Test
     public void shouldAllowOverridingStubs() {
-        when(spy.contains(anyObject())).thenReturn(true);
+        when(spy.contains(any())).thenReturn(true);
         when(spy.contains("foo")).thenReturn(false);
 
         assertTrue(spy.contains("bar"));
@@ -70,26 +68,22 @@ public void shouldAllowOverridingStubs() {
 
     @Test
     public void shouldStubVoid() {
-        doNothing()
-        .doThrow(new RuntimeException())
-        .when(spy)
-        .clear();
+        doNothing().doThrow(new RuntimeException()).when(spy).clear();
 
         spy.add("one");
         spy.clear();
         try {
             spy.clear();
             fail();
-        } catch (RuntimeException e) {}
+        } catch (RuntimeException e) {
+        }
 
         assertEquals(1, spy.size());
     }
 
     @Test
     public void shouldStubWithDoReturnAndVerify() {
-        doReturn("foo")
-        .doReturn("bar")
-        .when(spy).get(0);
+        doReturn("foo").doReturn("bar").when(spy).get(0);
 
         assertEquals("foo", spy.get(0));
         assertEquals("bar", spy.get(0));
@@ -120,7 +114,8 @@ public void shouldVerifyInOrderAndFail() {
         try {
             inOrder.verify(spy).add("one");
             fail();
-        } catch (VerificationInOrderFailure f) {}
+        } catch (VerificationInOrderFailure f) {
+        }
     }
 
     @Test
@@ -140,7 +135,8 @@ public void shouldVerifyNumberOfTimesAndFail() {
         try {
             verify(spy, times(3)).add("one");
             fail();
-        } catch (TooFewActualInvocations e) {}
+        } catch (TooFewActualInvocations e) {
+        }
     }
 
     @Test
@@ -152,13 +148,14 @@ public void shouldVerifyNoMoreInteractionsAndFail() {
         try {
             verifyNoMoreInteractions(spy);
             fail();
-        } catch (NoInteractionsWanted e) {}
+        } catch (NoInteractionsWanted e) {
+        }
     }
 
     @Test
     public void shouldToString() {
         spy.add("foo");
-        assertEquals("[foo]" , spy.toString());
+        assertEquals("[foo]", spy.toString());
     }
 
     interface Foo {
@@ -167,14 +164,16 @@ interface Foo {
 
     @Test
     public void shouldAllowSpyingAnonymousClasses() {
-        //when
-        Foo spy = spy(new Foo() {
-            public String print() {
-                return "foo";
-            }
-        });
-
-        //then
+        // when
+        Foo spy =
+                spy(
+                        new Foo() {
+                            public String print() {
+                                return "foo";
+                            }
+                        });
+
+        // then
         assertEquals("foo", spy.print());
     }
 
@@ -183,10 +182,14 @@ public void shouldSayNiceMessageWhenSpyingOnPrivateClass() throws Exception {
         List<String> real = Arrays.asList("first", "second");
         try {
             List<String> spy = spy(real);
-            assumeTrue("Using inline mocks, it is possible to spy on private types", spy.getClass() != real.getClass());
+            assumeTrue(
+                    "Using inline mocks, it is possible to spy on private types",
+                    spy.getClass() != real.getClass());
             fail();
         } catch (MockitoException e) {
-            assertThat(e).hasMessageContaining("Most likely it is due to mocking a private class that is not visible to Mockito");
+            assertThat(e)
+                    .hasMessageContaining(
+                            "Most likely it is due to mocking a private class that is not visible to Mockito");
         }
     }
 }
diff --git a/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java b/mockito-core/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
similarity index 95%
rename from src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
rename to mockito-core/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
index 89bdd66712..da467887de 100644
--- a/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
+++ b/mockito-core/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
@@ -4,7 +4,7 @@
  */
 package org.mockitousage.spies;
 
-import static org.mockito.Matchers.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.spy;
 
 import java.util.Collection;
diff --git a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
similarity index 87%
rename from src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
rename to mockito-core/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
index 9591411647..e204784d0c 100644
--- a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
@@ -34,7 +34,9 @@ public void shouldShowActualAndExpectedWhenArgumentsAreDifferent() {
             verifyTheMock(1, "not foo");
             fail();
         } catch (ArgumentsAreDifferent e) {
-            assertThat(e).hasMessageContaining("callMethodOnMock(").hasMessageContaining("verifyTheMock(");
+            assertThat(e)
+                    .hasMessageContaining("callMethodOnMock(")
+                    .hasMessageContaining("verifyTheMock(");
         }
     }
 }
diff --git a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
similarity index 87%
rename from src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
rename to mockito-core/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
index 5fc186e7fc..2bd7e0c735 100644
--- a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
@@ -27,7 +27,7 @@ public void resetState() {
     }
 
     private void misplacedArgumentMatcherHere() {
-        anyString();
+        String ignored = anyString();
     }
 
     @Test
@@ -38,8 +38,8 @@ public void shouldPointOutMisplacedMatcher() {
             fail();
         } catch (InvalidUseOfMatchersException e) {
             assertThat(e)
-                .hasMessageContaining("-> at ")
-                .hasMessageContaining("misplacedArgumentMatcherHere(");
+                    .hasMessageContaining("-> at ")
+                    .hasMessageContaining("misplacedArgumentMatcherHere(");
         }
     }
 
@@ -57,8 +57,8 @@ public void shouldPointOutUnfinishedStubbing() {
             fail();
         } catch (UnfinishedStubbingException e) {
             assertThat(e)
-                .hasMessageContaining("-> at ")
-                .hasMessageContaining("unfinishedStubbingHere(");
+                    .hasMessageContaining("-> at ")
+                    .hasMessageContaining("unfinishedStubbingHere(");
         }
     }
 
diff --git a/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
similarity index 96%
rename from src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
rename to mockito-core/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
index f57b024318..03d99beda9 100644
--- a/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
@@ -34,7 +34,7 @@ public void cleanStackTrace() {
     @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void makeSureStateIsValidatedInTheVeryFirstTestThanksToTheRunner() {
-        //mess up the state:
+        // mess up the state:
         verify(mock);
     }
 
@@ -158,14 +158,14 @@ public void shouldMentionFinalAndObjectMethodsWhenVerifying() {
 
     @Test
     public void shouldMentionFinalAndObjectMethodsWhenMisplacedArgumentMatcher() {
-        when(mock.equals(anyObject())).thenReturn(false);
+        when(mock.equals(any())).thenReturn(false);
     }
 
     @Test
     public void shouldShowExampleOfCorrectArgumentCapturing() {
         ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
-        argument.capture();
-        argument.getValue();
+        Object ignored = argument.capture();
+        String ignoredValue = argument.getValue();
     }
 
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
similarity index 99%
rename from src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
rename to mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
index 39b67bd804..4a2b7b75be 100644
--- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
@@ -39,14 +39,17 @@ private void firstChunk() {
         mock.simpleMethod(1);
         mock.simpleMethod(1);
     }
+
     private void secondChunk() {
         mockTwo.simpleMethod(2);
         mockTwo.simpleMethod(2);
     }
+
     private void thirdChunk() {
         mock.simpleMethod(3);
         mock.simpleMethod(3);
     }
+
     private void fourthChunk() {
         mockTwo.simpleMethod(4);
         mockTwo.simpleMethod(4);
diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
similarity index 97%
rename from src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
rename to mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
index 3e17a8147f..a85252da07 100644
--- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
@@ -18,7 +18,7 @@
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-//This is required to make sure stack trace is well filtered when runner is ON
+// This is required to make sure stack trace is well filtered when runner is ON
 @RunWith(MockitoJUnitRunner.class)
 public class PointingStackTraceToActualInvocationInOrderTest extends TestBase {
 
@@ -39,12 +39,15 @@ public void setup() {
     private void first() {
         mock.simpleMethod(1);
     }
+
     private void second() {
         mockTwo.simpleMethod(2);
     }
+
     private void third() {
         mock.simpleMethod(3);
     }
+
     private void fourth() {
         mockTwo.simpleMethod(4);
     }
diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
similarity index 95%
rename from src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
rename to mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
index 3ac3d9bb67..41c2f044b3 100644
--- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
@@ -18,7 +18,7 @@
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
-//This is required to make sure stack trace is well filtered when runner is ON
+// This is required to make sure stack trace is well filtered when runner is ON
 @RunWith(MockitoJUnitRunner.class)
 public class PointingStackTraceToActualInvocationTest extends TestBase {
 
@@ -36,12 +36,15 @@ public void setup() {
     private void first() {
         mock.simpleMethod(1);
     }
+
     private void second() {
         mockTwo.simpleMethod(2);
     }
+
     private void third() {
         mock.simpleMethod(3);
     }
+
     private void fourth() {
         mockTwo.simpleMethod(4);
     }
diff --git a/mockito-core/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java b/mockito-core/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
new file mode 100644
index 0000000000..1734e53a5b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stacktrace;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.Conditions.firstMethodInStackTrace;
+
+import org.assertj.core.api.Assertions;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class StackTraceFilteringTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    @After
+    public void resetState() {
+        super.resetState();
+    }
+
+    @Before
+    public void setup() {
+        makeStackTracesClean();
+    }
+
+    @Test
+    public void shouldFilterStackTraceOnVerify() {
+        try {
+            verify(mock).simpleMethod();
+            fail();
+        } catch (WantedButNotInvoked e) {
+            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerify"));
+        }
+    }
+
+    @Test
+    public void shouldFilterStackTraceOnVerifyNoMoreInteractions() {
+        mock.oneArg(true);
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+            Assertions.assertThat(e)
+                    .has(
+                            firstMethodInStackTrace(
+                                    "shouldFilterStackTraceOnVerifyNoMoreInteractions"));
+        }
+    }
+
+    @Test
+    public void shouldFilterStackTraceOnVerifyNoInteractions() {
+        mock.oneArg(true);
+        try {
+            verifyNoInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+            Assertions.assertThat(e)
+                    .has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoInteractions"));
+        }
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void shouldFilterStacktraceOnMockitoException() {
+        verify(mock);
+        try {
+            verify(mock).oneArg(true);
+            fail();
+        } catch (MockitoException expected) {
+            Assertions.assertThat(expected)
+                    .has(firstMethodInStackTrace("shouldFilterStacktraceOnMockitoException"));
+        }
+    }
+
+    @Test
+    public void shouldFilterStacktraceWhenVerifyingInOrder() {
+        InOrder inOrder = inOrder(mock);
+        mock.oneArg(true);
+        mock.oneArg(false);
+
+        inOrder.verify(mock).oneArg(false);
+        try {
+            inOrder.verify(mock).oneArg(true);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+            Assertions.assertThat(e)
+                    .has(firstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder"));
+        }
+    }
+
+    @Test
+    public void shouldFilterStacktraceWhenInOrderThrowsMockitoException() {
+        try {
+            inOrder();
+            fail();
+        } catch (MockitoException expected) {
+            Assertions.assertThat(expected)
+                    .has(
+                            firstMethodInStackTrace(
+                                    "shouldFilterStacktraceWhenInOrderThrowsMockitoException"));
+        }
+    }
+
+    @Test
+    public void shouldFilterStacktraceWhenInOrderVerifies() {
+        try {
+            InOrder inOrder = inOrder(mock);
+            inOrder.verify(null);
+            fail();
+        } catch (MockitoException expected) {
+            Assertions.assertThat(expected)
+                    .has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies"));
+        }
+    }
+
+    @Test
+    public void shouldFilterStackTraceWhenThrowingExceptionFromMockHandler() {
+        try {
+            when(mock.oneArg(true)).thenThrow(new Exception());
+            fail();
+        } catch (MockitoException expected) {
+            Assertions.assertThat(expected)
+                    .has(
+                            firstMethodInStackTrace(
+                                    "shouldFilterStackTraceWhenThrowingExceptionFromMockHandler"));
+        }
+    }
+
+    @Test
+    public void shouldShowProperExceptionStackTrace() throws Exception {
+        when(mock.simpleMethod()).thenThrow(new RuntimeException());
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (RuntimeException e) {
+            Assertions.assertThat(e)
+                    .has(firstMethodInStackTrace("shouldShowProperExceptionStackTrace"));
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java
new file mode 100644
index 0000000000..e2f4b7eb8c
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+import static org.mockito.Mockito.when;
+
+import org.assertj.core.api.Assertions;
+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;
+
+public class LenientMockAnnotationTest {
+
+    public @Rule MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+    @Mock(lenient = true)
+    IMethods lenientMock;
+
+    @Mock IMethods regularMock;
+
+    @Test
+    public void mock_is_lenient() {
+        when(lenientMock.simpleMethod("1")).thenReturn("1");
+        when(regularMock.simpleMethod("2")).thenReturn("2");
+
+        // then lenient mock does not throw:
+        ProductionCode.simpleMethod(lenientMock, "3");
+
+        // but regular mock throws:
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                ProductionCode.simpleMethod(regularMock, "4");
+                            }
+                        })
+                .isInstanceOf(PotentialStubbingProblem.class);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java
new file mode 100644
index 0000000000..9b468ffe83
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+import static org.mockito.Mockito.when;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Before;
+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;
+
+public class PotentialStubbingSensitivityTest {
+
+    @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+    @Mock IMethods mock;
+
+    @Before
+    public void setup() {
+        when(mock.simpleMethod("1")).thenReturn("1");
+    }
+
+    @Test
+    public void allows_stubbing_with_different_arg_in_test_code() {
+        // although we are calling 'simpleMethod' with different argument
+        // Mockito understands that this is stubbing in the test code and does not trigger
+        // PotentialStubbingProblem
+        when(mock.simpleMethod("2")).thenReturn("2");
+
+        // methods in anonymous inner classes are ok, too
+        new Runnable() {
+            public void run() {
+                when(mock.simpleMethod("3")).thenReturn("3");
+            }
+        }.run();
+
+        // avoiding unnecessary stubbing failures:
+        mock.simpleMethod("1");
+        mock.simpleMethod("2");
+        mock.simpleMethod("3");
+    }
+
+    @Test
+    public void reports_potential_stubbing_problem_in_production_code() {
+        // when
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() throws Throwable {
+                                ProductionCode.simpleMethod(mock, "2");
+                            }
+                        })
+                .isInstanceOf(PotentialStubbingProblem.class);
+    }
+}
diff --git a/src/test/java/org/mockitousage/strictness/ProductionCode.java b/mockito-core/src/test/java/org/mockitousage/strictness/ProductionCode.java
similarity index 100%
rename from src/test/java/org/mockitousage/strictness/ProductionCode.java
rename to mockito-core/src/test/java/org/mockitousage/strictness/ProductionCode.java
diff --git a/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessMockAnnotationTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessMockAnnotationTest.java
new file mode 100644
index 0000000000..7250555880
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessMockAnnotationTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2022 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.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+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.mockito.Mockito.when;
+
+@RunWith(Enclosed.class)
+public class StrictnessMockAnnotationTest {
+
+    public static class StrictStubsTest {
+        public @Rule MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+        @Mock(strictness = Mock.Strictness.LENIENT)
+        IMethods lenientMock;
+
+        @Mock IMethods regularMock;
+
+        @Test
+        public void mock_is_lenient() {
+            when(lenientMock.simpleMethod("1")).thenReturn("1");
+
+            // then lenient mock does not throw:
+            ProductionCode.simpleMethod(lenientMock, "3");
+        }
+
+        @Test
+        public void mock_is_strict() {
+            when(regularMock.simpleMethod("2")).thenReturn("2");
+
+            Assertions.assertThatThrownBy(() -> ProductionCode.simpleMethod(regularMock, "4"))
+                    .isInstanceOf(PotentialStubbingProblem.class);
+        }
+    }
+
+    public static class LenientStubsTest {
+        public @Rule MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.LENIENT);
+
+        @Mock IMethods lenientMock;
+
+        @Mock(strictness = Mock.Strictness.STRICT_STUBS)
+        IMethods regularMock;
+
+        @Test
+        public void mock_is_lenient() {
+            when(lenientMock.simpleMethod("1")).thenReturn("1");
+
+            // then lenient mock does not throw:
+            ProductionCode.simpleMethod(lenientMock, "3");
+        }
+
+        @Test
+        public void mock_is_strict() {
+            when(regularMock.simpleMethod("2")).thenReturn("2");
+
+            Assertions.assertThatThrownBy(() -> ProductionCode.simpleMethod(regularMock, "4"))
+                    .isInstanceOf(PotentialStubbingProblem.class);
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
new file mode 100644
index 0000000000..fd1c05323f
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+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;
+
+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;
+
+// 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() {
+                            public void call() throws Throwable {
+                                ProductionCode.simpleMethod(strictStubsMock, 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/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
new file mode 100644
index 0000000000..cc78e2ab8a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+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;
+
+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;
+
+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 {
+                                ProductionCode.simpleMethod(mock, "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/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
new file mode 100644
index 0000000000..b8a5dc4a38
--- /dev/null
+++ b/mockito-core/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 static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+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;
+
+@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() {
+                            public void call() {
+                                ProductionCode.simpleMethod(mock, "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/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
new file mode 100644
index 0000000000..c1081278cb
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+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;
+
+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;
+
+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() {
+                            public void call() {
+                                ProductionCode.simpleMethod(mock, 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() {
+                            public void call() {
+                                ProductionCode.simpleMethod(mock, 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/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
new file mode 100644
index 0000000000..1bc9574e71
--- /dev/null
+++ b/mockito-core/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 static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+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;
+
+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() {
+                            public void call() {
+                                ProductionCode.simpleMethod(mock, "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/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWithSettingsTest.java b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWithSettingsTest.java
new file mode 100644
index 0000000000..854792cd50
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/strictness/StrictnessWithSettingsTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2022 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.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+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.mockito.Mockito.*;
+
+public class StrictnessWithSettingsTest {
+
+    public @Rule MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+    IMethods lenientMock;
+    IMethods regularMock;
+    IMethods strictMock;
+
+    @Before
+    public void before() {
+        lenientMock = mock(IMethods.class, withSettings().strictness(Strictness.LENIENT));
+        regularMock = mock(IMethods.class);
+        strictMock = mock(IMethods.class, withSettings().strictness(Strictness.STRICT_STUBS));
+    }
+
+    @Test
+    public void mock_is_lenient() {
+        when(lenientMock.simpleMethod("1")).thenReturn("1");
+
+        // lenient mock does not throw
+        ProductionCode.simpleMethod(lenientMock, "3");
+    }
+
+    @Test
+    public void mock_is_strict_with_default_settings() {
+        when(regularMock.simpleMethod("3")).thenReturn("3");
+
+        Assertions.assertThatThrownBy(() -> ProductionCode.simpleMethod(regularMock, "4"))
+                .isInstanceOf(PotentialStubbingProblem.class);
+    }
+
+    @Test
+    public void mock_is_strict_with_explicit_settings() {
+        when(strictMock.simpleMethod("2")).thenReturn("2");
+
+        Assertions.assertThatThrownBy(() -> ProductionCode.simpleMethod(strictMock, "5"))
+                .isInstanceOf(PotentialStubbingProblem.class);
+    }
+}
diff --git a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
similarity index 80%
rename from src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
index 022cadc64d..15e4346526 100644
--- a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
@@ -33,7 +33,8 @@ public void should_evaluate_latest_stubbing_first() throws Exception {
 
         assertEquals(200, mock.objectReturningMethod(200));
         assertEquals(100, mock.objectReturningMethod(666));
-        assertEquals("default behavior should return null", null, mock.objectReturningMethod("blah"));
+        assertEquals(
+                "default behavior should return null", null, mock.objectReturningMethod("blah"));
     }
 
     @Test
@@ -45,7 +46,8 @@ public void should_stubbing_be_treated_as_interaction() throws Exception {
         try {
             verifyNoMoreInteractions(mock);
             fail();
-        } catch (NoInteractionsWanted e) {}
+        } catch (NoInteractionsWanted e) {
+        }
     }
 
     @Test
@@ -62,7 +64,7 @@ public void should_stubbing_not_be_treated_as_interaction() {
         when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
         doThrow(new RuntimeException()).when(mock).simpleMethod("two");
 
-        verifyZeroInteractions(mock);
+        verifyNoInteractions(mock);
     }
 
     @Test
@@ -79,10 +81,11 @@ public void unfinished_stubbing_cleans_up_the_state() {
         try {
             when("").thenReturn("");
             fail();
-        } catch (MissingMethodInvocationException e) {}
+        } catch (MissingMethodInvocationException e) {
+        }
 
-        //anything that can cause state validation
-        verifyZeroInteractions(mock);
+        // anything that can cause state validation
+        verifyNoInteractions(mock);
     }
 
     @Test
@@ -91,9 +94,10 @@ public void unfinished_stubbing_cleans_up_the_state_verify_no_interactions() {
         try {
             when("").thenReturn("");
             fail();
-        } catch (MissingMethodInvocationException e) {}
+        } catch (MissingMethodInvocationException e) {
+        }
 
-        //anything that can cause state validation
+        // anything that can cause state validation
         verifyNoInteractions(mock);
     }
 
@@ -127,12 +131,16 @@ public void test_stub_only_not_verifiable() throws Exception {
 
         assertEquals(200, localMock.objectReturningMethod(200));
         assertEquals(100, localMock.objectReturningMethod(666));
-        assertEquals("default behavior should return null", null, localMock.objectReturningMethod("blah"));
+        assertEquals(
+                "default behavior should return null",
+                null,
+                localMock.objectReturningMethod("blah"));
 
         try {
             verify(localMock, atLeastOnce()).objectReturningMethod(eq(200));
             fail();
-        } catch (CannotVerifyStubOnlyMock e) {}
+        } catch (CannotVerifyStubOnlyMock e) {
+        }
     }
 
     @SuppressWarnings("MockitoUsage")
@@ -144,9 +152,11 @@ public void test_stub_only_not_verifiable_fail_fast() {
             verify(localMock); // throws exception before method invocation
             fail();
         } catch (CannotVerifyStubOnlyMock e) {
-            assertEquals("\n" +
-                "Argument \"iMethods\" passed to verify is a stubOnly() mock which cannot be verified.\n" +
-                "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings.", e.getMessage());
+            assertEquals(
+                    "\n"
+                            + "Argument \"iMethods\" passed to verify is a stubOnly() mock which cannot be verified.\n"
+                            + "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings.",
+                    e.getMessage());
         }
     }
 
@@ -157,7 +167,8 @@ public void test_stub_only_not_verifiable_verify_no_more_interactions() {
         try {
             verifyNoMoreInteractions(localMock);
             fail();
-        } catch (CannotVerifyStubOnlyMock e) {}
+        } catch (CannotVerifyStubOnlyMock e) {
+        }
     }
 
     @Test
@@ -167,6 +178,7 @@ public void test_stub_only_not_verifiable_in_order() {
         try {
             inOrder(localMock);
             fail();
-        } catch (CannotVerifyStubOnlyMock e) {}
+        } catch (CannotVerifyStubOnlyMock e) {
+        }
     }
 }
diff --git a/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
similarity index 98%
rename from src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
index 43917d120a..333661df33 100644
--- a/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
@@ -13,8 +13,7 @@
 
 public class CallingRealMethodTest extends TestBase {
 
-    @Mock
-    TestedObject mock;
+    @Mock TestedObject mock;
 
     static class TestedObject {
 
diff --git a/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
similarity index 80%
rename from src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
index 465bd21c85..000f76666d 100644
--- a/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
@@ -55,14 +55,14 @@ public void shouldCloneArrays() throws Exception {
         EmailSender emailSender = mock(EmailSender.class, new ClonesArguments());
 
         // 1. Pass an array into a mock that "ClonesArguments"
-        Person[] ccList = new Person[] { new Person("Wes") };
+        Person[] ccList = new Person[] {new Person("Wes")};
         emailSender.sendGroupEmail(1, ccList);
 
         // 2. Mutate the array
         ccList[0] = new Person("Joe");
 
         // 3. Verify that the mock made a copy of the array
-        verify(emailSender).sendGroupEmail(1, new Person[] { new Person("Wes") });
+        verify(emailSender).sendGroupEmail(1, new Person[] {new Person("Wes")});
     }
 
     @Test
@@ -71,10 +71,10 @@ public void shouldNotThrowNPEWhenCloningNulls() throws Exception {
         EmailSender emailSender = mock(EmailSender.class, new ClonesArguments());
 
         // 1. Pass a null into a mock that "ClonesArguments"
-        emailSender.sendEmail(1, (Person)null);
+        emailSender.sendEmail(1, (Person) null);
 
         // 2. Verify that the null argument was captured
-        verify(emailSender).sendEmail(eq(1), (Person)isNull());
+        verify(emailSender).sendEmail(eq(1), (Person) isNull());
     }
 
     public class Person {
@@ -102,29 +102,21 @@ public int hashCode() {
 
         @Override
         public boolean equals(Object obj) {
-            if (this == obj)
-                return true;
-            if (obj == null)
-                return false;
-            if (getClass() != obj.getClass())
-                return false;
+            if (this == obj) return true;
+            if (obj == null) return false;
+            if (getClass() != obj.getClass()) return false;
             Person other = (Person) obj;
-            if (!getOuterType().equals(other.getOuterType()))
-                return false;
-            if (emailSent != other.emailSent)
-                return false;
+            if (!getOuterType().equals(other.getOuterType())) return false;
+            if (emailSent != other.emailSent) return false;
             if (name == null) {
-                if (other.name != null)
-                    return false;
-            } else if (!name.equals(other.name))
-                return false;
+                if (other.name != null) return false;
+            } else if (!name.equals(other.name)) return false;
             return true;
         }
 
         private CloningParameterTest getOuterType() {
             return CloningParameterTest.this;
         }
-
     }
 
     public interface EmailSender {
@@ -134,6 +126,5 @@ public interface EmailSender {
         void sendGroupEmail(int i, Person[] persons);
 
         List<?> getAllEmails(Person person);
-
     }
 }
diff --git a/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
similarity index 86%
rename from src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
index 3740a28b9d..5e39714cfd 100644
--- a/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
@@ -6,6 +6,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.fail;
@@ -22,10 +23,10 @@
 
 import org.junit.Test;
 import org.mockito.InOrder;
+import org.mockito.MockSettings;
 import org.mockito.exceptions.verification.TooManyActualInvocations;
 import org.mockitoutil.TestBase;
 
-
 public class DeepStubbingTest extends TestBase {
 
     static class Person {
@@ -165,7 +166,7 @@ public void withArguments() throws Exception {
     public void withAnyPatternArguments() throws Exception {
         OutputStream out = new ByteArrayOutputStream();
 
-        //TODO: should not use javax in case it changes
+        // TODO: should not use javax in case it changes
         SocketFactory sf = mock(SocketFactory.class, RETURNS_DEEP_STUBS);
         when(sf.createSocket(anyString(), anyInt()).getOutputStream()).thenReturn(out);
 
@@ -222,36 +223,50 @@ public void withPatternPrimitive() throws Exception {
         assertEquals(a, sf.createSocket("stackoverflow.com", 80).getPort());
     }
 
+    @Test
+    public void unnamed_to_string() {
+        SocketFactory sf = mock(SocketFactory.class, RETURNS_DEEP_STUBS);
+        assertNotNull(sf.toString());
+    }
+
+    @Test
+    public void named_to_string() {
+        MockSettings settings =
+                withSettings().name("name of mock").defaultAnswer(RETURNS_DEEP_STUBS);
+        SocketFactory sf = mock(SocketFactory.class, settings);
+        assertEquals("name of mock", sf.toString());
+    }
+
     Person person = mock(Person.class, RETURNS_DEEP_STUBS);
 
     @Test
     public void shouldStubbingBasicallyWorkFine() {
-        //given
+        // given
         given(person.getAddress().getStreet().getName()).willReturn("Norymberska");
 
-        //when
+        // when
         String street = person.getAddress().getStreet().getName();
 
-        //then
+        // then
         assertEquals("Norymberska", street);
     }
 
     @Test
     public void shouldVerificationBasicallyWorkFine() {
-        //given
+        // given
         person.getAddress().getStreet().getName();
 
-        //then
+        // then
         verify(person.getAddress().getStreet()).getName();
     }
 
     @Test
     public void verification_work_with_argument_Matchers_in_nested_calls() {
-        //given
+        // given
         person.getAddress("111 Mock Lane").getStreet();
         person.getAddress("111 Mock Lane").getStreet(Locale.ITALIAN).getName();
 
-        //then
+        // then
         verify(person.getAddress(anyString())).getStreet();
         verify(person.getAddress(anyString()).getStreet(Locale.CHINESE), never()).getName();
         verify(person.getAddress(anyString()).getStreet(eq(Locale.ITALIAN))).getName();
@@ -263,11 +278,21 @@ public void deep_stub_return_same_mock_instance_if_invocation_matchers_matches()
 
         person.getAddress("the docks").getStreet().getName();
 
-        assertSame(person.getAddress("the docks").getStreet(), person.getAddress(anyString()).getStreet());
-        assertSame(person.getAddress(anyString()).getStreet(), person.getAddress(anyString()).getStreet());
-        assertSame(person.getAddress("the docks").getStreet(), person.getAddress("the docks").getStreet());
-        assertSame(person.getAddress(anyString()).getStreet(), person.getAddress("the docks").getStreet());
-        assertSame(person.getAddress("111 Mock Lane").getStreet(), person.getAddress("the docks").getStreet());
+        assertSame(
+                person.getAddress("the docks").getStreet(),
+                person.getAddress(anyString()).getStreet());
+        assertSame(
+                person.getAddress(anyString()).getStreet(),
+                person.getAddress(anyString()).getStreet());
+        assertSame(
+                person.getAddress("the docks").getStreet(),
+                person.getAddress("the docks").getStreet());
+        assertSame(
+                person.getAddress(anyString()).getStreet(),
+                person.getAddress("the docks").getStreet());
+        assertSame(
+                person.getAddress("111 Mock Lane").getStreet(),
+                person.getAddress("the docks").getStreet());
     }
 
     @Test
@@ -284,7 +309,6 @@ public void times_never_atLeast_atMost_verificationModes_should_work() {
         verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atMostOnce()).getName();
     }
 
-
     @Test
     public void inOrder_only_work_on_the_very_last_mock_but_it_works() {
         when(person.getAddress(anyString()).getStreet().getName()).thenReturn("deep");
@@ -296,14 +320,15 @@ public void inOrder_only_work_on_the_very_last_mock_but_it_works() {
         person.getAddress("the docks").getStreet(Locale.ITALIAN).getName();
         person.getAddress("the docks").getStreet(Locale.CHINESE).getName();
 
-        InOrder inOrder = inOrder(
-                person.getAddress("the docks").getStreet(),
-                person.getAddress("the docks").getStreet(Locale.CHINESE),
-                person.getAddress("the docks").getStreet(Locale.ITALIAN)
-        );
+        InOrder inOrder =
+                inOrder(
+                        person.getAddress("the docks").getStreet(),
+                        person.getAddress("the docks").getStreet(Locale.CHINESE),
+                        person.getAddress("the docks").getStreet(Locale.ITALIAN));
         inOrder.verify(person.getAddress("the docks").getStreet(), times(1)).getName();
         inOrder.verify(person.getAddress("the docks").getStreet()).getLongName();
-        inOrder.verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atLeast(1)).getName();
+        inOrder.verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atLeast(1))
+                .getName();
         inOrder.verify(person.getAddress("the docks").getStreet(Locale.CHINESE)).getName();
     }
 
@@ -322,19 +347,17 @@ public void verificationMode_only_work_on_the_last_returned_mock() {
             verify(person.getAddress("the docks"), times(1)).getStreet();
             fail();
         } catch (TooManyActualInvocations e) {
-            assertThat(e.getMessage())
-                    .contains("Wanted 1 time")
-                    .contains("But was 3 times");
+            assertThat(e.getMessage()).contains("Wanted 1 time").contains("But was 3 times");
         }
     }
 
     @Test
     public void shouldFailGracefullyWhenClassIsFinal() {
-        //when
+        // when
         FinalClass value = new FinalClass();
         given(person.getFinalClass()).willReturn(value);
 
-        //then
+        // then
         assertEquals(value, person.getFinalClass());
     }
 
@@ -353,5 +376,4 @@ public void deep_stub_does_not_stack_overflow_on_reversed_generics() {
 
         assertThat(mock.reverse().finalMethod()).isEqualTo(5L);
     }
-
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java
new file mode 100644
index 0000000000..556bc56368
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.validateMockitoUsage;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+public class MisusingStubbingTest extends TestBase {
+
+    @Test
+    public void clean_state_after_not_a_mock() {
+        // when
+        assertThatThrownBy(() -> doReturn(100).when("not a mock"));
+
+        // then
+        validateMockitoUsage();
+    }
+
+    @Test
+    public void clean_state_after_null_passed() {
+        // when
+        assertThatThrownBy(() -> doReturn(100).when(null));
+
+        // then
+        validateMockitoUsage();
+    }
+}
diff --git a/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java
similarity index 100%
rename from src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java
new file mode 100644
index 0000000000..38f5ff6821
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.Answers;
+
+// Reproduces issue #1551
+public class SmartNullsGenericBugTest {
+
+    @Test
+    public void smart_nulls_generic_bug_generic_T() {
+        ConcreteDao concreteDao =
+                mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+        final Entity result = concreteDao.findById();
+
+        Assertions.assertThat(result).as("#1551").isNotNull();
+    }
+
+    @Test
+    public void smart_nulls_generic_bug_generic_M() {
+        ConcreteDao concreteDao =
+                mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+        final String other = concreteDao.find();
+
+        Assertions.assertThat(other).as("#1551 - CCannot resolve type").isNull();
+    }
+
+    @Test
+    public void smart_nulls_generic_bug_generic_M_provided_in_args() {
+        ConcreteDao concreteDao =
+                mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+        final String other = concreteDao.findArgs(1, "plop");
+
+        Assertions.assertThat(other).as("#1551").isEqualTo("");
+    }
+
+    @Test
+    public void smart_nulls_generic_bug_generic_M_provided_as_varargs() {
+        ConcreteDao concreteDao =
+                mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+        final String other = concreteDao.findVarargs(42, "plip", "plop");
+
+        Assertions.assertThat(other).as("#1551").isEqualTo("");
+    }
+
+    static class AbstractDao<T> {
+        T findById() {
+            return null;
+        }
+
+        <M> M find() {
+            return null;
+        }
+
+        <M> M findArgs(int idx, M arg) {
+            return null;
+        }
+
+        <M> M findVarargs(int idx, M... args) {
+            return null;
+        }
+    }
+
+    static class Entity {}
+
+    static class ConcreteDao extends AbstractDao<Entity> {}
+}
diff --git a/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
similarity index 81%
rename from src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
index 304d062a31..cd98a0d07d 100644
--- a/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
@@ -67,7 +67,9 @@ Bar getBarWithParams(int x, String y) {
             return null;
         }
 
-        <T> T returnsFromArg(T arg) { return arg; }
+        <T> T returnsFromArg(T arg) {
+            return arg;
+        }
 
         void boo() {}
     }
@@ -79,7 +81,8 @@ public void shouldThrowSmartNPEWhenMethodReturnsClass() throws Exception {
         try {
             foo.boo();
             fail();
-        } catch (SmartNullPointerException e) {}
+        } catch (SmartNullPointerException e) {
+        }
     }
 
     @Test
@@ -89,10 +92,10 @@ public void shouldThrowSmartNPEWhenMethodReturnsInterface() throws Exception {
         try {
             bar.boo();
             fail();
-        } catch (SmartNullPointerException e) {}
+        } catch (SmartNullPointerException e) {
+        }
     }
 
-
     @Test
     public void shouldReturnOrdinaryEmptyValuesForOrdinaryTypes() throws Exception {
         IMethods mock = mock(IMethods.class, RETURNS_SMART_NULLS);
@@ -109,13 +112,14 @@ public void shouldNotThrowSmartNullPointerOnToString() {
         try {
             verify(mock).simpleMethod(smartNull);
             fail();
-        } catch (WantedButNotInvoked e) {}
+        } catch (WantedButNotInvoked e) {
+        }
     }
 
     @Test
     public void shouldNotThrowSmartNullPointerOnObjectMethods() {
         Object smartNull = mock.objectReturningMethod();
-        smartNull.toString();
+        String ignored = smartNull.toString();
     }
 
     @Test
@@ -134,7 +138,8 @@ public void shouldShowParameters() {
     @Test
     public void shouldShowParametersWhenParamsAreHuge() {
         Foo foo = mock(Foo.class, RETURNS_SMART_NULLS);
-        String longStr = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";
+        String longStr =
+                "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";
         Bar smartNull = foo.getBarWithParams(10, longStr);
 
         try {
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
new file mode 100644
index 0000000000..71ae85727d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.mockito.BDDMockito.given;
+import static org.mockitoutil.ConcurrentTesting.concurrently;
+import static org.mockitoutil.JUnitResultAssert.assertThat;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoSession;
+import org.mockito.StateMaster;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitousage.strictness.ProductionCode;
+
+public class StrictStubbingEndToEndTest {
+
+    JUnitCore junit = new JUnitCore();
+
+    @After
+    public void after() {
+        new StateMaster().clearMockitoListeners();
+    }
+
+    @Test
+    public void finish_mocking_exception_does_not_hide_the_exception_from_test() {
+        Result result = junit.run(UnnecessaryStubbing.class);
+        assertThat(result)
+                // both exceptions are reported to JUnit:
+                .fails("unnecessary_stubbing", IllegalStateException.class)
+                .fails("unnecessary_stubbing", UnnecessaryStubbingException.class);
+    }
+
+    @Test
+    public void does_not_report_unused_stubbing_if_mismatch_reported() {
+        Result result = junit.run(ReportMismatchButNotUnusedStubbing.class);
+        assertThat(result).fails(1, PotentialStubbingProblem.class);
+    }
+
+    @Test
+    public void strict_stubbing_does_not_leak_to_other_tests() {
+        Result result =
+                junit.run(
+                        LenientStrictness1.class,
+                        StrictStubsPassing.class,
+                        LenientStrictness2.class);
+        // all tests pass, lenient test cases contain incorrect stubbing
+        assertThat(result).succeeds(5);
+    }
+
+    @Test
+    public void detects_unfinished_session() {
+        Result result = junit.run(UnfinishedMocking.class);
+        assertThat(result)
+                .fails(
+                        UnfinishedMockingSessionException.class,
+                        "\n"
+                                + "Unfinished mocking session detected.\n"
+                                + "Previous MockitoSession was not concluded with 'finishMocking()'.\n"
+                                + "For examples of correct usage see javadoc for MockitoSession class.");
+    }
+
+    @Test
+    public void concurrent_sessions_in_different_threads() throws Exception {
+        final Map<Class, Result> results = new ConcurrentHashMap<Class, Result>();
+        concurrently(
+                new Runnable() {
+                    public void run() {
+                        results.put(StrictStubsPassing.class, junit.run(StrictStubsPassing.class));
+                    }
+                },
+                new Runnable() {
+                    public void run() {
+                        results.put(
+                                ReportMismatchButNotUnusedStubbing.class,
+                                junit.run(ReportMismatchButNotUnusedStubbing.class));
+                    }
+                });
+
+        assertThat(results.get(StrictStubsPassing.class)).succeeds(1);
+        assertThat(results.get(ReportMismatchButNotUnusedStubbing.class)).fails(1);
+    }
+
+    public static class UnnecessaryStubbing {
+        @Mock IMethods mock;
+        MockitoSession mockito =
+                Mockito.mockitoSession()
+                        .initMocks(this)
+                        .strictness(Strictness.STRICT_STUBS)
+                        .startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void unnecessary_stubbing() {
+            given(mock.simpleMethod("1")).willReturn("one");
+            throw new IllegalStateException();
+        }
+    }
+
+    public static class ReportMismatchButNotUnusedStubbing {
+        @Mock IMethods mock;
+        MockitoSession mockito =
+                Mockito.mockitoSession()
+                        .initMocks(this)
+                        .strictness(Strictness.STRICT_STUBS)
+                        .startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void mismatch() {
+            given(mock.simpleMethod(1)).willReturn("");
+            ProductionCode.simpleMethod(mock, 2);
+        }
+    }
+
+    public static class StrictStubsPassing {
+        @Mock IMethods mock;
+        MockitoSession mockito =
+                Mockito.mockitoSession()
+                        .initMocks(this)
+                        .strictness(Strictness.STRICT_STUBS)
+                        .startMocking();
+
+        @After
+        public void after() {
+            mockito.finishMocking();
+        }
+
+        @Test
+        public void used() {
+            given(mock.simpleMethod(1)).willReturn("");
+            mock.simpleMethod(1);
+        }
+    }
+
+    public static class LenientStrictness1 {
+        @Mock IMethods mock = Mockito.mock(IMethods.class);
+
+        @Test
+        public void unused() {
+            given(mock.simpleMethod(1)).willReturn("");
+        }
+
+        @Test
+        public void mismatch() {
+            given(mock.simpleMethod(2)).willReturn("");
+            mock.simpleMethod(3);
+        }
+    }
+
+    public static class LenientStrictness2 {
+        @Mock IMethods mock = Mockito.mock(IMethods.class);
+
+        @Test
+        public void unused() {
+            given(mock.simpleMethod(1)).willReturn("");
+        }
+
+        @Test
+        public void mismatch() {
+            given(mock.simpleMethod(2)).willReturn("");
+            mock.simpleMethod(3);
+        }
+    }
+
+    public static class UnfinishedMocking {
+        @Mock IMethods mock;
+        MockitoSession mockito =
+                Mockito.mockitoSession()
+                        .initMocks(this)
+                        .strictness(Strictness.STRICT_STUBS)
+                        .startMocking();
+
+        @Test
+        public void unused() {
+            given(mock.simpleMethod("1")).willReturn("one");
+        }
+
+        @Test
+        public void unused2() {
+            given(mock.simpleMethod("1")).willReturn("one");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
new file mode 100644
index 0000000000..dfc0323e26
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockitoutil.ThrowableAssert.assertThat;
+
+import org.junit.After;
+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.mockitousage.strictness.ProductionCode;
+
+public class StrictStubbingTest {
+
+    @Mock IMethods mock;
+
+    MockitoSession mockito =
+            Mockito.mockitoSession()
+                    .initMocks(this)
+                    .strictness(Strictness.STRICT_STUBS)
+                    .startMocking();
+
+    @After
+    public void after() {
+        // Some tests already invoke below but that's ok
+        mockito.finishMocking();
+    }
+
+    @Test
+    public void no_interactions() throws Throwable {
+        // expect no exception
+        mockito.finishMocking();
+    }
+
+    @Test
+    public void few_interactions() throws Throwable {
+        mock.simpleMethod(100);
+        mock.otherMethod();
+    }
+
+    @Test
+    public void few_verified_interactions() throws Throwable {
+        // when
+        mock.simpleMethod(100);
+        mock.otherMethod();
+
+        // and
+        verify(mock).simpleMethod(100);
+        verify(mock).otherMethod();
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void stubbed_method_is_implicitly_verified() throws Throwable {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+        mock.simpleMethod(100);
+
+        // no exceptions:
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+        mock.simpleMethod(100); // <- implicitly verified
+        mock.simpleMethod(200); // <- unverified
+
+        // expect
+        assertThat(
+                        new Runnable() {
+                            public void run() {
+                                verifyNoMoreInteractions(mock);
+                            }
+                        })
+                .throwsException(NoInteractionsWanted.class);
+    }
+
+    @Test
+    public void stubbing_argument_mismatch() throws Throwable {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+
+        // stubbing argument mismatch is detected
+        assertThat(
+                        new Runnable() {
+                            public void run() {
+                                ProductionCode.simpleMethod(mock, 200);
+                            }
+                        })
+                .throwsException(PotentialStubbingProblem.class);
+    }
+
+    @Test
+    public void unused_stubbing() throws Throwable {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+
+        // unused stubbing is reported
+        assertThat(
+                        new Runnable() {
+                            public void run() {
+                                mockito.finishMocking();
+                            }
+                        })
+                .throwsException(UnnecessaryStubbingException.class);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
new file mode 100644
index 0000000000..0d64e2b130
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class StubbingConsecutiveAnswersTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    @Test
+    public void should_return_consecutive_values() {
+        when(mock.simpleMethod()).thenReturn("one").thenReturn("two").thenReturn("three");
+
+        assertEquals("one", mock.simpleMethod());
+        assertEquals("two", mock.simpleMethod());
+        assertEquals("three", mock.simpleMethod());
+        assertEquals("three", mock.simpleMethod());
+        assertEquals("three", mock.simpleMethod());
+    }
+
+    @Test
+    public void should_return_consecutive_values_for_two_nulls() {
+        when(mock.simpleMethod()).thenReturn(null, (String[]) null);
+
+        assertNull(mock.simpleMethod());
+        assertNull(mock.simpleMethod());
+    }
+
+    @Test
+    public void should_return_consecutive_values_first_var_arg_null() {
+        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() {
+        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() {
+        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() {
+        when(mock.simpleMethod()).thenReturn("one", "two", "three");
+
+        assertEquals("one", mock.simpleMethod());
+        assertEquals("two", mock.simpleMethod());
+        assertEquals("three", mock.simpleMethod());
+        assertEquals("three", mock.simpleMethod());
+        assertEquals("three", mock.simpleMethod());
+    }
+
+    @Test
+    public void
+            should_return_consecutive_value_and_throw_exceptions_set_by_shorten_return_methods() {
+        when(mock.simpleMethod())
+                .thenReturn("zero")
+                .thenReturn("one", "two")
+                .thenThrow(new NullPointerException(), new RuntimeException())
+                .thenReturn("three")
+                .thenThrow(new IllegalArgumentException());
+
+        assertEquals("zero", mock.simpleMethod());
+        assertEquals("one", mock.simpleMethod());
+        assertEquals("two", mock.simpleMethod());
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (RuntimeException expected) {
+        }
+        assertEquals("three", mock.simpleMethod());
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+    }
+
+    @Test
+    public void should_throw_consecutively() {
+        when(mock.simpleMethod())
+                .thenThrow(new RuntimeException())
+                .thenThrow(new IllegalArgumentException())
+                .thenThrow(new NullPointerException());
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (RuntimeException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+    }
+
+    @Test
+    public void should_throw_consecutively_set_by_shorten_then_throw_method() {
+        when(mock.simpleMethod())
+                .thenThrow(
+                        new RuntimeException(),
+                        new IllegalArgumentException(),
+                        new NullPointerException());
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (RuntimeException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+    }
+
+    @Test
+    public void should_throw_classes() {
+        // Unavoidable JDK7+ 'unchecked generic array creation' warning
+        when(mock.simpleMethod()).thenThrow(IllegalArgumentException.class);
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void should_throw_consecutively_classes_set_by_shorten_then_throw_method() {
+        // Unavoidable JDK7+ 'unchecked generic array creation' warning
+        when(mock.simpleMethod())
+                .thenThrow(
+                        RuntimeException.class,
+                        IllegalArgumentException.class,
+                        NullPointerException.class);
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (RuntimeException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+    }
+
+    @Test
+    public void should_mix_consecutive_returns_with_exceptions() {
+        when(mock.simpleMethod())
+                .thenThrow(new IllegalArgumentException())
+                .thenReturn("one")
+                .thenThrow(new NullPointerException())
+                .thenReturn(null);
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+
+        assertEquals("one", mock.simpleMethod());
+
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+
+        assertEquals(null, mock.simpleMethod());
+        assertEquals(null, mock.simpleMethod());
+    }
+
+    @Test
+    public void should_validate_consecutive_exception() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.simpleMethod()).thenReturn("one").thenThrow(new Exception());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Checked exception is invalid for this method!",
+                        "Invalid: java.lang.Exception");
+    }
+
+    @Test
+    public void should_stub_void_method_and_continue_throwing() {
+        doThrow(new IllegalArgumentException())
+                .doNothing()
+                .doThrow(new NullPointerException())
+                .when(mock)
+                .voidMethod();
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+
+        mock.voidMethod();
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+    }
+
+    @Test
+    public void should_stub_void_method() {
+        doNothing().doThrow(new NullPointerException()).doNothing().when(mock).voidMethod();
+
+        mock.voidMethod();
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (NullPointerException expected) {
+        }
+
+        mock.voidMethod();
+        mock.voidMethod();
+    }
+
+    @Test
+    public void should_validate_consecutive_exception_for_void_method() {
+        assertThatThrownBy(
+                        () -> {
+                            doNothing().doThrow(new Exception()).when(mock).voidMethod();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Checked exception is invalid for this method!",
+                        "Invalid: java.lang.Exception");
+    }
+}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
similarity index 92%
rename from src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
index b90827106e..28b9cea895 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
@@ -73,6 +73,13 @@ public void should_not_fail_when_calling_primitive_returning_method() {
         assertThat(builder.returnInt()).isEqualTo(0);
     }
 
+    @Test
+    public void should_not_fail_when_calling_method_with_generic_return_type() {
+        Builder builder = mock(Builder.class, RETURNS_SELF);
+
+        assertThat(builder.returnGeneric("Generic Result")).isEqualTo(null);
+    }
+
     @Test
     public void use_full_builder_with_terminating_method() {
         HttpBuilder builder = mock(HttpBuilder.class, RETURNS_SELF);
@@ -99,6 +106,10 @@ public void returnNothing() {}
         public int returnInt() {
             return 1;
         }
+
+        public <T> T returnGeneric(T result) {
+            return result;
+        }
     }
 
     private static class BuilderSubClass extends Builder {
@@ -150,6 +161,5 @@ public HttpBuilder withHeader(String header) {
         public String request() {
             return uri + headers.toString();
         }
-
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
new file mode 100644
index 0000000000..53d902945d
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import java.io.IOException;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.stubbing.Answer;
+import org.mockitousage.IMethods;
+import org.mockitousage.MethodsImpl;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("serial")
+public class StubbingUsingDoReturnTest extends TestBase {
+
+    @Mock private IMethods mock;
+
+    @After
+    public void reset_state() {
+        super.resetState();
+    }
+
+    @Test
+    public void should_stub() {
+        doReturn("foo").when(mock).simpleMethod();
+        doReturn("bar").when(mock).simpleMethod();
+
+        assertThat(mock.simpleMethod()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_stub_with_args() {
+        doReturn("foo").when(mock).simpleMethod("foo");
+        doReturn("bar").when(mock).simpleMethod(eq("one"), anyInt());
+
+        assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
+        assertThat(mock.simpleMethod("one", 234)).isEqualTo("bar");
+        assertThat(mock.simpleMethod("xxx", 234)).isNull();
+    }
+
+    class FooRuntimeException extends RuntimeException {}
+
+    @Test
+    public void should_stub_with_throwable() {
+        doThrow(new FooRuntimeException()).when(mock).voidMethod();
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (FooRuntimeException e) {
+        }
+    }
+
+    @Test
+    public void should_allow_setting_valid_checked_exception() throws Exception {
+        doThrow(new IOException()).when(mock).throwsIOException(0);
+
+        try {
+            mock.throwsIOException(0);
+            fail();
+        } catch (IOException e) {
+        }
+    }
+
+    class FooCheckedException extends Exception {}
+
+    @Test
+    public void should_detect_invalid_checked_exception() {
+        try {
+            doThrow(new FooCheckedException()).when(mock).throwsIOException(0);
+            fail();
+        } catch (Exception e) {
+            assertThat(e).hasMessageContaining("Checked exception is invalid");
+        }
+    }
+
+    @Test
+    public void should_scream_when_return_set_for_void() {
+        try {
+            doReturn("foo").when(mock).voidMethod();
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e).hasMessageContaining("void method").hasMessageContaining("cannot");
+        }
+    }
+
+    @Test
+    public void should_scream_when_not_a_mock_passed() {
+        try {
+            doReturn("foo").when("foo").toString();
+            fail();
+        } catch (Exception e) {
+            assertThat(e).hasMessageContaining("Argument passed to when() is not a mock");
+        }
+    }
+
+    @Test
+    public void should_scream_when_null_passed() {
+        try {
+            doReturn("foo").when((Object) null).toString();
+            fail();
+        } catch (Exception e) {
+            assertThat(e).hasMessageContaining("Argument passed to when() is null");
+        }
+    }
+
+    @Test
+    public void should_allow_chained_stubbing() {
+        doReturn("foo").doThrow(new RuntimeException()).doReturn("bar").when(mock).simpleMethod();
+
+        assertThat(mock.simpleMethod()).isEqualTo("foo");
+        try {
+            mock.simpleMethod();
+            fail();
+        } catch (RuntimeException expected) {
+        }
+
+        assertThat(mock.simpleMethod()).isEqualTo("bar");
+        assertThat(mock.simpleMethod()).isEqualTo("bar");
+    }
+
+    @Test
+    public void should_allow_consecutive_return_values() {
+        doReturn("foo", "bar")
+                .doThrow(new RuntimeException())
+                .doReturn(430L, new byte[0], "qix")
+                .when(mock)
+                .objectReturningMethodNoArgs();
+
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("foo");
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("bar");
+        try {
+            mock.objectReturningMethodNoArgs();
+            fail("exception not raised");
+        } catch (RuntimeException expected) {
+        }
+
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(430L);
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(new byte[0]);
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("qix");
+        assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("qix");
+    }
+
+    @Test
+    public void should_allow_do_call_real_method_in_chained_stubbing() {
+        MethodsImpl methods = mock(MethodsImpl.class);
+        doReturn("A").doCallRealMethod().when(methods).simpleMethod();
+
+        assertThat(methods.simpleMethod()).isEqualTo("A");
+        assertThat(methods.simpleMethod()).isNull();
+    }
+
+    @Test
+    public void should_allow_chained_stubbing_with_exception_class() {
+        doReturn("whatever").doThrow(IllegalArgumentException.class).when(mock).simpleMethod();
+
+        assertThat(mock.simpleMethod()).isEqualTo("whatever");
+        assertThatThrownBy(
+                        () -> {
+                            mock.simpleMethod();
+                        })
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void should_allow_chained_stubbing_on_void_methods() {
+        doNothing().doNothing().doThrow(new RuntimeException()).when(mock).voidMethod();
+
+        mock.voidMethod();
+        mock.voidMethod();
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (RuntimeException e) {
+        }
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (RuntimeException e) {
+        }
+    }
+
+    @Test
+    public void should_stub_with_generic_answer() {
+        doAnswer((Answer<Object>) invocation -> "foo").when(mock).simpleMethod();
+
+        assertThat(mock.simpleMethod()).isEqualTo("foo");
+    }
+
+    @Test
+    public void should_not_allow_do_nothing_on_non_voids() {
+        try {
+            doNothing().when(mock).simpleMethod();
+            fail();
+        } catch (MockitoException e) {
+            assertThat(e).hasMessageContaining("Only void methods can doNothing()");
+        }
+    }
+
+    @Test
+    public void should_stubbing_be_treated_as_interaction() {
+        doReturn("foo").when(mock).simpleMethod();
+        mock.simpleMethod();
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void should_verify_stubbed_call() {
+        doReturn("foo").when(mock).simpleMethod();
+        mock.simpleMethod();
+        mock.simpleMethod();
+
+        verify(mock, times(2)).simpleMethod();
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void should_allow_stubbing_to_string() {
+        doReturn("test").when(mock).toString();
+        assertThat(mock.toString()).isEqualTo("test");
+    }
+
+    @Test
+    public void should_detect_invalid_return_type() {
+        try {
+            doReturn("foo").when(mock).booleanObjectReturningMethod();
+            fail();
+        } catch (Exception e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "String cannot be returned by booleanObjectReturningMethod()"
+                                    + "\n"
+                                    + "booleanObjectReturningMethod() should return Boolean");
+        }
+    }
+
+    @Test
+    public void should_detect_when_null_assigned_to_boolean() {
+        try {
+            doReturn(null).when(mock).intReturningMethod();
+            fail();
+        } catch (Exception e) {
+            assertThat(e).hasMessageContaining("null cannot be returned by intReturningMethod");
+        }
+    }
+
+    @Test
+    public void should_allow_stubbing_when_types_match_signature() {
+        doReturn("foo").when(mock).objectReturningMethodNoArgs();
+        doReturn("foo").when(mock).simpleMethod();
+        doReturn(1).when(mock).intReturningMethod();
+        doReturn(2).when(mock).intReturningMethod();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
new file mode 100644
index 0000000000..c2564f70e9
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+import static org.mockitoutil.TestBase.filterLineNo;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoSession;
+import org.mockito.StateMaster;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.framework.DefaultMockitoSession;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+
+public class StubbingWarningsTest {
+
+    private static final String TEST_NAME = "test.name";
+
+    @Mock IMethods mock;
+
+    SimpleMockitoLogger logger = new SimpleMockitoLogger();
+    MockitoSession mockito =
+            new DefaultMockitoSession(
+                    singletonList((Object) this), TEST_NAME, Strictness.WARN, logger);
+
+    @After
+    public void after() {
+        StateMaster stateMaster = new StateMaster();
+        stateMaster.reset();
+        stateMaster.clearMockitoListeners();
+    }
+
+    @Test
+    public void few_interactions() {
+        // when
+        mock.simpleMethod(100);
+        mock.otherMethod();
+
+        // expect no exception
+        mockito.finishMocking();
+        logger.assertEmpty();
+    }
+
+    @Test
+    public void stubbing_used() {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+        mock.simpleMethod(100);
+
+        // then
+        mockito.finishMocking();
+        logger.assertEmpty();
+    }
+
+    @Test
+    public void unused_stubbed_is_not_implicitly_verified() {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+        mock.simpleMethod(100); // <- stubbing is used
+        mock.simpleMethod(200); // <- other method should not generate arg mismatch
+
+        // then
+        mockito.finishMocking();
+        logger.assertEmpty();
+    }
+
+    @Test
+    public void stubbing_argument_mismatch() {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+        mock.simpleMethod(200);
+
+        mockito.finishMocking();
+
+        // TODO - currently we warn about "Unused" instead of "Arg mismatch" below
+        // because it was simpler to implement. This can be improved given we put priority to
+        // improve the warnings.
+        // then
+        assertEquals(
+                filterLineNo(
+                        "[MockitoHint] "
+                                + TEST_NAME
+                                + " (see javadoc for MockitoHint):\n"
+                                + "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.stubbing_argument_mismatch(StubbingWarningsTest.java:0)\n"),
+                filterLineNo(logger.getLoggedInfo()));
+    }
+
+    @Test
+    public void unused_stubbing() {
+        // when
+        given(mock.simpleMethod(100)).willReturn("100");
+
+        mockito.finishMocking();
+
+        // then
+        assertEquals(
+                filterLineNo(
+                        "[MockitoHint] "
+                                + TEST_NAME
+                                + " (see javadoc for MockitoHint):\n"
+                                + "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.unused_stubbing(StubbingWarningsTest.java:0)\n"),
+                filterLineNo(logger.getLoggedInfo()));
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void unfinished_verification_without_throwable() {
+        // when
+        verify(mock);
+
+        assertThatThrownBy(
+                        () -> {
+                            mockito.finishMocking();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Missing method call for verify(mock) here:",
+                        "-> at",
+                        "Example of correct verification:",
+                        "    verify(mock).doSomething()",
+                        "Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.",
+                        "Those methods *cannot* be stubbed/verified.",
+                        "Mocking methods declared on non-public parent classes is not supported.");
+    }
+
+    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
+    @Test
+    public void unfinished_verification_with_throwable() {
+        // when
+        verify(mock);
+
+        mockito.finishMocking(new AssertionError());
+
+        // then
+        logger.assertEmpty();
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
new file mode 100644
index 0000000000..2b96bdf0a9
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
@@ -0,0 +1,736 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.within;
+import static org.mockito.AdditionalAnswers.answer;
+import static org.mockito.AdditionalAnswers.answerVoid;
+import static org.mockito.AdditionalAnswers.answersWithDelay;
+import static org.mockito.AdditionalAnswers.returnsArgAt;
+import static org.mockito.AdditionalAnswers.returnsFirstArg;
+import static org.mockito.AdditionalAnswers.returnsLastArg;
+import static org.mockito.AdditionalAnswers.returnsSecondArg;
+import static org.mockito.BDDMockito.any;
+import static org.mockito.BDDMockito.anyInt;
+import static org.mockito.BDDMockito.anyString;
+import static org.mockito.BDDMockito.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.mock;
+import static org.mockito.BDDMockito.times;
+import static org.mockito.BDDMockito.verify;
+
+import java.util.Arrays;
+import java.util.Date;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.stubbing.Answer1;
+import org.mockito.stubbing.Answer2;
+import org.mockito.stubbing.Answer3;
+import org.mockito.stubbing.Answer4;
+import org.mockito.stubbing.Answer5;
+import org.mockito.stubbing.Answer6;
+import org.mockito.stubbing.VoidAnswer1;
+import org.mockito.stubbing.VoidAnswer2;
+import org.mockito.stubbing.VoidAnswer3;
+import org.mockito.stubbing.VoidAnswer4;
+import org.mockito.stubbing.VoidAnswer5;
+import org.mockito.stubbing.VoidAnswer6;
+import org.mockitousage.IMethods;
+
+@SuppressWarnings({"Convert2Lambda", "Anonymous2MethodRef", "RedundantThrows"})
+@RunWith(MockitoJUnitRunner.class)
+public class StubbingWithAdditionalAnswersTest {
+
+    @Mock IMethods iMethods;
+
+    @Test
+    public void can_return_arguments_of_invocation() throws Exception {
+        given(iMethods.objectArgMethod(any())).will(returnsFirstArg());
+        given(iMethods.threeArgumentMethod(eq(0), any(), anyString())).will(returnsSecondArg());
+        given(iMethods.threeArgumentMethod(eq(1), any(), anyString())).will(returnsLastArg());
+        given(iMethods.mixedVarargsReturningString(eq(1), any(String[].class)))
+                .will(returnsArgAt(2));
+
+        assertThat(iMethods.objectArgMethod("first")).isEqualTo("first");
+        assertThat(iMethods.threeArgumentMethod(0, "second", "whatever")).isEqualTo("second");
+        assertThat(iMethods.threeArgumentMethod(1, "whatever", "last")).isEqualTo("last");
+        assertThat(iMethods.mixedVarargsReturningString(1, "a", "b")).isEqualTo("b");
+    }
+
+    @Test
+    public void can_return_var_arguments_of_invocation() throws Exception {
+        given(iMethods.mixedVarargsReturningStringArray(eq(1), any(String[].class)))
+                .will(returnsLastArg());
+        given(iMethods.mixedVarargsReturningObjectArray(eq(1), any(String[].class)))
+                .will(returnsArgAt(1));
+
+        assertThat(iMethods.mixedVarargsReturningStringArray(1, "the", "var", "args"))
+                .containsExactlyInAnyOrder("the", "var", "args");
+        assertThat(iMethods.mixedVarargsReturningObjectArray(1, "the", "var", "args"))
+                .containsExactlyInAnyOrder("the", "var", "args");
+    }
+
+    @Test
+    public void returns_arg_at_throws_on_out_of_range_var_args() throws Exception {
+        given(iMethods.mixedVarargsReturningString(eq(1), any(String[].class)))
+                .will(returnsArgAt(3));
+
+        assertThatThrownBy(() -> iMethods.mixedVarargsReturningString(1, "a", "b"))
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Invalid argument index");
+    }
+
+    @Test
+    public void returns_arg_at_throws_on_out_of_range_array_var_args() throws Exception {
+        assertThatThrownBy(
+                        () ->
+                                given(iMethods.mixedVarargsReturningStringArray(eq(1), any()))
+                                        .will(returnsArgAt(3)))
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("The argument of type 'String' cannot be returned");
+    }
+
+    @Test
+    public void can_return_after_delay() throws Exception {
+        final long sleepyTime = 500L;
+
+        given(iMethods.objectArgMethod(any()))
+                .will(answersWithDelay(sleepyTime, returnsFirstArg()));
+
+        final Date before = new Date();
+        assertThat(iMethods.objectArgMethod("first")).isEqualTo("first");
+        final Date after = new Date();
+
+        final long timePassed = after.getTime() - before.getTime();
+        assertThat(timePassed).isCloseTo(sleepyTime, within(15L));
+    }
+
+    @Test
+    public void can_return_expanded_arguments_of_invocation() throws Exception {
+        given(iMethods.varargsObject(eq(1), any(Object[].class))).will(returnsArgAt(3));
+
+        assertThat(iMethods.varargsObject(1, "bob", "alexander", "alice", "carl"))
+                .isEqualTo("alice");
+    }
+
+    @Test
+    public void can_return_primitives_or_wrappers() throws Exception {
+        given(iMethods.toIntPrimitive(anyInt())).will(returnsFirstArg());
+        given(iMethods.toIntWrapper(anyInt())).will(returnsFirstArg());
+        given(iMethods.toIntWrapperVarArgs(anyInt(), any())).will(returnsFirstArg());
+
+        assertThat(iMethods.toIntPrimitive(1)).isEqualTo(1);
+        assertThat(iMethods.toIntWrapper(1)).isEqualTo(1);
+        assertThat(iMethods.toIntWrapperVarArgs(1, 10)).isEqualTo(1);
+    }
+
+    @Test
+    public void can_return_based_on_strongly_types_one_parameter_function() throws Exception {
+        given(iMethods.simpleMethod(anyString()))
+                .will(
+                        answer(
+                                new Answer1<String, String>() {
+                                    public String answer(String s) {
+                                        return s;
+                                    }
+                                }));
+
+        assertThat(iMethods.simpleMethod("string")).isEqualTo("string");
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_one_parameter_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.simpleMethod(anyString()))
+                .will(
+                        answerVoid(
+                                new VoidAnswer1<String>() {
+                                    public void answer(String s) {
+                                        target.simpleMethod(s);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.simpleMethod("string");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).simpleMethod("string");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_two_parameter_function() throws Exception {
+        given(iMethods.simpleMethod(anyString(), anyInt()))
+                .will(
+                        answer(
+                                new Answer2<String, String, Integer>() {
+                                    public String answer(String s, Integer i) {
+                                        return s + "-" + i;
+                                    }
+                                }));
+
+        assertThat(iMethods.simpleMethod("string", 1)).isEqualTo("string-1");
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_two_parameter_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.simpleMethod(anyString(), anyInt()))
+                .will(
+                        answerVoid(
+                                new VoidAnswer2<String, Integer>() {
+                                    public void answer(String s, Integer i) {
+                                        target.simpleMethod(s, i);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.simpleMethod("string", 1);
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).simpleMethod("string", 1);
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_three_parameter_function() throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(iMethods.threeArgumentMethodWithStrings(anyInt(), anyString(), anyString()))
+                .will(
+                        answer(
+                                new Answer3<String, Integer, String, String>() {
+                                    public String answer(Integer i, String s1, String s2) {
+                                        target.threeArgumentMethodWithStrings(i, s1, s2);
+                                        return "answered";
+                                    }
+                                }));
+
+        assertThat(iMethods.threeArgumentMethodWithStrings(1, "string1", "string2"))
+                .isEqualTo("answered");
+        verify(target, times(1)).threeArgumentMethodWithStrings(1, "string1", "string2");
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_three_parameter_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.threeArgumentMethodWithStrings(anyInt(), anyString(), anyString()))
+                .will(
+                        answerVoid(
+                                new VoidAnswer3<Integer, String, String>() {
+                                    public void answer(Integer i, String s1, String s2) {
+                                        target.threeArgumentMethodWithStrings(i, s1, s2);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.threeArgumentMethodWithStrings(1, "string1", "string2");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).threeArgumentMethodWithStrings(1, "string1", "string2");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_four_parameter_function() throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(iMethods.fourArgumentMethod(anyInt(), anyString(), anyString(), any(boolean[].class)))
+                .will(
+                        answer(
+                                new Answer4<String, Integer, String, String, boolean[]>() {
+                                    public String answer(
+                                            Integer i, String s1, String s2, boolean[] a) {
+                                        target.fourArgumentMethod(i, s1, s2, a);
+                                        return "answered";
+                                    }
+                                }));
+
+        boolean[] booleanArray = {true, false};
+        assertThat(iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray))
+                .isEqualTo("answered");
+        verify(target, times(1)).fourArgumentMethod(1, "string1", "string2", booleanArray);
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_four_parameter_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.fourArgumentMethod(anyInt(), anyString(), anyString(), any(boolean[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer4<Integer, String, String, boolean[]>() {
+                                    public void answer(
+                                            Integer i, String s1, String s2, boolean[] a) {
+                                        target.fourArgumentMethod(i, s1, s2, a);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        boolean[] booleanArray = {true, false};
+        iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray);
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).fourArgumentMethod(1, "string1", "string2", booleanArray);
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_five_parameter_function() throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt()))
+                .will(
+                        answer(
+                                new Answer5<String, String, Integer, Integer, Integer, Integer>() {
+                                    public String answer(
+                                            String s1,
+                                            Integer i1,
+                                            Integer i2,
+                                            Integer i3,
+                                            Integer i4) {
+                                        target.simpleMethod(s1, i1, i2, i3, i4);
+                                        return "answered";
+                                    }
+                                }));
+
+        assertThat(iMethods.simpleMethod("hello", 1, 2, 3, 4)).isEqualTo("answered");
+        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4);
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_five_parameter_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt()))
+                .will(
+                        answerVoid(
+                                new VoidAnswer5<String, Integer, Integer, Integer, Integer>() {
+                                    public void answer(
+                                            String s1,
+                                            Integer i1,
+                                            Integer i2,
+                                            Integer i3,
+                                            Integer i4) {
+                                        target.simpleMethod(s1, i1, i2, i3, i4);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.simpleMethod("hello", 1, 2, 3, 4);
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4);
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_six_parameter_function() throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt()))
+                .will(
+                        answer(
+                                new Answer6<
+                                        String,
+                                        String,
+                                        Integer,
+                                        Integer,
+                                        Integer,
+                                        Integer,
+                                        Integer>() {
+                                    public String answer(
+                                            String s1,
+                                            Integer i1,
+                                            Integer i2,
+                                            Integer i3,
+                                            Integer i4,
+                                            Integer i5) {
+                                        target.simpleMethod(s1, i1, i2, i3, i4, i5);
+                                        return "answered";
+                                    }
+                                }));
+
+        assertThat(iMethods.simpleMethod("hello", 1, 2, 3, 4, 5)).isEqualTo("answered");
+        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void will_execute_a_void_returning_strongly_typed_six_parameter_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt()))
+                .will(
+                        answerVoid(
+                                new VoidAnswer6<
+                                        String, Integer, Integer, Integer, Integer, Integer>() {
+                                    public void answer(
+                                            String s1,
+                                            Integer i1,
+                                            Integer i2,
+                                            Integer i3,
+                                            Integer i4,
+                                            Integer i5) {
+                                        target.simpleMethod(s1, i1, i2, i3, i4, i5);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.simpleMethod("hello", 1, 2, 3, 4, 5);
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void can_return_based_on_strongly_types_one_parameter_var_args_function()
+            throws Exception {
+        given(iMethods.varargs(any(String[].class)))
+                .will(
+                        answer(
+                                new Answer1<Integer, String[]>() {
+                                    public Integer answer(String[] strings) {
+                                        return strings.length;
+                                    }
+                                }));
+
+        assertThat(iMethods.varargs("some", "args")).isEqualTo(2);
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_one_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.varargs(any(String[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer1<String[]>() {
+                                    public void answer(String[] s) {
+                                        target.varargs(s);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.varargs("some", "args");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).varargs("some", "args");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_two_parameter_var_args_function()
+            throws Exception {
+        given(iMethods.mixedVarargsReturningString(any(), any(String[].class)))
+                .will(
+                        answer(
+                                new Answer2<String, Object, String[]>() {
+                                    public String answer(Object o, String[] s) {
+                                        return String.join("-", s);
+                                    }
+                                }));
+
+        assertThat(iMethods.mixedVarargsReturningString(1, "var", "args")).isEqualTo("var-args");
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_two_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.mixedVarargsReturningString(any(), any(String[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer2<Object, String[]>() {
+                                    public void answer(Object o, String[] s) {
+                                        target.mixedVarargsReturningString(o, s);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.mixedVarargsReturningString(1, "var", "args");
+
+        // expect the answer to write correctly to "target"
+        verify(target).mixedVarargsReturningString(1, "var", "args");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_three_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.threeArgumentVarArgsMethod(anyInt(), any(), any(String[].class)))
+                .will(
+                        answer(
+                                new Answer3<String, Integer, String, String[]>() {
+                                    public String answer(Integer i, String s1, String[] s2) {
+                                        target.threeArgumentVarArgsMethod(i, s1, s2);
+                                        return String.join("-", s2);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        assertThat(iMethods.threeArgumentVarArgsMethod(1, "string1", "var", "args"))
+                .isEqualTo("var-args");
+
+        // expect the answer to write correctly to "target"
+        verify(target).threeArgumentVarArgsMethod(1, "string1", "var", "args");
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_three_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.threeArgumentVarArgsMethod(anyInt(), any(), any(String[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer3<Integer, String, String[]>() {
+                                    public void answer(Integer i, String s1, String[] s2) {
+                                        target.threeArgumentVarArgsMethod(i, s1, s2);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.threeArgumentVarArgsMethod(1, "string1", "var", "args");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).threeArgumentVarArgsMethod(1, "string1", "var", "args");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_four_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(iMethods.fourArgumentVarArgsMethod(anyInt(), any(), anyInt(), any(String[].class)))
+                .will(
+                        answer(
+                                new Answer4<String, Integer, String, Integer, String[]>() {
+                                    public String answer(
+                                            Integer i1, String s2, Integer i3, String[] s4) {
+                                        target.fourArgumentVarArgsMethod(i1, s2, i3, s4);
+                                        return String.join("-", s4);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        String[] varargs = {"var", "args"};
+        assertThat(iMethods.fourArgumentVarArgsMethod(1, "string1", 3, varargs))
+                .isEqualTo("var-args");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).fourArgumentVarArgsMethod(1, "string1", 3, varargs);
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_four_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(iMethods.fourArgumentVarArgsMethod(anyInt(), any(), anyInt(), any(String[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer4<Integer, String, Integer, String[]>() {
+                                    public void answer(
+                                            Integer i, String s2, Integer i3, String[] s4) {
+                                        target.fourArgumentVarArgsMethod(i, s2, i3, s4);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.fourArgumentVarArgsMethod(1, "string1", 3, "var", "args");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1)).fourArgumentVarArgsMethod(1, "string1", 3, "var", "args");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_five_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(
+                        iMethods.fiveArgumentVarArgsMethod(
+                                anyInt(), any(), anyInt(), any(), any(String[].class)))
+                .will(
+                        answer(
+                                new Answer5<String, Integer, String, Integer, String, String[]>() {
+                                    public String answer(
+                                            Integer i1,
+                                            String s2,
+                                            Integer i3,
+                                            String s4,
+                                            String[] s5) {
+                                        target.fiveArgumentVarArgsMethod(i1, s2, i3, s4, s5);
+                                        return String.join("-", s5);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        assertThat(iMethods.fiveArgumentVarArgsMethod(1, "two", 3, "four", "var", "args"))
+                .isEqualTo("var-args");
+
+        // expect the answer to write correctly to "target"
+        verify(target).fiveArgumentVarArgsMethod(1, "two", 3, "four", "var", "args");
+    }
+
+    @Test
+    public void will_execute_a_void_based_on_strongly_typed_five_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+
+        given(
+                        iMethods.fiveArgumentVarArgsMethod(
+                                anyInt(), any(), anyInt(), any(), any(String[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer5<Integer, String, Integer, String, String[]>() {
+                                    public void answer(
+                                            Integer i1,
+                                            String s2,
+                                            Integer i3,
+                                            String s4,
+                                            String[] s5) {
+                                        target.fiveArgumentVarArgsMethod(i1, s2, i3, s4, s5);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.fiveArgumentVarArgsMethod(1, "two", 3, "four", "var", "args");
+
+        // expect the answer to write correctly to "target"
+        verify(target).fiveArgumentVarArgsMethod(1, "two", 3, "four", "var", "args");
+    }
+
+    @Test
+    public void can_return_based_on_strongly_typed_six_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(
+                        iMethods.sixArgumentVarArgsMethod(
+                                anyInt(), any(), anyInt(), any(), any(), any(String[].class)))
+                .will(
+                        answer(
+                                new Answer6<
+                                        String,
+                                        Integer,
+                                        String,
+                                        Integer,
+                                        String,
+                                        String,
+                                        String[]>() {
+                                    public String answer(
+                                            Integer i1,
+                                            String s2,
+                                            Integer i3,
+                                            String s4,
+                                            String s5,
+                                            String[] s6) {
+                                        target.sixArgumentVarArgsMethod(i1, s2, i3, s4, s5, s6);
+                                        return "answered";
+                                    }
+                                }));
+
+        // invoke on iMethods
+        assertThat(iMethods.sixArgumentVarArgsMethod(1, "two", 3, "four", "five", "var", "args"))
+                .isEqualTo("answered");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1))
+                .sixArgumentVarArgsMethod(1, "two", 3, "four", "five", "var", "args");
+    }
+
+    @Test
+    public void will_execute_a_void_returning_strongly_typed_six_parameter_var_args_function()
+            throws Exception {
+        final IMethods target = mock(IMethods.class);
+        given(
+                        iMethods.sixArgumentVarArgsMethod(
+                                anyInt(), any(), anyInt(), any(), any(), any(String[].class)))
+                .will(
+                        answerVoid(
+                                new VoidAnswer6<
+                                        Integer, String, Integer, String, String, String[]>() {
+                                    public void answer(
+                                            Integer i1,
+                                            String s2,
+                                            Integer i3,
+                                            String s4,
+                                            String s5,
+                                            String[] s6) {
+                                        target.sixArgumentVarArgsMethod(i1, s2, i3, s4, s5, s6);
+                                    }
+                                }));
+
+        // invoke on iMethods
+        iMethods.sixArgumentVarArgsMethod(1, "two", 3, "four", "five", "var", "args");
+
+        // expect the answer to write correctly to "target"
+        verify(target, times(1))
+                .sixArgumentVarArgsMethod(1, "two", 3, "four", "five", "var", "args");
+    }
+
+    @Test
+    public void can_accept_array_supertype_for_strongly_typed_var_args_function() throws Exception {
+        given(iMethods.varargs(any(String[].class)))
+                .will(
+                        answer(
+                                new Answer1<Integer, Object[]>() {
+                                    public Integer answer(Object[] s) {
+                                        return s.length;
+                                    }
+                                }));
+
+        assertThat(iMethods.varargs("var", "args")).isEqualTo(2);
+    }
+
+    @Test
+    public void can_accept_non_vararg_answer_on_var_args_function() throws Exception {
+        given(iMethods.varargs(any(String[].class)))
+                .will(
+                        answer(
+                                new Answer2<Integer, String, String>() {
+                                    public Integer answer(String s1, String s2) {
+                                        return s1.length() + s2.length();
+                                    }
+                                }));
+
+        assertThat(iMethods.varargs("var", "args")).isEqualTo(7);
+    }
+
+    @Test
+    public void should_work_with_var_args_with_no_elements() throws Exception {
+        given(iMethods.varargs(any(String[].class)))
+                .will(
+                        answer(
+                                new Answer1<Integer, String[]>() {
+                                    public Integer answer(String[] s) {
+                                        return s.length;
+                                    }
+                                }));
+
+        assertThat(iMethods.varargs()).isEqualTo(0);
+    }
+
+    @Test
+    public void should_work_with_array_var_args() throws Exception {
+        given(iMethods.arrayVarargsMethod(any(String[][].class)))
+                .will(
+                        answer(
+                                new Answer1<Integer, String[][]>() {
+                                    public Integer answer(String[][] s) {
+                                        return Arrays.stream(s).mapToInt(e -> e.length).sum();
+                                    }
+                                }));
+
+        String[][] varArgs = {{}, {""}, {"", ""}};
+        assertThat(iMethods.arrayVarargsMethod(varArgs)).isEqualTo(3);
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java
new file mode 100644
index 0000000000..43824bf680
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.mockito.Mockito.doThrow;
+
+import java.util.List;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockitoutil.TestBase;
+
+// issue 1514
+@SuppressWarnings({"serial", "unchecked", "rawtypes"})
+public class StubbingWithBadThrowablesTest extends TestBase {
+
+    @Mock List mock;
+
+    @Test
+    public void handles_bad_exception() {
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                doThrow(UninstantiableException.class).when(mock).clear();
+                            }
+                        })
+                .isInstanceOf(
+                        InstantiationError.class); // because the exception cannot be instantiated
+
+        // ensure that the state is cleaned
+        Mockito.validateMockitoUsage();
+    }
+
+    abstract static class UninstantiableException extends RuntimeException {}
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
new file mode 100644
index 0000000000..dada3d5710
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class StubbingWithCustomAnswerTest extends TestBase {
+    @Mock private IMethods mock;
+
+    @Test
+    public void shouldAnswer() throws Exception {
+        when(mock.simpleMethod(anyString()))
+                .thenAnswer(
+                        new Answer<String>() {
+                            public String answer(InvocationOnMock invocation) throws Throwable {
+                                String arg = invocation.getArgument(0);
+
+                                return invocation.getMethod().getName() + "-" + arg;
+                            }
+                        });
+
+        assertEquals("simpleMethod-test", mock.simpleMethod("test"));
+    }
+
+    @Test
+    public void shouldAnswerWithThenAnswerAlias() throws Exception {
+        RecordCall recordCall = new RecordCall();
+        Set<?> mockedSet = (Set<?>) when(mock(Set.class).isEmpty()).then(recordCall).getMock();
+
+        boolean unused = mockedSet.isEmpty();
+
+        assertTrue(recordCall.isCalled());
+    }
+
+    @Test
+    public void shouldAnswerConsecutively() throws Exception {
+        when(mock.simpleMethod())
+                .thenAnswer(
+                        new Answer<String>() {
+                            public String answer(InvocationOnMock invocation) throws Throwable {
+                                return invocation.getMethod().getName();
+                            }
+                        })
+                .thenReturn("Hello")
+                .thenAnswer(
+                        new Answer<String>() {
+                            public String answer(InvocationOnMock invocation) throws Throwable {
+                                return invocation.getMethod().getName() + "-1";
+                            }
+                        });
+
+        assertEquals("simpleMethod", mock.simpleMethod());
+        assertEquals("Hello", mock.simpleMethod());
+        assertEquals("simpleMethod-1", mock.simpleMethod());
+        assertEquals("simpleMethod-1", mock.simpleMethod());
+    }
+
+    @Test
+    public void shouldAnswerVoidMethod() throws Exception {
+        RecordCall recordCall = new RecordCall();
+
+        doAnswer(recordCall).when(mock).voidMethod();
+
+        mock.voidMethod();
+        assertTrue(recordCall.isCalled());
+    }
+
+    @Test
+    public void shouldAnswerVoidMethodConsecutively() throws Exception {
+        RecordCall call1 = new RecordCall();
+        RecordCall call2 = new RecordCall();
+
+        doAnswer(call1)
+                .doThrow(new UnsupportedOperationException())
+                .doAnswer(call2)
+                .when(mock)
+                .voidMethod();
+
+        mock.voidMethod();
+        assertTrue(call1.isCalled());
+        assertFalse(call2.isCalled());
+
+        try {
+            mock.voidMethod();
+            fail();
+        } catch (UnsupportedOperationException e) {
+        }
+
+        mock.voidMethod();
+        assertTrue(call2.isCalled());
+    }
+
+    @Test
+    public void shouldMakeSureTheInterfaceDoesNotChange() throws Exception {
+        when(mock.simpleMethod(anyString()))
+                .thenAnswer(
+                        new Answer<String>() {
+                            public String answer(InvocationOnMock invocation) throws Throwable {
+                                assertTrue(invocation.getArguments().getClass().isArray());
+                                assertEquals(
+                                        IMethods.class, invocation.getMethod().getDeclaringClass());
+
+                                return "assertions passed";
+                            }
+                        });
+
+        assertEquals("assertions passed", mock.simpleMethod("test"));
+    }
+
+    private static class RecordCall implements Answer<Object> {
+        private boolean called = false;
+
+        public boolean isCalled() {
+            return called;
+        }
+
+        public Object answer(InvocationOnMock invocation) throws Throwable {
+            called = true;
+            return null;
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
similarity index 82%
rename from src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
index d89be348ca..245fa788ee 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
@@ -97,15 +97,10 @@ public void delegate_should_not_be_called_when_stubbed2() {
     }
 
     @Test
-    public void null_wrapper_dont_throw_exception_from_org_mockito_package() throws Exception {
+    public void null_wrapper_dont_throw_exception_from_org_mockito_package() {
         IMethods methods = mock(IMethods.class, delegatesTo(new MethodsImpl()));
 
-        try {
-            byte b = methods.byteObjectReturningMethod(); // real method returns null
-            fail();
-        } catch (Exception e) {
-            assertThat(e.toString()).doesNotContain("org.mockito");
-        }
+        assertThat(methods.byteObjectReturningMethod()).isNull();
     }
 
     @Test
@@ -144,7 +139,9 @@ public void calling_method_with_wrong_primitive_return_should_throw_exception()
             mock.size();
             fail();
         } catch (MockitoException e) {
-            assertThat(e.toString()).contains("Methods called on delegated instance must have compatible return type");
+            assertThat(e.toString())
+                    .contains(
+                            "Methods called on delegated instance must have compatible return type");
         }
     }
 
@@ -156,19 +153,25 @@ public void calling_method_with_wrong_reference_return_should_throw_exception()
             mock.subList(0, 0);
             fail();
         } catch (MockitoException e) {
-            assertThat(e.toString()).contains("Methods called on delegated instance must have compatible return type");
+            assertThat(e.toString())
+                    .contains(
+                            "Methods called on delegated instance must have compatible return type");
         }
     }
 
     @Test
     public void exception_should_be_propagated_from_delegate() throws Exception {
         final RuntimeException failure = new RuntimeException("angry-method");
-        IMethods methods = mock(IMethods.class, delegatesTo(new MethodsImpl() {
-            @Override
-            public String simpleMethod() {
-                throw failure;
-            }
-        }));
+        IMethods methods =
+                mock(
+                        IMethods.class,
+                        delegatesTo(
+                                new MethodsImpl() {
+                                    @Override
+                                    public String simpleMethod() {
+                                        throw failure;
+                                    }
+                                }));
 
         try {
             methods.simpleMethod(); // delegate throws an exception
@@ -184,18 +187,19 @@ interface Foo {
 
     @Test
     public void should_call_anonymous_class_method() throws Throwable {
-        Foo foo = new Foo() {
-            public int bar() {
-                return 0;
-            }
-        };
+        Foo foo =
+                new Foo() {
+                    public int bar() {
+                        return 0;
+                    }
+                };
 
         Foo mock = mock(Foo.class);
         when(mock.bar()).thenAnswer(AdditionalAnswers.delegatesTo(foo));
 
-        //when
+        // when
         mock.bar();
 
-        //then no exception is thrown
+        // then no exception is thrown
     }
 }
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
similarity index 79%
rename from src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
index a5a83b163d..5bd3f33c0b 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
@@ -23,28 +23,24 @@ private static final class FooImpl implements Foo {
         public int bar(String baz, Object... args) {
             return args != null ? args.length : -1; // simple return argument count
         }
-
     }
 
     @Test
     public void should_not_fail_when_calling_varargs_method() {
-        Foo foo = mock(Foo.class, withSettings()
-                .defaultAnswer(delegatesTo(new FooImpl())));
+        Foo foo = mock(Foo.class, withSettings().defaultAnswer(delegatesTo(new FooImpl())));
         assertThat(foo.bar("baz", 12, "45", 67.8)).isEqualTo(3);
     }
 
     @Test
     public void should_not_fail_when_calling_varargs_method_without_arguments() {
-        Foo foo = mock(Foo.class, withSettings()
-                .defaultAnswer(delegatesTo(new FooImpl())));
+        Foo foo = mock(Foo.class, withSettings().defaultAnswer(delegatesTo(new FooImpl())));
         assertThat(foo.bar("baz")).isEqualTo(0);
         assertThat(foo.bar("baz", new Object[0])).isEqualTo(0);
     }
 
     @Test
     public void should_not_fail_when_calling_varargs_method_with_null_argument() {
-        Foo foo = mock(Foo.class, withSettings()
-                .defaultAnswer(delegatesTo(new FooImpl())));
+        Foo foo = mock(Foo.class, withSettings().defaultAnswer(delegatesTo(new FooImpl())));
         assertThat(foo.bar("baz", (Object[]) null)).isEqualTo(-1);
     }
 }
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
similarity index 77%
rename from src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
rename to mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
index 9818542368..b7f1cec527 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
@@ -25,26 +25,28 @@ public class StubbingWithExtraAnswersTest extends TestBase {
 
     @Test
     public void shouldWorkAsStandardMockito() throws Exception {
-        //when
+        // when
         List<Integer> list = asList(1, 2, 3);
-        when(mock.objectReturningMethodNoArgs()).thenAnswer(AdditionalAnswers.returnsElementsOf(list));
+        when(mock.objectReturningMethodNoArgs())
+                .thenAnswer(AdditionalAnswers.returnsElementsOf(list));
 
-        //then
+        // then
         assertEquals(1, mock.objectReturningMethodNoArgs());
         assertEquals(2, mock.objectReturningMethodNoArgs());
         assertEquals(3, mock.objectReturningMethodNoArgs());
-        //last element is returned continuously
+        // last element is returned continuously
         assertEquals(3, mock.objectReturningMethodNoArgs());
         assertEquals(3, mock.objectReturningMethodNoArgs());
     }
 
     @Test
     public void shouldReturnNullIfNecessary() throws Exception {
-        //when
+        // when
         List<Integer> list = asList(1, null);
-        when(mock.objectReturningMethodNoArgs()).thenAnswer(AdditionalAnswers.returnsElementsOf(list));
+        when(mock.objectReturningMethodNoArgs())
+                .thenAnswer(AdditionalAnswers.returnsElementsOf(list));
 
-        //then
+        // then
         assertEquals(1, mock.objectReturningMethodNoArgs());
         assertEquals(null, mock.objectReturningMethodNoArgs());
         assertEquals(null, mock.objectReturningMethodNoArgs());
@@ -53,10 +55,11 @@ public void shouldReturnNullIfNecessary() throws Exception {
     @Test
     public void shouldScreamWhenNullPassed() throws Exception {
         try {
-            //when
+            // when
             AdditionalAnswers.returnsElementsOf(null);
-            //then
+            // then
             fail();
-        } catch (MockitoException e) {}
+        } catch (MockitoException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
new file mode 100644
index 0000000000..efc3e8f33a
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings({"serial", "unchecked", "rawtypes"})
+public class StubbingWithThrowablesTest extends TestBase {
+
+    private LinkedList mock;
+
+    private Map mockTwo;
+
+    @Before
+    public void setup() {
+        mock = mock(LinkedList.class);
+        mockTwo = mock(HashMap.class);
+    }
+
+    @Test
+    public void throws_same_exception_consecutively() {
+        when(mock.add("")).thenThrow(new ExceptionOne());
+
+        // 1st invocation
+        assertThatThrownBy(
+                        () -> {
+                            mock.add("");
+                        })
+                .isInstanceOf(ExceptionOne.class);
+
+        mock.add("1");
+
+        // 2nd invocation
+        assertThatThrownBy(
+                        () -> {
+                            mock.add("");
+                        })
+                .isInstanceOf(ExceptionOne.class);
+    }
+
+    @Test
+    public void throws_same_exception_consecutively_with_doThrow() {
+        doThrow(new ExceptionOne()).when(mock).clear();
+
+        // 1st invocation
+        assertThatThrownBy(
+                        () -> {
+                            mock.clear();
+                        })
+                .isInstanceOf(ExceptionOne.class);
+
+        mock.add("1");
+
+        // 2nd invocation
+        assertThatThrownBy(
+                        () -> {
+                            mock.clear();
+                        })
+                .isInstanceOf(ExceptionOne.class);
+    }
+
+    @Test
+    public void throws_new_exception_consecutively_from_class() {
+        when(mock.add(null)).thenThrow(NaughtyException.class);
+
+        NaughtyException first =
+                Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+        NaughtyException second =
+                Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+
+        assertNotSame(first, second);
+    }
+
+    @Test
+    public void throws_new_exception_consecutively_from_class_with_doThrow() {
+        doThrow(NaughtyException.class).when(mock).add(null);
+
+        NaughtyException first =
+                Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+        NaughtyException second =
+                Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+
+        assertNotSame(first, second);
+    }
+
+    @Test
+    public void shouldStubWithThrowable() {
+        IllegalArgumentException expected = new IllegalArgumentException("thrown by mock");
+        when(mock.add("throw")).thenThrow(expected);
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.add("throw");
+                        })
+                .isEqualTo(expected);
+    }
+
+    @Test
+    public void shouldSetThrowableToVoidMethod() {
+        IllegalArgumentException expected = new IllegalArgumentException("thrown by mock");
+
+        doThrow(expected).when(mock).clear();
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.clear();
+                        })
+                .isEqualTo(expected);
+    }
+
+    @Test
+    public void shouldLastStubbingVoidBeImportant() {
+        doThrow(new ExceptionOne()).when(mock).clear();
+        doThrow(new ExceptionTwo()).when(mock).clear();
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.clear();
+                        })
+                .isInstanceOf(ExceptionTwo.class);
+    }
+
+    @Test
+    public void shouldFailStubbingThrowableOnTheSameInvocationDueToAcceptableLimitation() {
+        when(mock.size()).thenThrow(new ExceptionOne());
+
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.size()).thenThrow(new ExceptionTwo());
+                        })
+                .isInstanceOf(ExceptionOne.class);
+    }
+
+    @Test
+    public void shouldAllowSettingCheckedException() throws Exception {
+        Reader reader = mock(Reader.class);
+        IOException ioException = new IOException();
+
+        when(reader.read()).thenThrow(ioException);
+
+        assertThatThrownBy(
+                        () -> {
+                            reader.read();
+                        })
+                .isEqualTo(ioException);
+    }
+
+    @Test
+    public void shouldAllowSettingError() {
+        Error error = new Error();
+
+        when(mock.add("quake")).thenThrow(error);
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.add("quake");
+                        })
+                .isEqualTo(error);
+    }
+
+    @Test
+    public void shouldNotAllowNullExceptionType() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.add(null)).thenThrow((Exception) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Cannot stub with null throwable");
+    }
+
+    @Test
+    public void shouldInstantiateExceptionClassOnInteraction() {
+        when(mock.add(null)).thenThrow(NaughtyException.class);
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.add(null);
+                        })
+                .isInstanceOf(NaughtyException.class);
+    }
+
+    @Test
+    public void shouldInstantiateExceptionClassWithOngoingStubbingOnInteraction() {
+        doThrow(NaughtyException.class).when(mock).add(null);
+
+        assertThatThrownBy(
+                        () -> {
+                            mock.add(null);
+                        })
+                .isInstanceOf(NaughtyException.class);
+    }
+
+    @Test
+    public void shouldNotAllowSettingInvalidCheckedException() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.add("monkey island")).thenThrow(new Exception());
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Checked exception is invalid for this method");
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullThrowable() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.add("monkey island")).thenThrow((Throwable) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Cannot stub with null throwable");
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullThrowableArray() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.add("monkey island")).thenThrow((Throwable[]) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Cannot stub with null throwable");
+    }
+
+    private void assertExceptionTypeCanNotBeNull(ThrowingCallable throwingCallable) {
+        assertThatThrownBy(throwingCallable)
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Exception type cannot be null");
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullThrowableClass() {
+        assertExceptionTypeCanNotBeNull(
+                () -> {
+                    when(mock.isEmpty()).thenThrow((Class) null);
+                });
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullThrowableClasses() {
+        assertExceptionTypeCanNotBeNull(
+                () -> {
+                    when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class[]) null);
+                });
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullVarArgThrowableClass() {
+        assertExceptionTypeCanNotBeNull(
+                () -> {
+                    when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class) null);
+                });
+    }
+
+    @Test
+    public void doThrowShouldNotAllowSettingNullThrowableClass() {
+        assertThatThrownBy(
+                        () -> {
+                            doThrow((Class) null).when(mock).isEmpty();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Exception type cannot be null");
+    }
+
+    @Test
+    public void doThrowShouldNotAllowSettingNullThrowableClasses() {
+        assertThatThrownBy(
+                        () -> {
+                            doThrow(RuntimeException.class, (Class) null).when(mock).isEmpty();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Exception type cannot be null");
+    }
+
+    @Test
+    public void doThrowShouldNotAllowSettingNullVarArgThrowableClasses() {
+        assertThatThrownBy(
+                        () -> {
+                            doThrow(RuntimeException.class, (Class[]) null).when(mock).isEmpty();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Exception type cannot be null");
+    }
+
+    @Test
+    public void shouldNotAllowSettingNullVarArgsThrowableClasses() {
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.isEmpty())
+                                    .thenThrow(
+                                            RuntimeException.class,
+                                            (Class<RuntimeException>[]) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Exception type cannot be null");
+    }
+
+    @Test
+    public void shouldNotAllowDifferentCheckedException() {
+        IMethods mock = mock(IMethods.class);
+
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.throwsIOException(0)).thenThrow(CheckedException.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Checked exception is invalid for this method");
+    }
+
+    @Test
+    public void shouldNotAllowCheckedExceptionWhenErrorIsDeclared() {
+        IMethods mock = mock(IMethods.class);
+
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.throwsError(0)).thenThrow(CheckedException.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Checked exception is invalid for this method");
+    }
+
+    @Test
+    public void shouldNotAllowCheckedExceptionWhenNothingIsDeclared() {
+        IMethods mock = mock(IMethods.class);
+
+        assertThatThrownBy(
+                        () -> {
+                            when(mock.throwsNothing(true)).thenThrow(CheckedException.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Checked exception is invalid for this method");
+    }
+
+    @Test
+    public void shouldMixThrowablesAndReturnsOnDifferentMocks() {
+        when(mock.add("ExceptionOne")).thenThrow(new ExceptionOne());
+        when(mock.getLast()).thenReturn("last");
+        doThrow(new ExceptionTwo()).when(mock).clear();
+
+        doThrow(new ExceptionThree()).when(mockTwo).clear();
+        when(mockTwo.containsValue("ExceptionFour")).thenThrow(new ExceptionFour());
+        when(mockTwo.get("Are you there?")).thenReturn("Yes!");
+
+        assertNull(mockTwo.get("foo"));
+        assertTrue(mockTwo.keySet().isEmpty());
+        assertEquals("Yes!", mockTwo.get("Are you there?"));
+        try {
+            mockTwo.clear();
+            fail();
+        } catch (ExceptionThree e) {
+        }
+        try {
+            mockTwo.containsValue("ExceptionFour");
+            fail();
+        } catch (ExceptionFour e) {
+        }
+
+        assertNull(mock.getFirst());
+        assertEquals("last", mock.getLast());
+        try {
+            mock.add("ExceptionOne");
+            fail();
+        } catch (ExceptionOne e) {
+        }
+        try {
+            mock.clear();
+            fail();
+        } catch (ExceptionTwo e) {
+        }
+    }
+
+    @Test
+    public void shouldStubbingWithThrowableBeVerifiable() {
+        when(mock.size()).thenThrow(new RuntimeException());
+        doThrow(new RuntimeException()).when(mock).clone();
+
+        try {
+            mock.size();
+            fail();
+        } catch (RuntimeException e) {
+        }
+
+        try {
+            mock.clone();
+            fail();
+        } catch (RuntimeException e) {
+        }
+
+        verify(mock).size();
+        verify(mock).clone();
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void shouldStubbingWithThrowableFailVerification() {
+        when(mock.size()).thenThrow(new RuntimeException());
+        doThrow(new RuntimeException()).when(mock).clone();
+
+        verifyNoInteractions(mock);
+
+        mock.add("test");
+
+        try {
+            verify(mock).size();
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+
+        try {
+            verify(mock).clone();
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    private class ExceptionOne extends RuntimeException {}
+
+    private class ExceptionTwo extends RuntimeException {}
+
+    private class ExceptionThree extends RuntimeException {}
+
+    private class ExceptionFour extends RuntimeException {}
+
+    private class CheckedException extends Exception {}
+
+    public class NaughtyException extends RuntimeException {
+        public NaughtyException() {
+            throw new RuntimeException("boo!");
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
similarity index 87%
rename from src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
index e84ee21248..8a3f6b1fc3 100644
--- a/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
@@ -20,12 +20,12 @@ public class AtLeastXVerificationTest extends TestBase {
 
     @Test
     public void shouldVerifyAtLeastXTimes() throws Exception {
-        //when
+        // when
         mock.clear();
         mock.clear();
         mock.clear();
 
-        //then
+        // then
         verify(mock, atLeast(2)).clear();
     }
 
@@ -37,16 +37,18 @@ public void shouldFailVerificationAtLeastXTimes() throws Exception {
         try {
             verify(mock, atLeast(2)).add(anyString());
             fail();
-        } catch (MockitoAssertionError e) {}
+        } catch (MockitoAssertionError e) {
+        }
     }
 
     @Test
-    public void shouldAllowAtLeastZeroForTheSakeOfVerifyNoMoreInteractionsSometimes() throws Exception {
-        //when
+    public void shouldAllowAtLeastZeroForTheSakeOfVerifyNoMoreInteractionsSometimes()
+            throws Exception {
+        // when
         mock.add("one");
         mock.clear();
 
-        //then
+        // then
         verify(mock, atLeast(0)).add("one");
         verify(mock, atLeast(0)).clear();
 
diff --git a/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
similarity index 88%
rename from src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
index 7ef39fe081..f6c08ac8bd 100644
--- a/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
@@ -22,6 +22,7 @@
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.verification.MoreThanAllowedActualInvocations;
 import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.verification.VerificationMode;
 import org.mockitoutil.TestBase;
 
 public class AtMostXVerificationTest extends TestBase {
@@ -39,7 +40,8 @@ public void shouldVerifyAtMostXTimes() throws Exception {
         try {
             verify(mock, atMostOnce()).clear();
             fail();
-        } catch (MoreThanAllowedActualInvocations e) {}
+        } catch (MoreThanAllowedActualInvocations e) {
+        }
     }
 
     @Test
@@ -50,7 +52,8 @@ public void shouldWorkWithArgumentMatchers() throws Exception {
         try {
             verify(mock, atMost(0)).add(anyString());
             fail();
-        } catch (MoreThanAllowedActualInvocations e) {}
+        } catch (MoreThanAllowedActualInvocations e) {
+        }
     }
 
     @Test
@@ -108,11 +111,18 @@ public void shouldDetectUnverifiedInMarkInteractionsAsVerified() throws Exceptio
         try {
             verifyNoMoreInteractions(mock);
             fail();
-        } catch(NoInteractionsWanted e) {
+        } catch (NoInteractionsWanted e) {
             assertThat(e).hasMessageContaining("undesiredInteraction(");
         }
     }
 
+    @Test
+    public void should_return_formatted_output_from_toString_method() {
+        VerificationMode atMost = atMost(3);
+
+        assertThat(atMost).hasToString("Wanted invocations count: at most 3");
+    }
+
     private void undesiredInteraction() {
         mock.add("");
     }
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
new file mode 100644
index 0000000000..80d02e32a9
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class BasicVerificationInOrderTest extends TestBase {
+
+    private IMethods mockOne;
+    private IMethods mockTwo;
+    private IMethods mockThree;
+    private InOrder inOrder;
+
+    @Before
+    public void setUp() {
+        mockOne = mock(IMethods.class);
+        mockTwo = mock(IMethods.class);
+        mockThree = mock(IMethods.class);
+
+        inOrder = inOrder(mockOne, mockTwo, mockThree);
+
+        mockOne.simpleMethod(1);
+        mockTwo.simpleMethod(2);
+        mockTwo.simpleMethod(2);
+        mockThree.simpleMethod(3);
+        mockTwo.simpleMethod(2);
+        mockOne.simpleMethod(4);
+    }
+
+    @Test
+    public void shouldVerifyInOrder() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldVerifyInOrderUsingAtLeastOnce() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(4);
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldVerifyInOrderWhenExpectingSomeInvocationsToBeCalledZeroTimes() {
+        inOrder.verify(mockOne, times(0)).oneArg(false);
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockTwo, times(0)).simpleMethod(22);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+        inOrder.verify(mockThree, times(0)).oneArg(false);
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldFailWhenFirstMockCalledTwice() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        try {
+            inOrder.verify(mockOne).simpleMethod(1);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailWhenLastMockCalledTwice() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+        try {
+            inOrder.verify(mockOne).simpleMethod(4);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnFirstMethodBecauseOneInvocationWanted() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockOne, times(0)).simpleMethod(1);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure:",
+                        "iMethods.simpleMethod(1);",
+                        "Wanted 0 times:",
+                        "-> at ",
+                        "But was 1 time:",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldFailOnFirstMethodBecauseOneInvocationWantedAgain() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockOne, times(2)).simpleMethod(1);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure:",
+                        "iMethods.simpleMethod(1);",
+                        "Wanted 2 times:",
+                        "-> at ",
+                        "But was 1 time:",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldFailOnSecondMethodBecauseFourInvocationsWanted() {
+        inOrder.verify(mockOne, times(1)).simpleMethod(1);
+        try {
+            inOrder.verify(mockTwo, times(4)).simpleMethod(2);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnSecondMethodBecauseTwoInvocationsWantedAgain() {
+        inOrder.verify(mockOne, times(1)).simpleMethod(1);
+        try {
+            inOrder.verify(mockTwo, times(0)).simpleMethod(2);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnLastMethodBecauseOneInvocationWanted() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree, atLeastOnce()).simpleMethod(3);
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        try {
+            inOrder.verify(mockOne, times(0)).simpleMethod(4);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnLastMethodBecauseOneInvocationWantedAgain() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree, atLeastOnce()).simpleMethod(3);
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        try {
+            inOrder.verify(mockOne, times(2)).simpleMethod(4);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    /* ------------- */
+
+    @Test
+    public void shouldFailOnFirstMethodBecauseDifferentArgsWanted() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockOne).simpleMethod(100);
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class)
+                .hasMessageContainingAll(
+                        "Argument(s) are different! Wanted:",
+                        "iMethods.simpleMethod(100);",
+                        "-> at ",
+                        "Actual invocations have different arguments:",
+                        "iMethods.simpleMethod(1);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(3);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(4);",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldFailOnFirstMethodBecauseDifferentMethodWanted() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockOne).oneArg(true);
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll(
+                        "Wanted but not invoked:",
+                        "iMethods.oneArg(true);",
+                        "-> at ",
+                        "However, there were exactly 6 interactions with this mock:",
+                        "iMethods.simpleMethod(1);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(3);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(4);",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldFailOnSecondMethodBecauseDifferentArgsWanted() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        try {
+            inOrder.verify(mockTwo, times(2)).simpleMethod(-999);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnSecondMethodBecauseDifferentMethodWanted() {
+        inOrder.verify(mockOne, times(1)).simpleMethod(1);
+        try {
+            inOrder.verify(mockTwo, times(2)).oneArg(true);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnLastMethodBecauseDifferentArgsWanted() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        try {
+            inOrder.verify(mockOne).simpleMethod(-666);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnLastMethodBecauseDifferentMethodWanted() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        try {
+            inOrder.verify(mockOne).oneArg(false);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    /* -------------- */
+
+    @Test
+    public void shouldFailWhenLastMethodVerifiedFirst() {
+        inOrder.verify(mockOne).simpleMethod(4);
+        try {
+            inOrder.verify(mockOne).simpleMethod(1);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailWhenMiddleMethodVerifiedFirst() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        try {
+            inOrder.verify(mockOne).simpleMethod(1);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailWhenMiddleMethodVerifiedFirstInAtLeastOnceMode() {
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        try {
+            inOrder.verify(mockOne).simpleMethod(1);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnVerifyNoMoreInteractions() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+
+        try {
+            verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnVerifyNoInteractions() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoInteractions(mockOne);
+                        })
+                .isInstanceOf(NoInteractionsWanted.class)
+                .hasMessageContainingAll(
+                        "No interactions wanted here:",
+                        "-> at ",
+                        "But found these interactions on mock 'iMethods':",
+                        "-> at ",
+                        "-> at ",
+                        "***",
+                        "For your reference, here is the list of all invocations ([?] - means unverified).",
+                        "1. [?]-> at ",
+                        "2. [?]-> at ");
+    }
+
+    @SuppressWarnings({"all", "CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldScreamWhenNullPassed() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder((Object[]) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Method requires argument(s)!",
+                        "Pass mocks that require verification in order.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne, mockTwo);");
+    }
+
+    @Test
+    public void shouldThrowNullPassedToVerifyException() {
+        try {
+            inOrder.verify(null);
+            fail();
+        } catch (NullInsteadOfMockException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "Argument passed to verify() should be a mock but is null!");
+        }
+    }
+
+    @Test
+    public void shouldThrowNotAMockPassedToVerifyException() {
+        Object object = new Object();
+        try {
+            inOrder.verify(object);
+            fail();
+        } catch (NotAMockException e) {
+            assertThat(e)
+                    .hasMessageContaining(
+                            "Argument passed to verify() is of type Object and is not a mock!");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/BasicVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
new file mode 100644
index 0000000000..70df2b178b
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
+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.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class BasicVerificationTest extends TestBase {
+
+    @Mock private List<String> mock;
+    @Mock private List<String> mockTwo;
+
+    @Test
+    public void shouldVerify() {
+        mock.clear();
+        verify(mock).clear();
+
+        mock.add("test");
+        verify(mock).add("test");
+
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void shouldFailVerification() {
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).clear();
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll(
+                        "Wanted but not invoked:",
+                        "mock.clear();",
+                        "-> at ",
+                        "Actually, there were zero interactions with this mock.");
+    }
+
+    @Test
+    public void shouldFailVerificationOnMethodArgument() {
+        mock.clear();
+        mock.add("foo");
+
+        verify(mock).clear();
+
+        assertThatThrownBy(
+                        () -> {
+                            verify(mock).add("bar");
+                        })
+                .isInstanceOf(ArgumentsAreDifferent.class);
+    }
+
+    @Test
+    public void shouldFailOnWrongMethod() {
+        mock.clear();
+        mock.clear();
+
+        mockTwo.add("add");
+
+        verify(mock, atLeastOnce()).clear();
+        verify(mockTwo, atLeastOnce()).add("add");
+        try {
+            verify(mockTwo, atLeastOnce()).add("foo");
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+    }
+
+    @Test
+    public void shouldDetectRedundantInvocation() {
+        mock.clear();
+        mock.add("foo");
+        mock.add("bar");
+
+        verify(mock).clear();
+        verify(mock).add("foo");
+
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldDetectWhenInvokedMoreThanOnce() {
+        mock.add("foo");
+        mock.clear();
+        mock.clear();
+
+        verify(mock).add("foo");
+
+        try {
+            verify(mock).clear();
+            fail();
+        } catch (TooManyActualInvocations e) {
+        }
+    }
+
+    @Test
+    public void shouldVerifyStubbedMethods() {
+        when(mock.add("test")).thenReturn(Boolean.FALSE);
+
+        mock.add("test");
+
+        verify(mock).add("test");
+    }
+
+    @Test
+    public void shouldDetectWhenOverloadedMethodCalled() {
+        IMethods mockThree = mock(IMethods.class);
+
+        mockThree.varargs((Object[]) new Object[] {});
+        try {
+            verify(mockThree).varargs((String[]) new String[] {});
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
new file mode 100644
index 0000000000..9e5ffebc50
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class DescriptiveMessagesOnVerificationInOrderErrorsTest extends TestBase {
+
+    private IMethods one;
+    private IMethods two;
+    private IMethods three;
+    private InOrder inOrder;
+
+    @Before
+    public void setup() {
+        one = Mockito.mock(IMethods.class);
+        two = Mockito.mock(IMethods.class);
+        three = Mockito.mock(IMethods.class);
+
+        one.simpleMethod(1);
+        one.simpleMethod(11);
+        two.simpleMethod(2);
+        two.simpleMethod(2);
+        three.simpleMethod(3);
+
+        inOrder = inOrder(one, two, three);
+    }
+
+    @Test
+    public void shouldPrintVerificationInOrderErrorAndShowBothWantedAndPrevious() {
+        inOrder.verify(one).simpleMethod(1);
+        inOrder.verify(two, atLeastOnce()).simpleMethod(2);
+
+        try {
+            inOrder.verify(one, atLeastOnce()).simpleMethod(11);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+            String expected =
+                    "\n"
+                            + "Verification in order failure"
+                            + "\n"
+                            + "Wanted but not invoked:"
+                            + "\n"
+                            + "iMethods.simpleMethod(11);"
+                            + "\n"
+                            + "-> at ";
+
+            assertThat(e).hasMessageContaining(expected);
+
+            String expectedCause =
+                    "\n"
+                            + "Wanted anywhere AFTER following interaction:"
+                            + "\n"
+                            + "iMethods.simpleMethod(2);"
+                            + "\n"
+                            + "-> at ";
+
+            assertThat(e).hasMessageContaining(expectedCause);
+        }
+    }
+
+    @Test
+    public void shouldPrintVerificationInOrderErrorAndShowWantedOnly() {
+        try {
+            inOrder.verify(one).differentMethod();
+            fail();
+        } catch (WantedButNotInvoked e) {
+            String expected =
+                    "\n"
+                            + "Wanted but not invoked:"
+                            + "\n"
+                            + "iMethods.differentMethod();"
+                            + "\n"
+                            + "-> at";
+
+            assertThat(e).hasMessageContaining(expected);
+        }
+    }
+
+    @Test
+    public void shouldPrintVerificationInOrderErrorAndShowWantedAndActual() {
+        try {
+            inOrder.verify(one).simpleMethod(999);
+            fail();
+        } catch (org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent e) {
+            assertThat(e).hasMessageContaining("have different arguments");
+        }
+    }
+
+    @Test
+    public void shouldNotSayArgumentsAreDifferent() {
+        // this is the last invocation so any next verification in order should simply say wanted
+        // but not invoked
+        inOrder.verify(three).simpleMethod(3);
+        try {
+            inOrder.verify(one).simpleMethod(999);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+            assertThat(e).hasMessageContaining("Wanted but not invoked");
+        }
+    }
+
+    @Test
+    public void shouldPrintMethodThatWasNotInvoked() {
+        inOrder.verify(one).simpleMethod(1);
+        inOrder.verify(one).simpleMethod(11);
+        inOrder.verify(two, times(2)).simpleMethod(2);
+        inOrder.verify(three).simpleMethod(3);
+        try {
+            inOrder.verify(three).simpleMethod(999);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+            String expectedMessage =
+                    "\n"
+                            + "Verification in order failure"
+                            + "\n"
+                            + "Wanted but not invoked:"
+                            + "\n"
+                            + "iMethods.simpleMethod(999);";
+            assertThat(e).hasMessageContaining(expectedMessage);
+        }
+    }
+
+    @Test
+    public void shouldPrintTooManyInvocations() {
+        inOrder.verify(one).simpleMethod(1);
+        inOrder.verify(one).simpleMethod(11);
+        try {
+            inOrder.verify(two, times(1)).simpleMethod(2);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+            String expectedMessage =
+                    "\n"
+                            + "Verification in order failure:"
+                            + "\n"
+                            + "iMethods.simpleMethod(2);"
+                            + "\n"
+                            + "Wanted 1 time:"
+                            + "\n"
+                            + "-> at";
+            assertThat(e).hasMessageContaining(expectedMessage);
+
+            String expectedCause = "\n" + "But was 2 times:" + "\n" + "-> at";
+            assertThat(e).hasMessageContaining(expectedCause);
+        }
+    }
+
+    @Test
+    public void shouldPrintTooFewInvocations() {
+        two.simpleMethod(2);
+
+        inOrder.verify(one, atLeastOnce()).simpleMethod(anyInt());
+        inOrder.verify(two, times(2)).simpleMethod(2);
+        inOrder.verify(three, atLeastOnce()).simpleMethod(3);
+
+        try {
+            inOrder.verify(two, times(2)).simpleMethod(2);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+            String expectedMessage =
+                    "\n"
+                            + "Verification in order failure:"
+                            + "\n"
+                            + "iMethods.simpleMethod(2);"
+                            + "\n"
+                            + "Wanted 2 times:"
+                            + "\n"
+                            + "-> at";
+            assertThat(e).hasMessageContaining(expectedMessage);
+
+            String expectedCause = "\n" + "But was 1 time:" + "\n" + "-> at";
+
+            assertThat(e).hasMessageContaining(expectedCause);
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
similarity index 81%
rename from src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
index 98217d346f..7ad4627789 100644
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
@@ -34,9 +34,9 @@ public void shouldVerifyActualNumberOfInvocationsSmallerThanWanted() throws Exce
             fail();
         } catch (TooFewActualInvocations e) {
             assertThat(e)
-                .hasMessageContaining("mock.clear();")
-                .hasMessageContaining("Wanted 100 times")
-                .hasMessageContaining("was 3");
+                    .hasMessageContaining("mock.clear();")
+                    .hasMessageContaining("Wanted 100 times")
+                    .hasMessageContaining("was 3");
         }
     }
 
@@ -53,9 +53,9 @@ public void shouldVerifyActualNumberOfInvocationsLargerThanWanted() throws Excep
             fail();
         } catch (TooManyActualInvocations e) {
             assertThat(e)
-                .hasMessageContaining("mock.clear();")
-                .hasMessageContaining("Wanted 1 time")
-                .hasMessageContaining("was 4");
+                    .hasMessageContaining("mock.clear();")
+                    .hasMessageContaining("Wanted 1 time")
+                    .hasMessageContaining("was 4");
         }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
new file mode 100644
index 0000000000..a1a29c1aad
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
@@ -0,0 +1,552 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalMatchers.aryEq;
+import static org.mockito.Mockito.*;
+
+import java.sql.Date;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.NeverWantedButInvoked;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class DescriptiveMessagesWhenVerificationFailsTest extends TestBase {
+
+    private IMethods mock;
+
+    @Before
+    public void setup() {
+        mock = Mockito.mock(IMethods.class, "iMethods");
+    }
+
+    @Test
+    public void should_print_method_name() {
+        try {
+            verify(mock).simpleMethod();
+            fail();
+        } catch (WantedButNotInvoked e) {
+            String expectedMessage =
+                    "\n"
+                            + "Wanted but not invoked:"
+                            + "\n"
+                            + "iMethods.simpleMethod();"
+                            + "\n"
+                            + "-> at";
+            assertThat(e).hasMessageContaining(expectedMessage);
+        }
+    }
+
+    private class Foo {
+        public String toString() {
+            return "foo";
+        }
+    }
+
+    @Test
+    public void should_print_method_name_and_arguments() {
+        try {
+            verify(mock).threeArgumentMethod(12, new Foo(), "xx");
+            fail();
+        } catch (WantedButNotInvoked e) {
+            assertThat(e).hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")");
+        }
+    }
+
+    @Test
+    public void should_print_actual_and_wanted_in_line() {
+        mock.varargs(1, 2);
+
+        try {
+            verify(mock).varargs(1, 1000);
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            String wanted =
+                    "\n"
+                            + "Argument(s) are different! Wanted:"
+                            + "\n"
+                            + "iMethods.varargs(1, 1000);";
+
+            assertThat(e).hasMessageContaining(wanted);
+
+            String actual =
+                    "\n"
+                            + "Actual invocations have different arguments at position [1]:"
+                            + "\n"
+                            + "iMethods.varargs(1, 2);";
+
+            assertThat(e).hasMessageContaining(actual);
+        }
+    }
+
+    @Test
+    public void should_print_actual_and_wanted_in_multiple_lines() {
+        mock.varargs("this is very long string", "this is another very long string");
+
+        try {
+            verify(mock).varargs("x", "y", "z");
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            String wanted =
+                    "\n"
+                            + "Argument(s) are different! Wanted:"
+                            + "\n"
+                            + "iMethods.varargs("
+                            + "\n"
+                            + "    \"x\","
+                            + "\n"
+                            + "    \"y\","
+                            + "\n"
+                            + "    \"z\""
+                            + "\n"
+                            + ");";
+
+            assertThat(e).hasMessageContaining(wanted);
+
+            String actual =
+                    "\n"
+                            + "Actual invocations have different arguments:"
+                            + "\n"
+                            + "iMethods.varargs("
+                            + "\n"
+                            + "    \"this is very long string\","
+                            + "\n"
+                            + "    \"this is another very long string\""
+                            + "\n"
+                            + ");";
+
+            assertThat(e).hasMessageContaining(actual);
+        }
+    }
+
+    @Test
+    public void
+            should_print_actual_and_wanted_when_actual_method_name_and_wanted_method_name_are_the_same() {
+        mock.simpleMethod();
+
+        try {
+            verify(mock).simpleMethod(10);
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e)
+                    .hasMessageContaining("simpleMethod(10)")
+                    .hasMessageContaining("simpleMethod()");
+        }
+    }
+
+    @Test
+    public void should_print_actual_and_unverified_wanted_when_the_difference_is_about_arguments() {
+        mock.twoArgumentMethod(1, 1);
+        mock.twoArgumentMethod(2, 2);
+
+        verify(mock).twoArgumentMethod(1, 1);
+        try {
+            verify(mock).twoArgumentMethod(2, 1000);
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e).hasMessageContaining("(2, 1000)").hasMessageContaining("(2, 2)");
+        }
+    }
+
+    @Test
+    public void should_print_first_unexpected_invocation() {
+        mock.oneArg(true);
+        mock.oneArg(false);
+        mock.threeArgumentMethod(1, "2", "3");
+
+        verify(mock).oneArg(true);
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+            String expectedMessage = "\n" + "No interactions wanted here:" + "\n" + "-> at";
+            assertThat(e).hasMessageContaining(expectedMessage);
+
+            String expectedCause =
+                    "\n" + "But found this interaction on mock '" + mock + "':" + "\n" + "-> at";
+            assertThat(e).hasMessageContaining(expectedCause);
+        }
+    }
+
+    @Test
+    public void should_print_first_unexpected_invocation_when_verifying_no_interactions() {
+        mock.twoArgumentMethod(1, 2);
+        mock.threeArgumentMethod(1, "2", "3");
+
+        try {
+            verifyNoInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+            String expected = "\n" + "No interactions wanted here:" + "\n" + "-> at";
+
+            assertThat(e).hasMessageContaining(expected);
+
+            String expectedCause =
+                    "\n" + "But found these interactions on mock '" + mock + "':" + "\n" + "-> at";
+
+            assertThat(e).hasMessageContaining(expectedCause);
+        }
+    }
+
+    @Test
+    public void should_print_method_name_when_verifying_at_least_once() throws Exception {
+        try {
+            verify(mock, atLeastOnce()).twoArgumentMethod(1, 2);
+            fail();
+        } catch (WantedButNotInvoked e) {
+            assertThat(e).hasMessageContaining("twoArgumentMethod(1, 2)");
+        }
+    }
+
+    @Test
+    public void should_print_method_when_matcher_used() throws Exception {
+        try {
+            verify(mock, atLeastOnce()).twoArgumentMethod(anyInt(), eq(100));
+            fail();
+        } catch (WantedButNotInvoked e) {
+            String expectedMessage =
+                    "\n"
+                            + "Wanted but not invoked:"
+                            + "\n"
+                            + "iMethods.twoArgumentMethod(\n"
+                            + "    <any integer>,\n"
+                            + "    100\n"
+                            + ");";
+            assertThat(e).hasMessageContaining(expectedMessage);
+        }
+    }
+
+    @Test
+    public void should_print_method_when_missing_invocation_with_array_matcher() {
+        mock.oneArray(new boolean[] {true, false, false});
+
+        try {
+            verify(mock).oneArray(aryEq(new boolean[] {false, false, false}));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e)
+                    .hasMessageContaining("[false, false, false]")
+                    .hasMessageContaining("[true, false, false]");
+        }
+    }
+
+    @Test
+    public void should_print_method_when_missing_invocation_with_vararg_matcher() {
+        mock.varargsString(10, "xxx", "yyy", "zzz");
+
+        try {
+            verify(mock).varargsString(10, "111", "222", "333");
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e).hasMessageContaining("111").hasMessageContaining("\"xxx\"");
+        }
+    }
+
+    @Test
+    public void should_print_method_when_missing_invocation_with_matcher() {
+        mock.simpleMethod("foo");
+
+        try {
+            verify(mock).simpleMethod(matches("burrito from Exmouth"));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e)
+                    .hasMessageContaining("matches(\"burrito from Exmouth\")")
+                    .hasMessageContaining("\"foo\"");
+        }
+    }
+
+    @Test
+    public void should_print_null_arguments() throws Exception {
+        mock.simpleMethod(null, (Integer) null);
+        try {
+            verify(mock).simpleMethod("test");
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e).hasMessageContaining("simpleMethod(null, null);");
+        }
+    }
+
+    @Test
+    public void should_say_never_wanted_but_invoked() throws Exception {
+        mock.simpleMethod(1);
+
+        verify(mock, never()).simpleMethod(2);
+        try {
+            verify(mock, never()).simpleMethod(1);
+            fail();
+        } catch (NeverWantedButInvoked e) {
+            assertThat(e)
+                    .hasMessageContaining("Never wanted here:")
+                    .hasMessageContaining("But invoked here:");
+        }
+    }
+
+    @Test
+    public void should_show_right_actual_method() throws Exception {
+        mock.simpleMethod(9191);
+        mock.simpleMethod("foo");
+
+        try {
+            verify(mock).simpleMethod("bar");
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e).hasMessageContaining("bar").hasMessageContaining("foo");
+        }
+    }
+
+    @Mock private IMethods iHavefunkyName;
+
+    @Test
+    public void should_print_field_name_when_annotations_used() throws Exception {
+        iHavefunkyName.simpleMethod(10);
+
+        try {
+            verify(iHavefunkyName).simpleMethod(20);
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            assertThat(e)
+                    .hasMessageContaining("iHavefunkyName.simpleMethod(20)")
+                    .hasMessageContaining("iHavefunkyName.simpleMethod(10)");
+        }
+    }
+
+    @Test
+    public void should_print_interactions_on_mock_when_ordinary_verification_fail()
+            throws Exception {
+        mock.otherMethod();
+        mock.booleanReturningMethod();
+
+        try {
+            verify(mock).simpleMethod();
+            fail();
+        } catch (WantedButNotInvoked e) {
+            //            assertContains("")
+        }
+    }
+
+    @Mock private IMethods veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock;
+
+    @Test
+    public void should_never_break_method_string_when_no_args_in_method() throws Exception {
+        try {
+            verify(veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock).simpleMethod();
+            fail();
+        } catch (WantedButNotInvoked e) {
+            assertThat(e)
+                    .hasMessageContaining("veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock.simpleMethod()");
+        }
+    }
+
+    @Test
+    public void
+            should_print_method_name_and_arguments_of_other_interactions_with_different_methods()
+                    throws Exception {
+        try {
+            mock.arrayMethod(new String[] {"a", "b", "c"});
+            mock.forByte((byte) 25);
+
+            verify(mock).threeArgumentMethod(12, new Foo(), "xx");
+            fail();
+        } catch (WantedButNotInvoked e) {
+            assertThat(e)
+                    .hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")")
+                    .hasMessageContaining("iMethods.arrayMethod([\"a\", \"b\", \"c\"])")
+                    .hasMessageContaining("iMethods.forByte((byte) 0x19)");
+        }
+    }
+
+    @Test
+    public void should_print_fully_qualified_name_when_arguments_classes_have_same_simple_name() {
+        Date dateArg = new Date(0);
+        String stringifiedDateArg = dateArg.toString();
+
+        try {
+            mock.overloadedMethodWithSameClassNameArguments(dateArg, new IMethods.Date(0));
+            verify(mock).overloadedMethodWithSameClassNameArguments(new IMethods.Date(0), dateArg);
+            fail();
+        } catch (Throwable e) {
+            String wanted =
+                    String.format(
+                            "\n"
+                                    + "Argument(s) are different! Wanted:"
+                                    + "\n"
+                                    + "iMethods.overloadedMethodWithSameClassNameArguments("
+                                    + "\n"
+                                    + "    (org.mockitousage.IMethods.Date) 0,"
+                                    + "\n"
+                                    + "    (java.sql.Date) %s"
+                                    + "\n"
+                                    + ");",
+                            stringifiedDateArg);
+
+            assertThat(e).hasMessageContaining(wanted);
+
+            String actual =
+                    String.format(
+                            "\n"
+                                    + "Actual invocations have different arguments at positions [0, 1]:"
+                                    + "\n"
+                                    + "iMethods.overloadedMethodWithSameClassNameArguments("
+                                    + "\n"
+                                    + "    (java.sql.Date) %s,"
+                                    + "\n"
+                                    + "    (org.mockitousage.IMethods.Date) 0"
+                                    + "\n"
+                                    + ");",
+                            stringifiedDateArg);
+            assertThat(e).hasMessageContaining(actual);
+        }
+    }
+
+    @Test
+    public void
+            should_not_print_fully_qualified_name_when_arguments_classes_have_different_simple_name() {
+        try {
+            mock.overloadedMethodWithDifferentClassNameArguments("string", 0);
+            verify(mock).overloadedMethodWithDifferentClassNameArguments(0, "string");
+            fail();
+        } catch (Throwable e) {
+            String wanted =
+                    "\n"
+                            + "Argument(s) are different! Wanted:"
+                            + "\n"
+                            + "iMethods.overloadedMethodWithDifferentClassNameArguments("
+                            + "\n"
+                            + "    0,"
+                            + "\n"
+                            + "    \"string\""
+                            + "\n"
+                            + ");";
+
+            assertThat(e).hasMessageContaining(wanted);
+
+            String actual =
+                    "\n"
+                            + "Actual invocations have different arguments at positions [0, 1]:"
+                            + "\n"
+                            + "iMethods.overloadedMethodWithDifferentClassNameArguments("
+                            + "\n"
+                            + "    \"string\","
+                            + "\n"
+                            + "    0"
+                            + "\n"
+                            + ");";
+            assertThat(e).hasMessageContaining(actual);
+        }
+    }
+
+    @Test
+    public void
+            should_print_fully_qualified_name_when_some_arguments_classes_have_same_simple_name() {
+        Date dateArg = new Date(0);
+        String stringifiedDateArg = dateArg.toString();
+
+        try {
+            mock.overloadedMethodWithSameClassNameArguments(
+                    dateArg, "string", new IMethods.Date(0));
+            verify(mock)
+                    .overloadedMethodWithSameClassNameArguments(
+                            new IMethods.Date(0), "string", dateArg);
+            fail();
+        } catch (Throwable e) {
+            String wanted =
+                    String.format(
+                            "\n"
+                                    + "Argument(s) are different! Wanted:"
+                                    + "\n"
+                                    + "iMethods.overloadedMethodWithSameClassNameArguments("
+                                    + "\n"
+                                    + "    (org.mockitousage.IMethods.Date) 0,"
+                                    + "\n"
+                                    + "    \"string\","
+                                    + "\n"
+                                    + "    (java.sql.Date) %s"
+                                    + "\n"
+                                    + ");",
+                            stringifiedDateArg);
+
+            assertThat(e).hasMessageContaining(wanted);
+
+            String actual =
+                    String.format(
+                            "\n"
+                                    + "Actual invocations have different arguments at positions [0, 2]:"
+                                    + "\n"
+                                    + "iMethods.overloadedMethodWithSameClassNameArguments("
+                                    + "\n"
+                                    + "    (java.sql.Date) %s,"
+                                    + "\n"
+                                    + "    \"string\","
+                                    + "\n"
+                                    + "    (org.mockitousage.IMethods.Date) 0"
+                                    + "\n"
+                                    + ");",
+                            stringifiedDateArg);
+            assertThat(e).hasMessageContaining(actual);
+        }
+    }
+
+    @Test
+    @Ignore("issue 380 related")
+    public void should_print_method_name_and_arguments_of_other_interactions_of_same_method()
+            throws Exception {
+        try {
+            mock.forByte((byte) 25);
+            mock.forByte((byte) 12);
+
+            verify(mock).forByte((byte) 42);
+            fail();
+        } catch (WantedButNotInvoked e) {
+            assertThat(e)
+                    .hasMessageContaining("iMethods.forByte(42)")
+                    .hasMessageContaining("iMethods.forByte(25)")
+                    .hasMessageContaining("iMethods.forByte(12)");
+        }
+    }
+
+    @Test
+    @Ignore("issue 380 related")
+    public void test1() {
+        AnInterface m = Mockito.mock(AnInterface.class);
+
+        for (int i = 1; i <= 2; i++) {
+            m.foo(i);
+        }
+
+        verify(m).foo(1);
+        verify(m).foo(2);
+        verify(m).foo(3); // XXX: doesn't mention the parameters of foo(1) and foo(2)
+        verify(m).foo(4);
+    }
+
+    @Test
+    @Ignore("issue 380 related")
+    public void test2() {
+        AnInterface m = Mockito.mock(AnInterface.class);
+
+        for (int i = 1; i <= 4; i++) {
+            m.foo(i);
+        }
+
+        verify(m).foo(1);
+        verify(m).foo(2);
+        verify(m).foo(5); // XXX: doesn't mention foo(4) at all
+    }
+
+    public interface AnInterface {
+        void foo(int i);
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java
similarity index 88%
rename from src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java
index 3cf4027e85..a3500b4012 100644
--- a/src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java
@@ -36,9 +36,7 @@ public void shouldDetectTooFewActualInvocations() throws Exception {
             verify(mock, times(100)).clear();
             fail();
         } catch (TooFewActualInvocations e) {
-            assertThat(e)
-                .hasMessageContaining("Wanted 100 times")
-                .hasMessageContaining("was 2");
+            assertThat(e).hasMessageContaining("Wanted 100 times").hasMessageContaining("was 2");
         }
     }
 
@@ -52,9 +50,7 @@ public void shouldDetectTooManyActualInvocations() throws Exception {
             verify(mock, times(1)).clear();
             fail();
         } catch (TooManyActualInvocations e) {
-            assertThat(e)
-                .hasMessageContaining("Wanted 1 time")
-                .hasMessageContaining("was 2 times");
+            assertThat(e).hasMessageContaining("Wanted 1 time").hasMessageContaining("was 2 times");
         }
     }
 
@@ -64,7 +60,8 @@ public void shouldDetectActualInvocationsCountIsMoreThanZero() throws Exception
         try {
             verify(mock, times(15)).clear();
             fail();
-        } catch (WantedButNotInvoked e) {}
+        } catch (WantedButNotInvoked e) {
+        }
     }
 
     @Test
@@ -106,7 +103,8 @@ public void shouldAllowVerifyingInteractionNeverHappened() throws Exception {
         try {
             verify(mock, never()).add("one");
             fail();
-        } catch (NeverWantedButInvoked e) {}
+        } catch (NeverWantedButInvoked e) {
+        }
     }
 
     @Test
@@ -123,6 +121,7 @@ public void shouldAllowVerifyingInteractionNeverHappenedInOrder() throws Excepti
         try {
             inOrder.verify(mock, never()).add("two");
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 }
diff --git a/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
similarity index 86%
rename from src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
index 6fcf7d26c5..104f410f85 100644
--- a/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/FindingRedundantInvocationsInOrderTest.java
@@ -24,36 +24,36 @@ public class FindingRedundantInvocationsInOrderTest extends TestBase {
 
     @Test
     public void shouldWorkFineIfNoInvocations() throws Exception {
-        //when
+        // when
         InOrder inOrder = inOrder(mock);
 
-        //then
+        // then
         inOrder.verifyNoMoreInteractions();
     }
 
     @Test
     public void shouldSayNoInteractionsWanted() throws Exception {
-        //when
+        // when
         mock.simpleMethod();
 
-        //then
+        // then
         InOrder inOrder = inOrder(mock);
         try {
             inOrder.verifyNoMoreInteractions();
             fail();
-        } catch(VerificationInOrderFailure e) {
+        } catch (VerificationInOrderFailure e) {
             assertThat(e).hasMessageContaining("No interactions wanted");
         }
     }
 
     @Test
     public void shouldVerifyNoMoreInteractionsInOrder() throws Exception {
-        //when
+        // when
         mock.simpleMethod();
         mock.simpleMethod(10);
         mock.otherMethod();
 
-        //then
+        // then
         InOrder inOrder = inOrder(mock);
         inOrder.verify(mock).simpleMethod(10);
         inOrder.verify(mock).otherMethod();
@@ -62,12 +62,12 @@ public void shouldVerifyNoMoreInteractionsInOrder() throws Exception {
 
     @Test
     public void shouldVerifyNoMoreInteractionsInOrderWithMultipleMocks() throws Exception {
-        //when
+        // when
         mock.simpleMethod();
         mock2.simpleMethod();
         mock.otherMethod();
 
-        //then
+        // then
         InOrder inOrder = inOrder(mock, mock2);
         inOrder.verify(mock2).simpleMethod();
         inOrder.verify(mock).otherMethod();
@@ -76,47 +76,50 @@ public void shouldVerifyNoMoreInteractionsInOrderWithMultipleMocks() throws Exce
 
     @Test
     public void shouldFailToVerifyNoMoreInteractionsInOrder() throws Exception {
-        //when
+        // when
         mock.simpleMethod();
         mock.simpleMethod(10);
         mock.otherMethod();
 
-        //then
+        // then
         InOrder inOrder = inOrder(mock);
         inOrder.verify(mock).simpleMethod(10);
         try {
             inOrder.verifyNoMoreInteractions();
             fail();
-        } catch(VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
     public void shouldFailToVerifyNoMoreInteractionsInOrderWithMultipleMocks() throws Exception {
-        //when
+        // when
         mock.simpleMethod();
         mock2.simpleMethod();
         mock.otherMethod();
 
-        //then
+        // then
         InOrder inOrder = inOrder(mock, mock2);
         inOrder.verify(mock2).simpleMethod();
         try {
             inOrder.verifyNoMoreInteractions();
             fail();
-        } catch(VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
     @Test
     public void shouldValidateState() throws Exception {
-        //when
+        // when
         InOrder inOrder = inOrder(mock);
         verify(mock); // mess up state
 
-        //then
+        // then
         try {
             inOrder.verifyNoMoreInteractions();
             fail();
-        } catch(UnfinishedVerificationException e) {}
+        } catch (UnfinishedVerificationException e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
new file mode 100644
index 0000000000..38ad1dff68
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class NoMoreInteractionsVerificationTest extends TestBase {
+
+    private LinkedList mock;
+
+    @Before
+    public void setup() {
+        mock = mock(LinkedList.class);
+    }
+
+    @Test
+    public void shouldStubbingNotRegisterRedundantInteractions() {
+        when(mock.add("one")).thenReturn(true);
+        when(mock.add("two")).thenReturn(true);
+
+        mock.add("one");
+
+        verify(mock).add("one");
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void shouldVerifyWhenWantedNumberOfInvocationsUsed() {
+        mock.add("one");
+        mock.add("one");
+        mock.add("one");
+
+        verify(mock, times(3)).add("one");
+
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void shouldFailNoMoreInteractionsVerification() {
+        mock.clear();
+
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldFailNoInteractionsVerification() {
+        mock.clear();
+
+        try {
+            verifyNoInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldPrintAllInvocationsWhenVerifyingNoMoreInvocations() {
+        mock.add(1);
+        mock.add(2);
+        mock.clear();
+
+        verify(mock).add(2);
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+            assertThat(e).hasMessageContaining("list of all invocations");
+        }
+    }
+
+    @Test
+    public void shouldNotContainAllInvocationsWhenSingleUnwantedFound() {
+        mock.add(1);
+
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+            assertThat(e.getMessage()).doesNotContain("list of all invocations");
+        }
+    }
+
+    @Test
+    public void shouldVerifyOneMockButFailOnOther() {
+        List<String> list = mock(List.class);
+        Map<String, Integer> map = mock(Map.class);
+
+        list.add("one");
+        list.add("one");
+
+        map.put("one", 1);
+
+        verify(list, times(2)).add("one");
+
+        verifyNoMoreInteractions(list);
+        try {
+            verifyNoInteractions(map);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldVerifyOneMockButFailOnOtherVerifyNoInteractions() {
+        List<String> list = mock(List.class);
+        Map<String, Integer> map = mock(Map.class);
+
+        list.add("one");
+        list.add("one");
+
+        map.put("one", 1);
+
+        verify(list, times(2)).add("one");
+
+        verifyNoMoreInteractions(list);
+        try {
+            verifyNoInteractions(map);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    // @SuppressWarnings("all")
+    @Test
+    public void verifyNoMoreInteractionsShouldScreamWhenNullPassed() {
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions((Object[]) null);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Method requires argument(s)!",
+                        "Pass mocks that should be verified, e.g:",
+                        "    verifyNoMoreInteractions(mockOne, mockTwo);",
+                        "    verifyNoInteractions(mockOne, mockTwo);");
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/OnlyVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/OnlyVerificationTest.java
similarity index 76%
rename from src/test/java/org/mockitousage/verification/OnlyVerificationTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/OnlyVerificationTest.java
index 7385008279..94eafe612c 100644
--- a/src/test/java/org/mockitousage/verification/OnlyVerificationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/OnlyVerificationTest.java
@@ -4,8 +4,9 @@
  */
 package org.mockitousage.verification;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.only;
 import static org.mockito.Mockito.verify;
 
@@ -15,6 +16,7 @@
 import org.mockito.Mock;
 import org.mockito.exceptions.verification.NoInteractionsWanted;
 import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.verification.VerificationMode;
 import org.mockitoutil.TestBase;
 
 public class OnlyVerificationTest extends TestBase {
@@ -41,7 +43,8 @@ public void shouldFailIfMethodWasNotInvoked() {
         try {
             verify(mock, only()).get(0);
             fail();
-        } catch (WantedButNotInvoked e) {}
+        } catch (WantedButNotInvoked e) {
+        }
     }
 
     @Test
@@ -51,7 +54,8 @@ public void shouldFailIfMethodWasInvokedMoreThanOnce() {
         try {
             verify(mock, only()).clear();
             fail();
-        } catch (NoInteractionsWanted e) {}
+        } catch (NoInteractionsWanted e) {
+        }
     }
 
     @Test
@@ -61,7 +65,8 @@ public void shouldFailIfMethodWasInvokedButWithDifferentArguments() {
         try {
             verify(mock, only()).get(999);
             fail();
-        } catch (WantedButNotInvoked e) {}
+        } catch (WantedButNotInvoked e) {
+        }
     }
 
     @Test
@@ -71,7 +76,8 @@ public void shouldFailIfExtraMethodWithDifferentArgsFound() {
         try {
             verify(mock, only()).get(2);
             fail();
-        } catch (NoInteractionsWanted e) {}
+        } catch (NoInteractionsWanted e) {
+        }
     }
 
     @Test
@@ -82,4 +88,10 @@ public void shouldVerifyMethodWasInvokedExclusivelyWhenTwoMocksInUse() {
         verify(mock2, only()).get(0);
     }
 
+    @Test
+    public void should_return_formatted_output_from_toString_method() {
+        VerificationMode only = only();
+
+        assertThat(only).hasToString("Wanted invocations count: 1 and no other method invoked");
+    }
 }
diff --git a/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java
similarity index 77%
rename from src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java
index 6f912989af..0bf65fa6b6 100644
--- a/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java
@@ -21,21 +21,22 @@ public class OrdinaryVerificationPrintsAllInteractionsTest extends TestBase {
 
     @Test
     public void shouldShowAllInteractionsOnMockWhenOrdinaryVerificationFail() throws Exception {
-        //given
+        // given
         firstInteraction();
         secondInteraction();
 
-        verify(mock).otherMethod(); //verify 1st interaction
+        verify(mock).otherMethod(); // verify 1st interaction
         try {
-            //when
+            // when
             verify(mock).simpleMethod();
             fail();
         } catch (WantedButNotInvoked e) {
-            //then
+            // then
             assertThat(e)
-                .hasMessageContaining("However, there were exactly 2 interactions with this mock")
-                .hasMessageContaining("firstInteraction(")
-                .hasMessageContaining("secondInteraction(");
+                    .hasMessageContaining(
+                            "However, there were exactly 2 interactions with this mock")
+                    .hasMessageContaining("firstInteraction(")
+                    .hasMessageContaining("secondInteraction(");
         }
     }
 
@@ -48,7 +49,9 @@ public void shouldNotShowAllInteractionsOnDifferentMock() throws Exception {
             verify(mock).simpleMethod();
             fail();
         } catch (WantedButNotInvoked e) {
-            assertThat(e.getMessage()).contains("firstInteraction(").doesNotContain("differentMockInteraction(");
+            assertThat(e.getMessage())
+                    .contains("firstInteraction(")
+                    .doesNotContain("differentMockInteraction(");
         }
     }
 
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java
new file mode 100644
index 0000000000..472e18475c
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class PrintingVerboseTypesWithArgumentsTest extends TestBase {
+
+    class Boo {
+        public void withLong(long x) {}
+
+        public void withLongAndInt(long x, int y) {}
+    }
+
+    @Test
+    public void should_not_report_argument_types_when_to_string_is_the_same() {
+        // given
+        Boo boo = mock(Boo.class);
+        boo.withLong(100);
+
+        try {
+            // when
+            verify(boo).withLong(eq(100));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            // then
+            assertThat(e)
+                    .hasMessageContaining("withLong((Integer) 100);")
+                    .hasMessageContaining("withLong((Long) 100L);");
+        }
+    }
+
+    @Test
+    public void should_show_the_type_of_only_the_argument_that_doesnt_match() {
+        // given
+        Boo boo = mock(Boo.class);
+        boo.withLongAndInt(100, 200);
+
+        try {
+            // when
+            verify(boo).withLongAndInt(eq(100), eq(200));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            // then
+            assertThat(e)
+                    .hasMessageContaining("withLongAndInt((Integer) 100, 200)")
+                    .hasMessageContaining("withLongAndInt((Long) 100L, 200)");
+        }
+    }
+
+    @Test
+    public void
+            should_show_the_type_of_the_mismatching_argument_when_output_descriptions_for_invocations_are_different() {
+        // given
+        Boo boo = mock(Boo.class);
+        boo.withLongAndInt(100, 200);
+
+        try {
+            // when
+            verify(boo).withLongAndInt(eq(100), any(Integer.class));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            // then
+            Assertions.assertThat(e.getMessage())
+                    .contains("withLongAndInt(\n" + "    (Long) 100L,\n" + "    200\n" + ")")
+                    .contains(
+                            "withLongAndInt(\n"
+                                    + "    (Integer) 100,\n"
+                                    + "    <any java.lang.Integer>\n"
+                                    + ")");
+        }
+    }
+
+    @Test
+    public void should_not_show_types_when_argument_value_is_different() {
+        // given
+        Boo boo = mock(Boo.class);
+        boo.withLongAndInt(100, 200);
+
+        try {
+            // when
+            verify(boo).withLongAndInt(eq(100L), eq(230));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            // then
+            assertThat(e)
+                    .hasMessageContaining("withLongAndInt(100L, 200)")
+                    .hasMessageContaining("withLongAndInt(100L, 230)");
+        }
+    }
+
+    class Foo {
+
+        private final int x;
+
+        public Foo(int x) {
+            this.x = x;
+        }
+
+        public boolean equals(Object obj) {
+            return x == ((Foo) obj).x;
+        }
+
+        public int hashCode() {
+            return 1;
+        }
+
+        public String toString() {
+            return "foo";
+        }
+    }
+
+    @Test
+    public void
+            should_not_show_types_when_types_are_the_same_even_if_to_string_gives_the_same_result() {
+        // given
+        IMethods mock = mock(IMethods.class);
+        mock.simpleMethod(new Foo(10));
+
+        try {
+            // when
+            verify(mock).simpleMethod(new Foo(20));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+            // then
+            assertThat(e).hasMessageContaining("simpleMethod(foo)");
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/RelaxedVerificationInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/verification/RelaxedVerificationInOrderTest.java
new file mode 100644
index 0000000000..d947dc8ee4
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/RelaxedVerificationInOrderTest.java
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.exceptions.verification.NeverWantedButInvoked;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+/**
+ * ignored since 'relaxed' in order verification is not implemented (too complex to bother, maybe later).
+ */
+public class RelaxedVerificationInOrderTest extends TestBase {
+
+    private IMethods mockOne;
+    private IMethods mockTwo;
+    private IMethods mockThree;
+    private InOrder inOrder;
+
+    @Before
+    public void setUp() {
+        mockOne = mock(IMethods.class);
+        mockTwo = mock(IMethods.class);
+        mockThree = mock(IMethods.class);
+
+        inOrder = inOrder(mockOne, mockTwo, mockThree);
+
+        mockOne.simpleMethod(1);
+        mockTwo.simpleMethod(2);
+        mockTwo.simpleMethod(2);
+        mockThree.simpleMethod(3);
+        mockTwo.simpleMethod(2);
+        mockOne.simpleMethod(4);
+    }
+
+    @Test
+    public void shouldVerifyInOrderAllInvocations() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldVerifyInOrderAndBeRelaxed() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+
+        verifyNoMoreInteractions(mockThree);
+    }
+
+    @Test
+    public void shouldAllowFirstChunkBeforeLastInvocation() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+
+        try {
+            verifyNoMoreInteractions(mockTwo);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldAllowAllChunksBeforeLastInvocation() {
+        inOrder.verify(mockTwo, times(3)).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+
+        verifyNoMoreInteractions(mockTwo);
+    }
+
+    @Test
+    public void shouldVerifyDetectFirstChunkOfInvocationThatExistInManyChunks() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        try {
+            verifyNoMoreInteractions(mockTwo);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldVerifyDetectAllChunksOfInvocationThatExistInManyChunks() {
+        inOrder.verify(mockTwo, times(3)).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+        verifyNoMoreInteractions(mockTwo);
+    }
+
+    @Test
+    public void shouldVerifyInteractionsFromAllChunksWhenAtLeastOnceMode() {
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        verifyNoMoreInteractions(mockTwo);
+        try {
+            inOrder.verify(mockThree).simpleMethod(3);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldVerifyInteractionsFromFirstChunk() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        try {
+            verifyNoMoreInteractions(mockTwo);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldFailVerificationOfNonFirstChunk() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockTwo, times(1)).simpleMethod(2);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure:",
+                        "iMethods.simpleMethod(2);",
+                        "Wanted 1 time:",
+                        "-> at ",
+                        "But was 3 times:",
+                        "-> at ",
+                        "-> at ",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldPassOnCombinationOfTimesAndAtLeastOnce() {
+        mockTwo.simpleMethod(2);
+
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        verifyNoMoreInteractions(mockTwo);
+    }
+
+    @Test
+    public void shouldPassOnEdgyCombinationOfTimesAndAtLeastOnce() {
+        mockTwo.simpleMethod(2);
+        mockThree.simpleMethod(3);
+
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+
+        verifyNoMoreInteractions(mockThree);
+    }
+
+    @Test
+    public void shouldVerifyInOrderMockTwoAndThree() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        verifyNoMoreInteractions(mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldVerifyInOrderMockOneAndThree() {
+        inOrder.verify(mockOne).simpleMethod(1);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockOne).simpleMethod(4);
+        verifyNoMoreInteractions(mockOne, mockThree);
+    }
+
+    @Test
+    public void shouldVerifyInOrderOnlyTwoInvocations() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+    }
+
+    @Test
+    public void shouldVerifyInOrderOnlyMockTwo() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        inOrder.verify(mockTwo).simpleMethod(2);
+        verifyNoMoreInteractions(mockTwo);
+    }
+
+    @Test
+    public void shouldVerifyMockTwoCalledTwice() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+    }
+
+    @Test
+    public void shouldVerifyMockTwoCalledAtLeastOnce() {
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+    }
+
+    @Test
+    public void shouldFailOnWrongMethodCalledOnMockTwo() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockTwo, atLeastOnce()).differentMethod();
+                        })
+                .isInstanceOf(WantedButNotInvoked.class)
+                .hasMessageContainingAll(
+                        "Wanted but not invoked:",
+                        "iMethods.differentMethod();",
+                        "-> at ",
+                        "However, there were exactly 6 interactions with this mock:",
+                        "iMethods.simpleMethod(1);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(3);",
+                        "-> at ",
+                        "iMethods.simpleMethod(2);",
+                        "-> at ",
+                        "iMethods.simpleMethod(4);",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldAllowTimesZeroButOnlyInOrder() {
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        inOrder.verify(mockOne, times(0)).simpleMethod(1);
+
+        try {
+            verify(mockOne, times(0)).simpleMethod(1);
+            fail();
+        } catch (NeverWantedButInvoked e) {
+        }
+    }
+
+    @Test
+    public void shouldFailTimesZeroInOrder() {
+        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
+        try {
+            inOrder.verify(mockThree, times(0)).simpleMethod(3);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailWhenMockTwoWantedZeroTimes() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockTwo, times(0)).simpleMethod(2);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure:",
+                        "iMethods.simpleMethod(2);",
+                        "Wanted 0 times:",
+                        "-> at ",
+                        "But was 3 times:",
+                        "-> at ",
+                        "-> at ",
+                        "-> at ");
+    }
+
+    @Test
+    public void shouldVerifyLastInvocation() {
+        inOrder.verify(mockOne).simpleMethod(4);
+    }
+
+    @Test
+    public void shouldVerifySecondAndLastInvocation() {
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+    }
+
+    @Test
+    public void shouldVerifySecondAndLastInvocationWhenAtLeastOnceUsed() {
+        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+        inOrder.verify(mockOne).simpleMethod(4);
+    }
+
+    @Test
+    public void shouldFailOnLastTwoInvocationsInWrongOrder() {
+        inOrder.verify(mockOne).simpleMethod(4);
+        try {
+            inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnLastAndFirstInWrongOrder() {
+        inOrder.verify(mockOne).simpleMethod(4);
+        try {
+            inOrder.verify(mockOne).simpleMethod(1);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnWrongMethodAfterLastInvocation() {
+        inOrder.verify(mockOne).simpleMethod(4);
+        try {
+            inOrder.verify(mockOne).simpleMethod(999);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java
similarity index 92%
rename from src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java
index 68292b9066..39e5fdf558 100644
--- a/src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java
@@ -84,7 +84,8 @@ public void shouldFailVerificationForMockOne() {
         try {
             inOrder.verify(mockOne).differentMethod();
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -95,7 +96,8 @@ public void shouldFailVerificationForMockOneBecauseOfWrongOrder() {
         try {
             inOrder.verify(mockOne).simpleMethod(1);
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -123,7 +125,8 @@ public void shouldFailVerificationForMockTwo() {
         try {
             inOrder.verify(mockTwo).simpleMethod(2);
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -133,7 +136,8 @@ public void shouldThrowNoMoreInvocationsForMockTwo() {
         try {
             inOrder.verify(mockTwo, times(2)).simpleMethod(2);
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -143,7 +147,8 @@ public void shouldThrowTooFewInvocationsForMockTwo() {
         try {
             inOrder.verify(mockTwo, times(4)).simpleMethod(2);
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -153,7 +158,8 @@ public void shouldThrowTooManyInvocationsForMockTwo() {
         try {
             inOrder.verify(mockTwo, times(2)).simpleMethod(2);
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -182,6 +188,7 @@ public void shouldAllowTwoTimesOnMockTwo() {
         try {
             verifyNoMoreInteractions(mockTwo);
             fail();
-        } catch (NoInteractionsWanted e) {}
+        } catch (NoInteractionsWanted e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationExcludingStubsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationExcludingStubsTest.java
new file mode 100644
index 0000000000..1494d081a3
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationExcludingStubsTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.ignoreStubs;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+@SuppressWarnings("unchecked")
+public class VerificationExcludingStubsTest extends TestBase {
+
+    @Mock IMethods mock;
+
+    @Test
+    public void shouldAllowToExcludeStubsForVerification() {
+        // given
+        when(mock.simpleMethod()).thenReturn("foo");
+
+        // when
+        String stubbed = mock.simpleMethod(); // irrelevant call because it is stubbing
+        mock.objectArgMethod(stubbed);
+
+        // then
+        verify(mock).objectArgMethod("foo");
+
+        // verifyNoMoreInteractions fails:
+        try {
+            verifyNoMoreInteractions(mock);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+
+        // but it works when stubs are ignored:
+        Object[] ignored = ignoreStubs(mock);
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void shouldExcludeFromVerificationInOrder() {
+        // given
+        when(mock.simpleMethod()).thenReturn("foo");
+
+        // when
+        mock.objectArgMethod("1");
+        mock.objectArgMethod("2");
+        mock.simpleMethod(); // calling the stub
+
+        // then
+        InOrder inOrder = inOrder(ignoreStubs(mock));
+        inOrder.verify(mock).objectArgMethod("1");
+        inOrder.verify(mock).objectArgMethod("2");
+        inOrder.verifyNoMoreInteractions();
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void shouldIgnoringStubsDetectNulls() {
+        assertThatThrownBy(
+                        () -> {
+                            Object ignored = ignoreStubs(mock, null);
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is null!");
+    }
+
+    @Test
+    public void shouldIgnoringStubsDetectNonMocks() {
+        assertThatThrownBy(
+                        () -> {
+                            Object ignored = ignoreStubs(mock, new Object());
+                        })
+                .isInstanceOf(NotAMockException.class)
+                .hasMessage("Argument should be a mock, but is: class java.lang.Object");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderMixedWithOrdinaryVerificationTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderMixedWithOrdinaryVerificationTest.java
new file mode 100644
index 0000000000..8a978e4cb8
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderMixedWithOrdinaryVerificationTest.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class VerificationInOrderMixedWithOrdinaryVerificationTest extends TestBase {
+
+    private IMethods mockOne;
+    private IMethods mockTwo;
+    private IMethods mockThree;
+    private InOrder inOrder;
+
+    @Before
+    public void setUp() {
+        mockOne = mock(IMethods.class);
+        mockTwo = mock(IMethods.class);
+        mockThree = mock(IMethods.class);
+
+        mockOne.simpleMethod(1);
+        mockOne.simpleMethod(1);
+        mockTwo.simpleMethod(2);
+        mockThree.simpleMethod(3);
+        mockThree.simpleMethod(4);
+
+        inOrder = inOrder(mockOne, mockThree);
+    }
+
+    @Test
+    public void shouldMixVerificationInOrderAndOrdinaryVerification() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockThree).simpleMethod(4);
+        verify(mockTwo).simpleMethod(2);
+
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldAllowOrdinarilyVerifyingMockPassedToInOrderObject() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+
+        verify(mockThree).simpleMethod(3);
+        verify(mockThree).simpleMethod(4);
+        verify(mockTwo).simpleMethod(2);
+
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldAllowRedundantVerifications() {
+        verify(mockOne, atLeastOnce()).simpleMethod(1);
+        verify(mockTwo).simpleMethod(2);
+        verify(mockThree).simpleMethod(3);
+        verify(mockThree).simpleMethod(4);
+
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockThree).simpleMethod(4);
+
+        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+    }
+
+    @Test
+    public void shouldFailOnNoMoreInteractions() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockThree).simpleMethod(3);
+        inOrder.verify(mockThree).simpleMethod(4);
+
+        try {
+            verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldFailOnNoMoreInteractionsOnMockVerifiedInOrder() {
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+        inOrder.verify(mockThree).simpleMethod(3);
+        verify(mockTwo).simpleMethod(2);
+
+        try {
+            verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
+            fail();
+        } catch (NoInteractionsWanted e) {
+        }
+    }
+
+    @Test
+    public void shouldAllowOneMethodVerifiedInOrder() {
+        verify(mockTwo).simpleMethod(2);
+        verify(mockOne, atLeastOnce()).simpleMethod(1);
+
+        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+    }
+
+    @Test
+    public void shouldFailOnLastInvocationTooEarly() {
+        inOrder.verify(mockThree).simpleMethod(4);
+
+        verify(mockThree).simpleMethod(4);
+        verify(mockTwo).simpleMethod(2);
+
+        try {
+            inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
+            fail();
+        } catch (VerificationInOrderFailure e) {
+        }
+    }
+
+    @Test
+    public void shouldScreamWhenUnfamiliarMockPassedToInOrderObject() {
+        assertThatThrownBy(
+                        () -> {
+                            inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(1);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "InOrder can only verify mocks that were passed in during creation of InOrder.",
+                        "For example:",
+                        "    InOrder inOrder = inOrder(mockOne);",
+                        "    inOrder.verify(mockOne).doStuff();");
+    }
+
+    @Test
+    public void shouldUseEqualsToVerifyMethodArguments() {
+        mockOne = mock(IMethods.class);
+
+        String textOne = "test";
+        String textTwo = new String(textOne);
+
+        assertEquals(textOne, textTwo);
+        assertNotSame(textOne, textTwo);
+
+        mockOne.simpleMethod(textOne);
+        mockOne.simpleMethod(textTwo);
+
+        verify(mockOne, times(2)).simpleMethod(textOne);
+
+        inOrder = inOrder(mockOne);
+        inOrder.verify(mockOne, times(2)).simpleMethod(textOne);
+    }
+
+    @Test
+    public void shouldUseEqualsToVerifyMethodVarargs() {
+        mockOne = mock(IMethods.class);
+
+        String textOne = "test";
+        String textTwo = new String(textOne);
+
+        assertEquals(textOne, textTwo);
+        assertNotSame(textOne, textTwo);
+
+        mockOne.varargsObject(1, textOne, textOne);
+        mockOne.varargsObject(1, textTwo, textTwo);
+
+        verify(mockOne, times(2)).varargsObject(1, textOne, textOne);
+
+        inOrder = inOrder(mockOne);
+        inOrder.verify(mockOne, times(2)).varargsObject(1, textOne, textOne);
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/VerificationInOrderTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderTest.java
similarity index 94%
rename from src/test/java/org/mockitousage/verification/VerificationInOrderTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderTest.java
index a997d1c5ac..030ac0d9a3 100644
--- a/src/test/java/org/mockitousage/verification/VerificationInOrderTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderTest.java
@@ -47,7 +47,8 @@ public void shouldVerifySingleMockInOrderAndNotInOrder() {
         try {
             inOrder.verify(mockOne).simpleMethod(1);
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -77,7 +78,8 @@ public void shouldVerifyInOrderWhenTwoChunksAreEqual() {
         try {
             inOrder.verify(mockOne, atLeastOnce()).simpleMethod();
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 
     @Test
@@ -96,6 +98,7 @@ public void shouldVerifyInOrderUsingMatcher() {
         try {
             inOrder.verify(mockOne, times(3)).simpleMethod(anyInt());
             fail();
-        } catch (VerificationInOrderFailure e) {}
+        } catch (VerificationInOrderFailure e) {
+        }
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderWithCallsTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderWithCallsTest.java
new file mode 100644
index 0000000000..f2861b7929
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderWithCallsTest.java
@@ -0,0 +1,505 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.calls;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class VerificationInOrderWithCallsTest extends TestBase {
+
+    @Mock private IMethods mockOne;
+    @Mock private IMethods mockTwo;
+
+    @Test
+    public void shouldFailWhenMethodNotCalled() {
+        // Given
+        mockOne.oneArg(1);
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(1)).oneArg(2);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure",
+                        "Wanted but not invoked",
+                        "mockOne.oneArg(2)");
+    }
+
+    @Test
+    public void shouldFailWhenMethodCalledTooFewTimes() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(2)).oneArg(2);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure",
+                        "mockOne.oneArg(2)",
+                        "Wanted 2 times",
+                        "But was 1 time");
+    }
+
+    @Test
+    public void shouldFailWhenSingleMethodCallsAreOutOfSequence() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(2);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(1)).oneArg(1);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure",
+                        "Wanted but not invoked",
+                        "mockOne.oneArg(1)");
+    }
+
+    @Test
+    public void shouldFailWhenDifferentMethodCallsAreOutOfSequence() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.voidMethod();
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(1)).oneArg(1);
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure",
+                        "Wanted but not invoked",
+                        "mockOne.oneArg(1)");
+    }
+
+    @Test
+    public void shouldFailWhenMethodCallsOnDifferentMocksAreOutOfSequence() {
+        // Given
+        mockOne.voidMethod();
+        mockTwo.voidMethod();
+
+        InOrder verifier = inOrder(mockOne, mockTwo);
+        verifier.verify(mockTwo, calls(1)).voidMethod();
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(1)).voidMethod();
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContainingAll(
+                        "Verification in order failure",
+                        "Wanted but not invoked",
+                        "mockOne.voidMethod()");
+    }
+
+    @Test
+    public void shouldAllowSequentialCallsToCallsForSingleMethod() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(2)).oneArg(2);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifyNoMoreInteractions(mockOne);
+        verifier.verifyNoMoreInteractions();
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldAllowSequentialCallsToCallsForDifferentMethods() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.voidMethod();
+        mockOne.voidMethod();
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(2)).voidMethod();
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifyNoMoreInteractions(mockOne);
+        verifier.verifyNoMoreInteractions();
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldAllowSequentialCallsToCallsForMethodsOnDifferentMocks() {
+        // Given
+        mockOne.voidMethod();
+        mockTwo.voidMethod();
+        mockTwo.voidMethod();
+        mockOne.voidMethod();
+
+        InOrder verifier = inOrder(mockOne, mockTwo);
+
+        // When
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockTwo, calls(2)).voidMethod();
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifyNoMoreInteractions(mockOne);
+        verifyNoMoreInteractions(mockTwo);
+        verifier.verifyNoMoreInteractions();
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldAllowFewerCallsForSingleMethod() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).oneArg(2);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).oneArg(2);
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldNotVerifySkippedCallsWhenFewerCallsForSingleMethod() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).oneArg(2);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions(mockOne);
+                        })
+                .isInstanceOf(NoInteractionsWanted.class);
+    }
+
+    @Test
+    public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForSingleMethod() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).oneArg(2);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verifyNoMoreInteractions();
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("No interactions wanted here");
+    }
+
+    @Test
+    public void shouldAllowFewerCallsForDifferentMethods() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.voidMethod();
+        mockOne.voidMethod();
+        mockOne.oneArg(1);
+        mockOne.voidMethod();
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldNotVerifySkippedCallsWhenFewerCallsForDifferentMethods() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.voidMethod();
+        mockOne.voidMethod();
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+
+        // When / Then - no exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions(mockOne);
+                        })
+                .isInstanceOf(NoInteractionsWanted.class);
+    }
+
+    @Test
+    public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForDifferentMethods() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.voidMethod();
+        mockOne.voidMethod();
+
+        InOrder verifier = inOrder(mockOne);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verifyNoMoreInteractions();
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("No interactions wanted here");
+    }
+
+    @Test
+    public void shouldAllowFewerCallsForMethodsOnDifferentMocks() {
+        // Given
+        mockOne.voidMethod();
+        mockTwo.voidMethod();
+        mockTwo.voidMethod();
+        mockOne.voidMethod();
+        mockTwo.voidMethod();
+
+        InOrder verifier = inOrder(mockOne, mockTwo);
+
+        // When
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockTwo, calls(1)).voidMethod();
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockTwo, calls(1)).voidMethod();
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldNotVerifySkippedCallsWhenFewerCallsForMethodsOnDifferentMocks() {
+        // Given
+        mockOne.voidMethod();
+        mockTwo.voidMethod();
+        mockTwo.voidMethod();
+        mockOne.voidMethod();
+
+        InOrder verifier = inOrder(mockOne, mockTwo);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockTwo, calls(1)).voidMethod();
+        verifier.verify(mockOne, calls(1)).voidMethod();
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifyNoMoreInteractions(mockTwo);
+                        })
+                .isInstanceOf(NoInteractionsWanted.class);
+    }
+
+    @Test
+    public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForMethodsOnDifferentMocks() {
+        // Given
+        mockOne.voidMethod();
+        mockTwo.voidMethod();
+        mockTwo.voidMethod();
+
+        InOrder verifier = inOrder(mockOne, mockTwo);
+        verifier.verify(mockOne, calls(1)).voidMethod();
+        verifier.verify(mockTwo, calls(1)).voidMethod();
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verifyNoMoreInteractions();
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("No interactions wanted here");
+    }
+
+    @Test
+    public void shouldVerifyWithCallsAfterUseOfTimes() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, times(1)).oneArg(1);
+        verifier.verify(mockOne, calls(2)).oneArg(2);
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldVerifyWithCallsAfterUseOfAtLeast() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, atLeast(1)).oneArg(1);
+        verifier.verify(mockOne, calls(2)).oneArg(2);
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldVerifyWithTimesAfterUseOfCalls() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, times(2)).oneArg(2);
+        verifier.verify(mockOne, times(1)).oneArg(1);
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldVerifyWithAtLeastAfterUseOfCalls() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(2);
+        mockOne.oneArg(2);
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, atLeast(1)).oneArg(2);
+        verifier.verify(mockOne, atLeast(1)).oneArg(1);
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldVerifyWithTimesAfterCallsInSameChunk() {
+        // Given
+        mockOne.oneArg(1);
+        mockOne.oneArg(1);
+        mockOne.oneArg(1);
+
+        InOrder verifier = inOrder(mockOne);
+
+        // When
+        verifier.verify(mockOne, calls(1)).oneArg(1);
+        verifier.verify(mockOne, times(2)).oneArg(1);
+        verifier.verifyNoMoreInteractions();
+
+        // Then - no exception thrown
+    }
+
+    @Test
+    public void shouldFailToCreateCallsWithZeroArgument() {
+        // Given
+        InOrder verifier = inOrder(mockOne);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(0)).voidMethod();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Negative and zero values are not allowed here");
+    }
+
+    @Test
+    public void shouldFailToCreateCallsWithNegativeArgument() {
+        // Given
+        InOrder verifier = inOrder(mockOne);
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verifier.verify(mockOne, calls(-1)).voidMethod();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Negative and zero values are not allowed here");
+    }
+
+    @Test
+    public void shouldFailToCreateCallsForNonInOrderVerification() {
+        // Given
+        mockOne.voidMethod();
+
+        // When / Then - expected exception thrown
+        assertThatThrownBy(
+                        () -> {
+                            verify(mockOne, calls(1)).voidMethod();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("calls is only intended to work with InOrder");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderWithTimeoutTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderWithTimeoutTest.java
new file mode 100644
index 0000000000..121399d1e1
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationInOrderWithTimeoutTest.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.mockito.Mockito.after;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.junit.MockitoJUnit.rule;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.junit.MockitoRule;
+import org.mockitousage.IMethods;
+import org.mockitoutil.async.AsyncTesting;
+
+public class VerificationInOrderWithTimeoutTest {
+
+    @Rule public MockitoRule mockito = rule();
+
+    @Mock private IMethods mock1;
+    @Mock private IMethods mock2;
+
+    private AsyncTesting async;
+
+    @Before
+    public void setUp() {
+        async = new AsyncTesting();
+    }
+
+    @After
+    public void tearDown() {
+        async.cleanUp();
+    }
+
+    @Test
+    public void should_not_allow_in_order_with_after() {
+        // expect
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                inOrder(mock1).verify(mock1, after(100)).oneArg('a');
+                            }
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("not implemented to work with InOrder");
+        // TODO specific exception
+    }
+
+    @Test
+    public void should_verify_in_order_with_timeout() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'c'));
+        async.runAfter(200, callMock(mock2, 'b'));
+
+        // then
+        InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock1, timeout(100)).oneArg('a');
+        inOrder.verify(mock2, timeout(500)).oneArg('b');
+    }
+
+    @Test
+    public void should_verify_in_order_with_timeout_and_fail() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(100, callMock(mock2, 'b'));
+
+        // then
+        final InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock2, timeout(300)).oneArg('b');
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                inOrder.verify(mock1, timeout(300)).oneArg('a');
+                            }
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("Wanted but not invoked:\nmock1.oneArg('a');")
+                .hasMessageContaining(
+                        "Wanted anywhere AFTER following interaction:\nmock2.oneArg('b');");
+    }
+
+    @Test
+    public void should_verify_in_order_with_times_x() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'a'));
+        async.runAfter(200, callMock(mock2, 'b'));
+        async.runAfter(250, callMock(mock2, 'b'));
+
+        // then
+        InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock1, timeout(100).times(2)).oneArg('a');
+        inOrder.verify(mock2, timeout(500).times(2)).oneArg('b');
+    }
+
+    @Test
+    public void should_verify_in_order_with_times_x_and_fail() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'a'));
+        async.runAfter(200, callMock(mock2, 'b'));
+        async.runAfter(250, callMock(mock2, 'b'));
+
+        // then
+        final InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock2, timeout(500).times(2)).oneArg('b');
+
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                inOrder.verify(mock1, timeout(100).times(2)).oneArg('a');
+                            }
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("Wanted but not invoked:\nmock1.oneArg('a');")
+                .hasMessageContaining(
+                        "Wanted anywhere AFTER following interaction:\nmock2.oneArg('b');");
+    }
+
+    @Test
+    public void should_not_allow_in_order_with_only() {
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            @Override
+                            public void call() throws Throwable {
+                                inOrder(mock1).verify(mock1, timeout(200).only()).oneArg('a');
+                            }
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("not implemented to work with InOrder");
+        // TODO specific exception
+    }
+
+    @Test
+    public void should_verify_in_order_with_at_least_once() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'a'));
+        async.runAfter(100, callMock(mock2, 'b'));
+        async.runAfter(120, callMock(mock2, 'b'));
+
+        // then
+        InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock1, timeout(200).atLeastOnce()).oneArg('a');
+        inOrder.verify(mock2, timeout(500).atLeastOnce()).oneArg('b');
+    }
+
+    @Test
+    public void should_verify_in_order_with_at_least_once_and_fail() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'a'));
+        async.runAfter(100, callMock(mock2, 'b'));
+        async.runAfter(120, callMock(mock2, 'b'));
+
+        // then
+        final InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock2, timeout(300).atLeastOnce()).oneArg('b');
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                inOrder.verify(mock1, timeout(500).atLeastOnce()).oneArg('a');
+                            }
+                        })
+                .isInstanceOf(VerificationInOrderFailure.class)
+                .hasMessageContaining("Wanted but not invoked:\nmock1.oneArg('a');")
+                .hasMessageContaining(
+                        "Wanted anywhere AFTER following interaction:\nmock2.oneArg('b');");
+    }
+
+    @Test
+    public void should_verify_in_order_with_at_least_x() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'a'));
+        async.runAfter(100, callMock(mock2, 'b'));
+        async.runAfter(120, callMock(mock2, 'b'));
+
+        // then
+        InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock1, timeout(200).atLeast(2)).oneArg('a');
+        inOrder.verify(mock2, timeout(500).atLeast(2)).oneArg('b');
+    }
+
+    @Test
+    public void should_verify_in_order_with_at_least_x_and_fail() {
+        // when
+        async.runAfter(20, callMock(mock1, 'a'));
+        async.runAfter(50, callMock(mock1, 'a'));
+        async.runAfter(100, callMock(mock2, 'b'));
+        async.runAfter(120, callMock(mock2, 'b'));
+
+        // then
+        final InOrder inOrder = inOrder(mock1, mock2);
+        inOrder.verify(mock2, timeout(300).atLeast(2)).oneArg('b');
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            public void call() {
+                                inOrder.verify(mock1, timeout(500).atLeast(2)).oneArg('a');
+                            }
+                        })
+                .isInstanceOf(AssertionError.class)
+                .hasMessageContaining("Verification in order failure");
+    }
+
+    private Runnable callMock(final IMethods mock, final char c) {
+        return new Runnable() {
+            @Override
+            public void run() {
+                mock.oneArg(c);
+            }
+        };
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
similarity index 88%
rename from src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
index a543d38988..77e7e46ec5 100644
--- a/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
@@ -29,10 +29,10 @@ public void shouldVerifyUsingMatchers() throws Exception {
         map.put("test", 100);
         map.put("test two", 200);
 
-        verify(list).add(anyObject());
+        verify(list).add(any());
         verify(list).add(anyInt(), eq("test two"));
 
-        verify(map, times(2)).put(anyObject(), anyObject());
+        verify(map, times(2)).put(any(), any());
         verify(map).put(eq("test two"), eq(200));
 
         verifyNoMoreInteractions(list, map);
@@ -55,10 +55,9 @@ public void shouldVerifyMultipleMocks() throws Exception {
         verify(list, times(1)).add("two");
         verify(list, times(0)).add("three");
 
-        verify(map, times(2)).put(anyObject(), anyInt());
+        verify(map, times(2)).put(any(), anyInt());
 
         verifyNoMoreInteractions(list, map);
-        verifyZeroInteractions(set);
         verifyNoInteractions(set);
     }
 }
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationStartedListenerTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationStartedListenerTest.java
new file mode 100644
index 0000000000..5d585f4291
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationStartedListenerTest.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.listeners.VerificationStartedEvent;
+import org.mockito.listeners.VerificationStartedListener;
+import org.mockitoutil.TestBase;
+
+/**
+ * This test demonstrates how verification started listeners work.
+ * The test cases are contrived but they provide necessary coverage.
+ * For rationale, see https://github.com/mockito/mockito/issues/1191
+ */
+public class VerificationStartedListenerTest extends TestBase {
+
+    @Test
+    public void verified_mock_can_be_replaced() throws Exception {
+        // given
+        final List mock1 = mock(List.class);
+        mock1.clear(); // register clear() on mock1
+
+        // when
+        List mock2 =
+                mock(
+                        List.class,
+                        Mockito.withSettings()
+                                .verificationStartedListeners(
+                                        new VerificationStartedListener() {
+                                            public void onVerificationStarted(
+                                                    VerificationStartedEvent event) {
+                                                // this is a hack to simulate desired behavior
+                                                event.setMock(mock1);
+                                            }
+                                        }));
+
+        // then verified mock is not mock2 that was passed to 'verify' but the replacement: mock1
+        List verifiedMock = verify(mock2);
+        assertEquals(mock1, verifiedMock);
+
+        // and verification is successful because mock1.clear() was called
+        verifiedMock.clear();
+
+        // this test is admittedly contrived. it's goal is to provide coverage for the key
+        // functionality of the listener
+        // see the discussion at https://github.com/mockito/mockito/issues/1191
+    }
+
+    @Test
+    public void verification_started_event_contains_correct_mock() throws Exception {
+        // given
+        final List<Object> container = new ArrayList<Object>();
+
+        List mock =
+                mock(
+                        List.class,
+                        Mockito.withSettings()
+                                .verificationStartedListeners(
+                                        new VerificationStartedListener() {
+                                            public void onVerificationStarted(
+                                                    VerificationStartedEvent event) {
+                                                // this is a hack to simulate desired behavior
+                                                container.add(event.getMock());
+                                            }
+                                        }));
+
+        // when
+        verify(mock, never()).clear();
+
+        // then
+        Assertions.assertThat(container).containsExactly(mock);
+    }
+
+    @Test
+    public void listeners_are_executed_in_sequence() throws Exception {
+        // given
+        final List<Object> container = new ArrayList<Object>();
+        final List mock1 = mock(List.class);
+
+        List mock2 =
+                mock(
+                        List.class,
+                        Mockito.withSettings()
+                                .verificationStartedListeners(
+                                        new VerificationStartedListener() {
+                                            public void onVerificationStarted(
+                                                    VerificationStartedEvent event) {
+                                                // this is a hack to simulate desired behavior
+                                                container.add(event.getMock());
+                                                event.setMock(mock1);
+                                            }
+                                        },
+                                        new VerificationStartedListener() {
+                                            @Override
+                                            public void onVerificationStarted(
+                                                    VerificationStartedEvent event) {
+                                                container.add(event.getMock());
+                                            }
+                                        }));
+
+        // when
+        verify(mock2, never()).clear();
+
+        // ensure that:
+        // 1. listeners were notified in sequence
+        // 2. the state set by 1st listeners affects 2nd listener
+        Assertions.assertThat(container).containsExactly(mock2, mock1);
+
+        // there is no particular reason we decided on that behavior
+        // we want to have a consistent and documented behavior of the verification started listener
+    }
+
+    @Test
+    public void shows_clean_exception_when_null_array_passed() throws Exception {
+        try {
+            // when
+            Mockito.withSettings().verificationStartedListeners(null);
+            fail();
+        } catch (MockitoException e) {
+            assertEquals(
+                    "verificationStartedListeners() does not accept null vararg array. See the Javadoc.",
+                    e.getMessage());
+        }
+    }
+
+    @Test
+    public void shows_clean_exception_when_null_listener_passed() throws Exception {
+        try {
+            // when
+            Mockito.withSettings()
+                    .verificationStartedListeners(mock(VerificationStartedListener.class), null);
+            fail();
+        } catch (MockitoException e) {
+            assertEquals(
+                    "verificationStartedListeners() does not accept null listeners. See the Javadoc.",
+                    e.getMessage());
+        }
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java
new file mode 100644
index 0000000000..6e916b7124
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.contains;
+import static org.mockito.AdditionalMatchers.geq;
+import static org.mockito.AdditionalMatchers.leq;
+import static org.mockito.AdditionalMatchers.and;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class VerificationUsingMatchersTest extends TestBase {
+
+    private IMethods mock;
+
+    @Before
+    public void setUp() {
+        mock = Mockito.mock(IMethods.class);
+    }
+
+    @Test
+    public void shouldVerifyExactNumberOfInvocationsUsingMatcher() {
+        mock.simpleMethod(1);
+        mock.simpleMethod(2);
+        mock.simpleMethod(3);
+
+        verify(mock, times(3)).simpleMethod(anyInt());
+    }
+
+    @Test
+    public void shouldVerifyUsingSameMatcher() {
+        Object one = new String("1243");
+        Object two = new String("1243");
+        Object three = new String("1243");
+
+        assertNotSame(one, two);
+        assertEquals(one, two);
+        assertEquals(two, three);
+
+        mock.oneArg(one);
+        mock.oneArg(two);
+
+        verify(mock).oneArg(same(one));
+        verify(mock, times(2)).oneArg(two);
+
+        try {
+            verify(mock).oneArg(same(three));
+            fail();
+        } catch (WantedButNotInvoked e) {
+        }
+    }
+
+    @Test
+    public void shouldVerifyUsingMixedMatchers() {
+        mock.threeArgumentMethod(11, "", "01234");
+
+        try {
+            verify(mock)
+                    .threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), contains("123"));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+        }
+
+        mock.threeArgumentMethod(8, new Object(), "01234");
+
+        try {
+            verify(mock)
+                    .threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), contains("123"));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+        }
+
+        mock.threeArgumentMethod(8, "", "no match");
+
+        try {
+            verify(mock)
+                    .threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), contains("123"));
+            fail();
+        } catch (ArgumentsAreDifferent e) {
+        }
+
+        mock.threeArgumentMethod(8, "", "123");
+
+        verify(mock).threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), contains("123"));
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
similarity index 98%
rename from src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
index 1dfdffb465..d173812e57 100644
--- a/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithAfterAndCaptorTest.java
@@ -62,7 +62,7 @@ public void shouldReturnListOfArgumentsWithSameSizeAsGivenInTimesVerification()
         // when
         exerciseMockNTimes(n);
 
-        //Then
+        // Then
         verify(mock, after(200).times(n)).oneArg((char) captor.capture());
         assertEquals(n, captor.getAllValues().size());
         assertEquals('0', (char) captor.getAllValues().get(0));
@@ -79,7 +79,7 @@ public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtLeastVerification(
         // when
         exerciseMockNTimes(n);
 
-        //Then
+        // Then
         verify(mock, after(200).atLeast(n)).oneArg((char) captor.capture());
         assertEquals(n, captor.getAllValues().size());
         assertEquals('0', (char) captor.getAllValues().get(0));
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java
new file mode 100644
index 0000000000..0d3f40be44
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import static org.assertj.core.api.Assertions.assertThat;
+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;
+
+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.internal.verification.DummyVerificationMode;
+import org.mockito.junit.MockitoRule;
+import org.mockito.verification.VerificationMode;
+import org.mockitousage.IMethods;
+import org.mockitoutil.Stopwatch;
+import org.mockitoutil.async.AsyncTesting;
+
+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(600)).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);
+    }
+
+    @Test
+    public void should_return_formatted_output_from_toString_when_created_with_factory_method() {
+        VerificationMode after = after(3);
+
+        assertThat(after).hasToString("Wanted after 3 ms: [Wanted invocations count: 1]");
+    }
+
+    @Test
+    public void should_return_formatted_output_from_toString_using_wrapped_verification_mode() {
+        org.mockito.verification.After after =
+                new org.mockito.verification.After(10, new DummyVerificationMode());
+
+        assertThat(after).hasToString("Wanted after 10 ms: [Dummy verification mode]");
+    }
+
+    @Test
+    public void
+            should_return_formatted_output_from_toString_when_chaining_other_verification_mode() {
+        VerificationMode afterAndOnly = after(5).only();
+
+        assertThat(afterAndOnly)
+                .hasToString(
+                        "Wanted after 5 ms: [Wanted invocations count: 1 and no other method invoked]");
+    }
+}
diff --git a/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java
new file mode 100644
index 0000000000..b51aafd980
--- /dev/null
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.verification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.after;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.mockito.junit.MockitoJUnit.rule;
+import static org.mockitoutil.Stopwatch.createNotStarted;
+
+import java.util.concurrent.TimeUnit;
+
+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.mockito.Mock;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.internal.verification.DummyVerificationMode;
+import org.mockito.junit.MockitoRule;
+import org.mockito.verification.Timeout;
+import org.mockito.verification.VerificationMode;
+import org.mockitousage.IMethods;
+import org.mockitoutil.Stopwatch;
+import org.mockitoutil.async.AsyncTesting;
+
+public class VerificationWithTimeoutTest {
+
+    @Rule public MockitoRule mockito = rule();
+
+    private Stopwatch watch = createNotStarted();
+
+    @Mock private IMethods mock;
+
+    private AsyncTesting async;
+
+    @Before
+    public void setUp() {
+        async = new AsyncTesting();
+    }
+
+    @After
+    public void tearDown() {
+        async.cleanUp();
+    }
+
+    @Test
+    public void should_verify_with_timeout() {
+        // when
+        async.runAfter(50, callMock('c'));
+        async.runAfter(500, callMock('c'));
+
+        // then
+        verify(mock, timeout(200).only()).oneArg('c');
+        verify(mock).oneArg('c'); // sanity check
+    }
+
+    @Test
+    public void should_verify_with_timeout_and_fail() {
+        // when
+        async.runAfter(200, callMock('c'));
+
+        // then
+        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
+    @Ignore // TODO nice to have
+    public void should_verify_with_timeout_and_fail_early() {
+        // when
+        callMock('c');
+        callMock('c');
+
+        watch.start();
+
+        // then
+        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 should_verify_with_times_x() {
+        // when
+        async.runAfter(50, callMock('c'));
+        async.runAfter(100, callMock('c'));
+        async.runAfter(600, callMock('c'));
+
+        // then
+        verify(mock, timeout(300).times(2)).oneArg('c');
+    }
+
+    @Test
+    public void should_verify_with_times_x_and_fail() {
+        // when
+        async.runAfter(10, callMock('c'));
+        async.runAfter(200, callMock('c'));
+
+        // then
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            @Override
+                            public void call() {
+                                verify(mock, timeout(100).times(2)).oneArg('c');
+                            }
+                        })
+                .isInstanceOf(TooFewActualInvocations.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(TooFewActualInvocations.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 should_return_formatted_output_from_toString_when_created_with_factory_method() {
+        VerificationMode timeout = timeout(7);
+
+        assertThat(timeout).hasToString("Wanted after at most 7 ms: [Wanted invocations count: 1]");
+    }
+
+    @Test
+    public void should_return_formatted_output_from_toString_using_wrapped_verification_mode() {
+        VerificationMode timeoutAndAtLeastOnce = new Timeout(9, new DummyVerificationMode());
+
+        assertThat(timeoutAndAtLeastOnce)
+                .hasToString("Wanted after at most 9 ms: [Dummy verification mode]");
+    }
+
+    @Test
+    public void
+            should_return_formatted_output_from_toString_when_chaining_other_verification_mode() {
+        VerificationMode timeoutAndOnly = timeout(7).only();
+
+        assertThat(timeoutAndOnly)
+                .hasToString(
+                        "Wanted after at most 7 ms: [Wanted invocations count: 1 and no other method invoked]");
+    }
+
+    @Test
+    @Ignore("not testable, probably timeout().only() does not make sense")
+    public void should_verify_with_only_and_fail() {
+        // when
+        async.runAfter(10, callMock('c'));
+        async.runAfter(50, callMock('c'));
+
+        // then
+        Assertions.assertThatThrownBy(
+                        new ThrowableAssert.ThrowingCallable() {
+                            @Override
+                            public void call() {
+                                verify(mock, after(200).only()).oneArg('c');
+                            }
+                        })
+                .isInstanceOf(AssertionError.class);
+    }
+
+    @Test
+    @Ignore // TODO nice to have
+    public void should_verify_with_only_and_fail_early() {
+        // when
+        callMock('c');
+        callMock('c');
+
+        watch.start();
+
+        // then
+        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) {
+        return new Runnable() {
+            @Override
+            public void run() {
+                mock.oneArg(c);
+            }
+        };
+    }
+}
diff --git a/src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java b/mockito-core/src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java
similarity index 95%
rename from src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java
rename to mockito-core/src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java
index 6ef951b416..e9b4a296e9 100644
--- a/src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java
+++ b/mockito-core/src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java
@@ -11,7 +11,6 @@
 import org.mockito.Mockito;
 import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
 
-
 public class VerifyPrintsAllInvocationsOnErrorTest {
 
     @Test
@@ -22,14 +21,12 @@ public void shouldPrintAllInvocationsOnError() {
         try {
             Mockito.verify(mockBuilder).with("key1", "wrongValue");
             fail();
-        }
-        catch (ArgumentsAreDifferent e) {
+        } catch (ArgumentsAreDifferent e) {
             assertThat(e).hasMessageContaining("exampleBuilder.with(\"key1\", \"val1\")");
             assertThat(e).hasMessageContaining("exampleBuilder.with(\"key2\", \"val2\"");
         }
     }
 
-
     private static class ExampleBuilder {
         public ExampleBuilder with(String key, String val) {
             return this;
diff --git a/src/test/java/org/mockito/StateMaster.java b/mockito-core/src/testFixtures/java/org/mockito/StateMaster.java
similarity index 100%
rename from src/test/java/org/mockito/StateMaster.java
rename to mockito-core/src/testFixtures/java/org/mockito/StateMaster.java
diff --git a/mockito-core/src/testFixtures/java/org/mockito/configuration/MockitoConfiguration.java b/mockito-core/src/testFixtures/java/org/mockito/configuration/MockitoConfiguration.java
new file mode 100644
index 0000000000..ab65516f11
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockito/configuration/MockitoConfiguration.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.configuration;
+
+import org.mockito.stubbing.Answer;
+
+public class MockitoConfiguration extends DefaultMockitoConfiguration
+        implements IMockitoConfiguration {
+
+    private Answer<Object> overriddenDefaultAnswer = null;
+
+    private boolean cleansStackTrace;
+
+    private org.mockito.plugins.AnnotationEngine overriddenEngine;
+
+    private boolean enableClassCache = true;
+
+    // for testing purposes, allow to override the configuration
+    public void overrideDefaultAnswer(Answer<Object> defaultAnswer) {
+        this.overriddenDefaultAnswer = defaultAnswer;
+    }
+
+    // for testing purposes, allow to override the configuration
+    public void overrideCleansStackTrace(boolean cleansStackTrace) {
+        this.cleansStackTrace = cleansStackTrace;
+    }
+
+    // for testing purposes, allow to override the annotation engine
+    public void overrideAnnotationEngine(org.mockito.plugins.AnnotationEngine engine) {
+        this.overriddenEngine = engine;
+    }
+
+    // for testing purposes, allow to override the annotation engine
+    public void overrideEnableClassCache(boolean enableClassCache) {
+        this.enableClassCache = enableClassCache;
+    }
+
+    @Override
+    public Answer<Object> getDefaultAnswer() {
+        if (overriddenDefaultAnswer == null) {
+            return super.getDefaultAnswer();
+        } else {
+            return overriddenDefaultAnswer;
+        }
+    }
+
+    @Override
+    public boolean cleansStackTrace() {
+        return cleansStackTrace;
+    }
+
+    @Override
+    public boolean enableClassCache() {
+        return enableClassCache;
+    }
+}
diff --git a/src/test/java/org/mockito/internal/configuration/ConfigurationAccess.java b/mockito-core/src/testFixtures/java/org/mockito/internal/configuration/ConfigurationAccess.java
similarity index 100%
rename from src/test/java/org/mockito/internal/configuration/ConfigurationAccess.java
rename to mockito-core/src/testFixtures/java/org/mockito/internal/configuration/ConfigurationAccess.java
diff --git a/mockito-core/src/testFixtures/java/org/mockito/internal/invocation/InvocationBuilder.java b/mockito-core/src/testFixtures/java/org/mockito/internal/invocation/InvocationBuilder.java
new file mode 100644
index 0000000000..d5cf3e5577
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockito/internal/invocation/InvocationBuilder.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.invocation;
+
+import static java.util.Arrays.asList;
+
+import static org.mockito.internal.invocation.InterceptedInvocation.NO_OP;
+
+import java.lang.reflect.Method;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.Mockito;
+import org.mockito.internal.debugging.LocationFactory;
+import org.mockito.internal.invocation.mockref.MockReference;
+import org.mockito.internal.invocation.mockref.MockStrongReference;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockitousage.IMethods;
+
+/**
+ * Build an invocation.
+ */
+@SuppressWarnings("unchecked")
+public class InvocationBuilder {
+
+    private String methodName = "simpleMethod";
+    private int sequenceNumber = 0;
+    private Object[] args = new Object[] {};
+    private Object mock = Mockito.mock(IMethods.class);
+    private Class<?> mockClass = IMethods.class;
+    private Method method;
+    private boolean verified;
+    private List<Class<?>> argTypes;
+    private Location location;
+
+    /**
+     * Build the invocation
+     * <p>
+     * If the method was not specified, use IMethods methods.
+     *
+     * @return invocation
+     */
+    public Invocation toInvocation() {
+        if (method == null) {
+            if (argTypes == null) {
+                argTypes = new LinkedList<Class<?>>();
+                for (Object arg : args) {
+                    if (arg == null) {
+                        argTypes.add(Object.class);
+                    } else {
+                        argTypes.add(arg.getClass());
+                    }
+                }
+            }
+
+            try {
+                method =
+                        mockClass.getMethod(
+                                methodName, argTypes.toArray(new Class[argTypes.size()]));
+            } catch (Exception e) {
+                throw new RuntimeException(
+                        "builder only creates invocations of IMethods interface", e);
+            }
+        }
+
+        Invocation i =
+                createInvocation(
+                        new MockStrongReference<Object>(mock, false),
+                        new SerializableMethod(method),
+                        args,
+                        NO_OP,
+                        location == null ? LocationFactory.create() : location,
+                        1);
+        if (verified) {
+            i.markVerified();
+        }
+        return i;
+    }
+
+    protected Invocation createInvocation(
+            MockReference<Object> mockRef,
+            MockitoMethod mockitoMethod,
+            Object[] arguments,
+            RealMethod realMethod,
+            Location location,
+            int sequenceNumber) {
+        return new InterceptedInvocation(
+                mockRef, mockitoMethod, arguments, realMethod, location, sequenceNumber);
+    }
+
+    public InvocationBuilder method(String methodName) {
+        this.methodName = methodName;
+        return this;
+    }
+
+    public InvocationBuilder seq(int sequenceNumber) {
+        this.sequenceNumber = sequenceNumber;
+        return this;
+    }
+
+    public InvocationBuilder args(Object... args) {
+        this.args = args;
+        return this;
+    }
+
+    public InvocationBuilder arg(Object o) {
+        this.args = new Object[] {o};
+        return this;
+    }
+
+    public InvocationBuilder mock(Object mock) {
+        this.mock = mock;
+        return this;
+    }
+
+    public InvocationBuilder mockClass(Class<?> mockClass) {
+        this.mockClass = mockClass;
+        this.mock = mock(mockClass);
+        return this;
+    }
+
+    public InvocationBuilder method(Method method) {
+        this.method = method;
+        return this;
+    }
+
+    public InvocationBuilder verified() {
+        this.verified = true;
+        return this;
+    }
+
+    public InvocationMatcher toInvocationMatcher() {
+        return new InvocationMatcher(toInvocation());
+    }
+
+    public InvocationBuilder simpleMethod() {
+        return this.method("simpleMethod");
+    }
+
+    public InvocationBuilder differentMethod() {
+        return this.method("differentMethod");
+    }
+
+    public InvocationBuilder argTypes(Class<?>... argTypes) {
+        this.argTypes = asList(argTypes);
+        return this;
+    }
+
+    public InvocationBuilder location(final String location) {
+        this.location =
+                new Location() {
+                    public String toString() {
+                        return location;
+                    }
+
+                    public String getSourceFile() {
+                        return "SomeClass";
+                    }
+                };
+        return this;
+    }
+}
diff --git a/mockito-core/src/testFixtures/java/org/mockitousage/IMethods.java b/mockito-core/src/testFixtures/java/org/mockitousage/IMethods.java
new file mode 100644
index 0000000000..5c1d3d8e5d
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitousage/IMethods.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import java.io.IOException;
+import java.nio.charset.CharacterCodingException;
+import java.util.*;
+
+public interface IMethods {
+
+    boolean booleanReturningMethod();
+
+    Boolean booleanObjectReturningMethod();
+
+    byte byteReturningMethod();
+
+    Byte byteObjectReturningMethod();
+
+    short shortReturningMethod();
+
+    Short shortObjectReturningMethod();
+
+    char charReturningMethod();
+
+    Character charObjectReturningMethod();
+
+    int intReturningMethod();
+
+    Integer integerReturningMethod();
+
+    long longReturningMethod();
+
+    Long longObjectReturningMethod();
+
+    float floatReturningMethod();
+
+    Float floatObjectReturningMethod();
+
+    double doubleReturningMethod();
+
+    Double doubleObjectReturningMethod();
+
+    Object objectReturningMethod(Object... objects);
+
+    Object objectReturningMethodNoArgs();
+
+    String oneArg(boolean value);
+
+    String oneArg(Boolean value);
+
+    String forBoolean(Boolean value);
+
+    String oneArg(byte value);
+
+    String oneArg(Byte value);
+
+    String forByte(Byte value);
+
+    String oneArg(short value);
+
+    String oneArg(Short value);
+
+    String forShort(Short value);
+
+    String oneArg(char value);
+
+    String oneArg(Character value);
+
+    String forCharacter(Character value);
+
+    String oneArg(int value);
+
+    String oneArg(Integer value);
+
+    String forInteger(Integer value);
+
+    String oneArg(long value);
+
+    String oneArg(Long value);
+
+    String forLong(Long value);
+
+    String oneArg(float value);
+
+    String oneArg(Float value);
+
+    String forFloat(Float value);
+
+    String oneArg(double value);
+
+    String oneArg(Double value);
+
+    String forDouble(Double value);
+
+    String oneArg(Object value);
+
+    String oneArg(String value);
+
+    String throwsNothing(boolean value);
+
+    String throwsIOException(int count) throws IOException;
+
+    String throwsError(int count);
+
+    String simpleMethod();
+
+    String differentMethod();
+
+    String differentMethod(String argument);
+
+    String otherMethod();
+
+    String simpleMethod(String argument);
+
+    String simpleMethod(Collection<?> collection);
+
+    String simpleMethod(Object argument);
+
+    String simpleMethod(int argument);
+
+    String simpleMethod(String argOne, Integer argTwo);
+
+    String simpleMethod(String one, Integer two, Integer three, Integer four, Integer five);
+
+    String simpleMethod(
+            String one, Integer two, Integer three, Integer four, Integer five, Integer six);
+
+    String simpleMethod(String one, String[] two);
+
+    Object threeArgumentMethod(int valueOne, Object valueTwo, String valueThree);
+
+    String threeArgumentMethodWithStrings(int valueOne, String valueTwo, String valueThree);
+
+    String threeArgumentVarArgsMethod(int valueOne, String valueTwo, String... valueThree);
+
+    String fourArgumentMethod(int valueOne, String valueTwo, String valueThree, boolean[] array);
+
+    String fourArgumentVarArgsMethod(
+            int valueOne, String valueTwo, int valueThree, String... valueFour);
+
+    String fiveArgumentVarArgsMethod(
+            int valueOne, String valueTwo, int valueThree, String valueFour, String... valueFive);
+
+    String sixArgumentVarArgsMethod(
+            int valueOne,
+            String valueTwo,
+            int valueThree,
+            String valueFour,
+            String valueFive,
+            String... valueSix);
+
+    int arrayVarargsMethod(String[]... arrayVarArgs);
+
+    void twoArgumentMethod(int one, int two);
+
+    void arrayMethod(String[] strings);
+
+    String oneArray(boolean[] array);
+
+    String oneArray(byte[] array);
+
+    String oneArray(char[] array);
+
+    String oneArray(double[] array);
+
+    String oneArray(float[] array);
+
+    String oneArray(int[] array);
+
+    String oneArray(long[] array);
+
+    String oneArray(short[] array);
+
+    String oneArray(Object[] array);
+
+    String canThrowException() throws CharacterCodingException;
+
+    String oneArray(String[] array);
+
+    void varargsString(int i, String... string);
+
+    Object varargsObject(int i, Object... object);
+
+    void varargsbyte(byte... bytes);
+
+    int varargs(Object... object);
+
+    int varargs(String... string);
+
+    int polyVararg(BaseType... args);
+
+    String varargsReturningString(Object... object);
+
+    void mixedVarargs(Object i, String... string);
+
+    String mixedVarargsReturningString(Object i, String... string);
+
+    String[] mixedVarargsReturningStringArray(Object i, String... string);
+
+    Object[] mixedVarargsReturningObjectArray(Object i, String... string);
+
+    String methodWithVarargAndNonVarargVariants(String string);
+
+    String methodWithVarargAndNonVarargVariants(String... string);
+
+    List<String> listReturningMethod(Object... objects);
+
+    LinkedList<String> linkedListReturningMethod();
+
+    String toString();
+
+    String toString(String foo);
+
+    void voidMethod();
+
+    Void voidReturningMethod();
+
+    String forList(List<String> list);
+
+    String forSet(Set<String> anySet);
+
+    String forMap(Map<String, String> map);
+
+    String forCollection(Collection<String> collection);
+
+    String forIterable(Iterable<String> iterable);
+
+    Object[] arrayReturningMethod();
+
+    IMethods iMethodsReturningMethod();
+
+    String stringReturningMethod();
+
+    Object objectArgMethod(Object str);
+
+    Object listArgMethod(List<String> list);
+
+    Object collectionArgMethod(Collection<String> collection);
+
+    Object iterableArgMethod(Iterable<String> collection);
+
+    Object setArgMethod(Set<String> set);
+
+    void longArg(long longArg);
+
+    void intArgumentMethod(int i);
+
+    int intArgumentReturningInt(int i);
+
+    boolean equals(String str);
+
+    boolean equals();
+
+    int hashCode(String str);
+
+    int toIntPrimitive(Integer i);
+
+    Integer toIntWrapper(int i);
+
+    Integer toIntWrapperVarArgs(int i, Object... varargs);
+
+    String forObject(Object object);
+
+    <T> String genericToString(T arg);
+
+    void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, Date date);
+
+    void overloadedMethodWithSameClassNameArguments(Date date, java.sql.Date javaDate);
+
+    void overloadedMethodWithDifferentClassNameArguments(String String, Integer i);
+
+    void overloadedMethodWithDifferentClassNameArguments(Integer i, String string);
+
+    void overloadedMethodWithSameClassNameArguments(
+            java.sql.Date javaDate, String string, Date date);
+
+    void overloadedMethodWithSameClassNameArguments(
+            Date date, String string, java.sql.Date javaDate);
+
+    /**
+     * Using this class to test cases where two classes have same simple name
+     */
+    public static class Date {
+
+        private int value;
+
+        public Date(int value) {
+            this.value = value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            Date date = (Date) o;
+            return value == date.value;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(value);
+        }
+    }
+
+    interface BaseType {}
+}
diff --git a/src/test/java/org/mockitousage/MethodsImpl.java b/mockito-core/src/testFixtures/java/org/mockitousage/MethodsImpl.java
similarity index 75%
rename from src/test/java/org/mockitousage/MethodsImpl.java
rename to mockito-core/src/testFixtures/java/org/mockitousage/MethodsImpl.java
index d538dd1dcf..678d3f7fe1 100644
--- a/src/test/java/org/mockitousage/MethodsImpl.java
+++ b/mockito-core/src/testFixtures/java/org/mockitousage/MethodsImpl.java
@@ -237,7 +237,8 @@ public String simpleMethod(String one, Integer two, Integer three, Integer four,
         return null;
     }
 
-    public String simpleMethod(String one, Integer two, Integer three, Integer four, Integer five, Integer six) {
+    public String simpleMethod(
+            String one, Integer two, Integer three, Integer four, Integer five, Integer six) {
         return null;
     }
 
@@ -253,18 +254,52 @@ public String threeArgumentMethodWithStrings(int valueOne, String valueTwo, Stri
         return null;
     }
 
-    public String fourArgumentMethod(int valueOne, String valueTwo, String valueThree, boolean[] array) {
+    public String threeArgumentVarArgsMethod(
+            final int valueOne, final String valueTwo, final String... valueThree) {
         return null;
     }
 
-    public void twoArgumentMethod(int one, int two) {
+    public String fourArgumentMethod(
+            int valueOne, String valueTwo, String valueThree, boolean[] array) {
+        return null;
+    }
 
+    public String fourArgumentVarArgsMethod(
+            final int valueOne,
+            final String valueTwo,
+            final int valueThree,
+            final String... valueFour) {
+        return null;
     }
 
-    public void arrayMethod(String[] strings) {
+    public String fiveArgumentVarArgsMethod(
+            final int valueOne,
+            final String valueTwo,
+            final int valueThree,
+            final String valueFour,
+            final String... valueFive) {
+        return null;
+    }
 
+    public String sixArgumentVarArgsMethod(
+            final int valueOne,
+            final String valueTwo,
+            final int valueThree,
+            final String valueFour,
+            final String valueFive,
+            final String... valueSix) {
+        return null;
     }
 
+    @Override
+    public int arrayVarargsMethod(final String[]... arrayVarArgs) {
+        return 0;
+    }
+
+    public void twoArgumentMethod(int one, int two) {}
+
+    public void arrayMethod(String[] strings) {}
+
     public String oneArray(boolean[] array) {
         return null;
     }
@@ -309,9 +344,7 @@ public String oneArray(String[] array) {
         return null;
     }
 
-    public void varargsString(int i, String... string) {
-
-    }
+    public void varargsString(int i, String... string) {}
 
     public Object varargsObject(int i, Object... object) {
         return null;
@@ -321,17 +354,21 @@ public int varargs(Object... object) {
         return -1;
     }
 
-    public String varargsReturningString(Object... object) {
-        return null;
-    }
-
     public int varargs(String... string) {
         return -1;
     }
 
-    public void mixedVarargs(Object i, String... string) {
+    @Override
+    public int polyVararg(final BaseType... args) {
+        return 0;
     }
 
+    public String varargsReturningString(Object... object) {
+        return null;
+    }
+
+    public void mixedVarargs(Object i, String... string) {}
+
     public String mixedVarargsReturningString(Object i, String... string) {
         return null;
     }
@@ -344,9 +381,18 @@ public Object[] mixedVarargsReturningObjectArray(Object i, String... string) {
         return null;
     }
 
-    public void varargsbyte(byte... bytes) {
+    @Override
+    public String methodWithVarargAndNonVarargVariants(String string) {
+        return "plain";
+    }
+
+    @Override
+    public String methodWithVarargAndNonVarargVariants(String... string) {
+        return "varargs";
     }
 
+    public void varargsbyte(byte... bytes) {}
+
     public List<String> listReturningMethod(Object... objects) {
         return null;
     }
@@ -359,9 +405,7 @@ public String toString(String foo) {
         return null;
     }
 
-    public void voidMethod() {
-
-    }
+    public void voidMethod() {}
 
     public String forList(List<String> list) {
         return null;
@@ -415,13 +459,9 @@ public Object setArgMethod(Set<String> set) {
         return null;
     }
 
-    public void longArg(long longArg) {
+    public void longArg(long longArg) {}
 
-    }
-
-    public void intArgumentMethod(int i) {
-
-    }
+    public void intArgumentMethod(int i) {}
 
     public int intArgumentReturningInt(int i) {
         return 0;
@@ -447,6 +487,11 @@ public Integer toIntWrapper(int i) {
         return null;
     }
 
+    @Override
+    public Integer toIntWrapperVarArgs(final int i, final Object... varargs) {
+        return null;
+    }
+
     public String forObject(Object object) {
         return null;
     }
@@ -460,4 +505,24 @@ public Void voidReturningMethod() {
     public <T> String genericToString(T arg) {
         return null;
     }
+
+    @Override
+    public void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, Date date) {}
+
+    @Override
+    public void overloadedMethodWithSameClassNameArguments(Date date, java.sql.Date javaDate) {}
+
+    @Override
+    public void overloadedMethodWithDifferentClassNameArguments(String string, Integer i) {}
+
+    @Override
+    public void overloadedMethodWithDifferentClassNameArguments(Integer i, String string) {}
+
+    @Override
+    public void overloadedMethodWithSameClassNameArguments(
+            java.sql.Date javaDate, String string, Date date) {}
+
+    @Override
+    public void overloadedMethodWithSameClassNameArguments(
+            Date date, String string, java.sql.Date javaDate) {}
 }
diff --git a/src/test/java/org/mockitoutil/ClassLoaders.java b/mockito-core/src/testFixtures/java/org/mockitoutil/ClassLoaders.java
similarity index 78%
rename from src/test/java/org/mockitoutil/ClassLoaders.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/ClassLoaders.java
index 045f83df09..dabaa779a5 100644
--- a/src/test/java/org/mockitoutil/ClassLoaders.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/ClassLoaders.java
@@ -11,6 +11,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.lang.StackWalker.Option;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.net.MalformedURLException;
@@ -36,6 +37,8 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.ThreadFactory;
 
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
 import org.objenesis.Objenesis;
 import org.objenesis.ObjenesisStd;
 import org.objenesis.instantiator.ObjectInstantiator;
@@ -43,8 +46,7 @@
 public abstract class ClassLoaders {
     protected ClassLoader parent = currentClassLoader();
 
-    protected ClassLoaders() {
-    }
+    protected ClassLoaders() {}
 
     public static IsolatedURLClassLoaderBuilder isolatedClassLoader() {
         return new IsolatedURLClassLoaderBuilder();
@@ -105,28 +107,33 @@ public ClassLoaderExecutor(ClassLoader classLoader) {
         }
 
         public void execute(final Runnable task) throws Exception {
-            ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactory() {
-                @Override
-                public Thread newThread(Runnable r) {
-                    Thread thread = Executors.defaultThreadFactory().newThread(r);
-                    thread.setContextClassLoader(classLoader);
-                    return thread;
-                }
-            });
+            ExecutorService executorService =
+                    Executors.newSingleThreadExecutor(
+                            new ThreadFactory() {
+                                @Override
+                                public Thread newThread(Runnable r) {
+                                    Thread thread = Executors.defaultThreadFactory().newThread(r);
+                                    thread.setContextClassLoader(classLoader);
+                                    return thread;
+                                }
+                            });
             try {
-                Future<?> taskFuture = executorService.submit(new Runnable() {
-                    @Override
-                    public void run() {
-                        try {
-                            reloadTaskInClassLoader(task).run();
-                        } catch (Throwable throwable) {
-                            throw new IllegalStateException(format("Given task could not be loaded properly in the given classloader '%s', error '%s",
-                                                                   task,
-                                                                   throwable.getMessage()),
-                                                            throwable);
-                        }
-                    }
-                });
+                Future<?> taskFuture =
+                        executorService.submit(
+                                new Runnable() {
+                                    @Override
+                                    public void run() {
+                                        try {
+                                            reloadTaskInClassLoader(task).run();
+                                        } catch (Throwable throwable) {
+                                            throw new IllegalStateException(
+                                                    format(
+                                                            "Given task could not be loaded properly in the given classloader '%s', error '%s",
+                                                            task, throwable.getMessage()),
+                                                    throwable);
+                                        }
+                                    }
+                                });
                 taskFuture.get();
                 executorService.shutdownNow();
             } catch (InterruptedException e) {
@@ -144,26 +151,27 @@ private <T extends Throwable> T unwrapAndThrows(ExecutionException ex) throws T
         Runnable reloadTaskInClassLoader(Runnable task) {
             try {
                 @SuppressWarnings("unchecked")
-                Class<Runnable> taskClassReloaded = (Class<Runnable>) classLoader.loadClass(task.getClass().getName());
+                Class<Runnable> taskClassReloaded =
+                        (Class<Runnable>) classLoader.loadClass(task.getClass().getName());
 
                 Objenesis objenesis = new ObjenesisStd();
-                ObjectInstantiator<Runnable> thingyInstantiator = objenesis.getInstantiatorOf(taskClassReloaded);
+                ObjectInstantiator<Runnable> thingyInstantiator =
+                        objenesis.getInstantiatorOf(taskClassReloaded);
                 Runnable reloaded = thingyInstantiator.newInstance();
 
                 // lenient shallow copy of class compatible fields
                 for (Field field : task.getClass().getDeclaredFields()) {
                     Field declaredField = taskClassReloaded.getDeclaredField(field.getName());
                     int modifiers = declaredField.getModifiers();
-                    if(Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers)) {
+                    if (Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers)) {
                         // Skip static final fields (e.g. jacoco fields)
                         // otherwise IllegalAccessException (can be bypassed with Unsafe though)
                         // We may also miss coverage data.
                         continue;
                     }
                     if (declaredField.getType() == field.getType()) { // don't copy this
-                        field.setAccessible(true);
-                        declaredField.setAccessible(true);
-                        declaredField.set(reloaded, field.get(task));
+                        MemberAccessor accessor = Plugins.getMemberAccessor();
+                        accessor.set(declaredField, reloaded, accessor.get(field, task));
                     }
                 }
 
@@ -201,6 +209,10 @@ public IsolatedURLClassLoaderBuilder withCodeSourceUrlOf(Class<?>... classes) {
         }
 
         public IsolatedURLClassLoaderBuilder withCurrentCodeSourceUrls() {
+            Class<?> callerClass =
+                    StackWalker.getInstance(Option.RETAIN_CLASS_REFERENCE).getCallerClass();
+
+            codeSourceUrls.add(obtainCurrentClassPathOf(callerClass.getName()));
             codeSourceUrls.add(obtainCurrentClassPathOf(ClassLoaders.class.getName()));
             return this;
         }
@@ -215,8 +227,7 @@ public ClassLoader build() {
                     jdkClassLoader(),
                     codeSourceUrls.toArray(new URL[codeSourceUrls.size()]),
                     privateCopyPrefixes,
-                    excludedPrefixes
-            );
+                    excludedPrefixes);
         }
     }
 
@@ -224,10 +235,11 @@ static class LocalIsolatedURLClassLoader extends URLClassLoader {
         private final ArrayList<String> privateCopyPrefixes;
         private final ArrayList<String> excludedPrefixes;
 
-        LocalIsolatedURLClassLoader(ClassLoader classLoader,
-                                    URL[] urls,
-                                    ArrayList<String> privateCopyPrefixes,
-                                    ArrayList<String> excludedPrefixes) {
+        LocalIsolatedURLClassLoader(
+                ClassLoader classLoader,
+                URL[] urls,
+                ArrayList<String> privateCopyPrefixes,
+                ArrayList<String> excludedPrefixes) {
             super(urls, classLoader);
             this.privateCopyPrefixes = privateCopyPrefixes;
             this.excludedPrefixes = excludedPrefixes;
@@ -236,17 +248,20 @@ static class LocalIsolatedURLClassLoader extends URLClassLoader {
         @Override
         public Class<?> findClass(String name) throws ClassNotFoundException {
             if (!classShouldBePrivate(name) || classShouldBeExcluded(name)) {
-                throw new ClassNotFoundException(format("Can only load classes with prefixes : %s, but not : %s",
-                                                        privateCopyPrefixes,
-                                                        excludedPrefixes));
+                throw new ClassNotFoundException(
+                        format(
+                                "Can only load classes with prefixes : %s, but not : %s",
+                                privateCopyPrefixes, excludedPrefixes));
             }
             try {
                 return super.findClass(name);
             } catch (ClassNotFoundException cnfe) {
-                throw new ClassNotFoundException(format("%s%n%s%n",
-                                                        cnfe.getMessage(),
-                                                        "    Did you forgot to add the code source url 'withCodeSourceUrlOf' / 'withCurrentCodeSourceUrls' ?"),
-                                                 cnfe);
+                throw new ClassNotFoundException(
+                        format(
+                                "%s%n%s%n",
+                                cnfe.getMessage(),
+                                "    Did you forgot to add the code source url 'withCodeSourceUrlOf' / 'withCurrentCodeSourceUrls' ?"),
+                        cnfe);
             }
         }
 
@@ -295,17 +310,15 @@ public ClassLoader build() {
             return new LocalExcludingURLClassLoader(
                     jdkClassLoader(),
                     codeSourceUrls.toArray(new URL[codeSourceUrls.size()]),
-                    excludedPrefixes
-            );
+                    excludedPrefixes);
         }
     }
 
     static class LocalExcludingURLClassLoader extends URLClassLoader {
         private final ArrayList<String> excludedPrefixes;
 
-        LocalExcludingURLClassLoader(ClassLoader classLoader,
-                                     URL[] urls,
-                                     ArrayList<String> excludedPrefixes) {
+        LocalExcludingURLClassLoader(
+                ClassLoader classLoader, URL[] urls, ArrayList<String> excludedPrefixes) {
             super(urls, classLoader);
             this.excludedPrefixes = excludedPrefixes;
         }
@@ -313,7 +326,8 @@ static class LocalExcludingURLClassLoader extends URLClassLoader {
         @Override
         public Class<?> findClass(String name) throws ClassNotFoundException {
             if (classShouldBeExcluded(name))
-                throw new ClassNotFoundException("classes with prefix : " + excludedPrefixes + " are excluded");
+                throw new ClassNotFoundException(
+                        "classes with prefix : " + excludedPrefixes + " are excluded");
             return super.findClass(name);
         }
 
@@ -409,12 +423,12 @@ public MemURLConnection(URL url, InMemoryClassLoader inMemoryClassLoader) {
             }
 
             @Override
-            public void connect() throws IOException {
-            }
+            public void connect() throws IOException {}
 
             @Override
             public InputStream getInputStream() throws IOException {
-                return new ByteArrayInputStream(inMemoryClassLoader.inMemoryClassObjects.get(qualifiedName));
+                return new ByteArrayInputStream(
+                        inMemoryClassLoader.inMemoryClassObjects.get(qualifiedName));
             }
         }
     }
@@ -422,9 +436,17 @@ public InputStream getInputStream() throws IOException {
     URL obtainCurrentClassPathOf(String className) {
         String path = className.replace('.', '/') + ".class";
         String url = ClassLoaders.class.getClassLoader().getResource(path).toExternalForm();
+        String location;
+        if (url.startsWith("jar:")) { // multi-release jar file location
+            location = url.substring(4, url.lastIndexOf(".jar!") + 4);
+        } else if (url.endsWith(path)) {
+            location = url.substring(0, url.length() - path.length());
+        } else {
+            throw new IllegalStateException("Unknown URL format for class location: " + url);
+        }
 
         try {
-            return new URL(url.substring(0, url.length() - path.length()));
+            return new URL(location);
         } catch (MalformedURLException e) {
             throw new RuntimeException("Classloader couldn't obtain a proper classpath URL", e);
         }
@@ -481,7 +503,10 @@ public Set<String> listOwnedClasses() throws IOException, URISyntaxException {
                     // Just ignore it.
                     continue;
                 } else {
-                    throw new IllegalArgumentException(format("Given ClassLoader '%s' don't have reachable by File or vi ClassLoaders.inMemory", classLoader));
+                    throw new IllegalArgumentException(
+                            format(
+                                    "Given ClassLoader '%s' don't have reachable by File or vi ClassLoaders.inMemory",
+                                    classLoader));
                 }
             }
             return classes;
@@ -499,8 +524,8 @@ private void addFromInMemoryBasedClassLoader(Set<String> classes, URI uri) {
             }
         }
 
-
-        private Set<String> findClassQualifiedNames(File root, File file, Set<String> packageFilters) {
+        private Set<String> findClassQualifiedNames(
+                File root, File file, Set<String> packageFilters) {
             if (file.isDirectory()) {
                 File[] files = file.listFiles();
                 Set<String> classes = new HashSet<String>();
@@ -527,10 +552,11 @@ private boolean excludes(String qualifiedName, Set<String> packageFilters) {
         }
 
         private String classNameFor(File root, File file) {
-            String temp = file.getAbsolutePath().substring(root.getAbsolutePath().length() + 1).
-                    replace(File.separatorChar, '.');
+            String temp =
+                    file.getAbsolutePath()
+                            .substring(root.getAbsolutePath().length() + 1)
+                            .replace(File.separatorChar, '.');
             return temp.subSequence(0, temp.indexOf(".class")).toString();
         }
-
     }
 }
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/ClassLoadersTest.java b/mockito-core/src/testFixtures/java/org/mockitoutil/ClassLoadersTest.java
new file mode 100644
index 0000000000..59da6e5bdd
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/ClassLoadersTest.java
@@ -0,0 +1,377 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockitoutil.ClassLoaders.currentClassLoader;
+import static org.mockitoutil.ClassLoaders.excludingClassLoader;
+import static org.mockitoutil.ClassLoaders.isolatedClassLoader;
+import static org.mockitoutil.ClassLoaders.jdkClassLoader;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class ClassLoadersTest {
+
+    public static final String CLASS_NAME_DEPENDING_ON_INTERFACE =
+            "org.mockitoutil.ClassLoadersTest$ClassUsingInterface1";
+    public static final String INTERFACE_NAME = "org.mockitoutil.ClassLoadersTest$Interface1";
+
+    @Test
+    public void isolated_class_loader_cannot_load_classes_when_no_given_prefix() {
+        // given
+        ClassLoader cl = isolatedClassLoader().build();
+
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            cl.loadClass("org.mockito.Mockito");
+                        })
+                .isInstanceOf(ClassNotFoundException.class)
+                .hasMessage("Can only load classes with prefixes : [], but not : []");
+    }
+
+    @Test
+    public void isolated_class_loader_cannot_load_classes_if_no_code_source_path() {
+        // given
+        ClassLoader cl =
+                isolatedClassLoader().withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE).build();
+
+        // when
+        try {
+            cl.loadClass(CLASS_NAME_DEPENDING_ON_INTERFACE);
+            fail();
+        } catch (ClassNotFoundException e) {
+            // then
+            assertThat(e).hasMessageContaining(CLASS_NAME_DEPENDING_ON_INTERFACE);
+        }
+    }
+
+    @Test
+    public void
+            isolated_class_loader_cannot_load_classes_if_dependent_classes_do_not_match_the_prefixes()
+                    throws Exception {
+        // given
+        ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
+                        .build();
+
+        // when
+        try {
+            cl.loadClass(CLASS_NAME_DEPENDING_ON_INTERFACE);
+            fail();
+        } catch (NoClassDefFoundError e) {
+            // then
+            assertThat(e).hasMessageContaining("org/mockitoutil/ClassLoadersTest$Interface1");
+        }
+    }
+
+    @Test
+    public void
+            isolated_class_loader_can_load_classes_when_dependent_classes_are_matching_the_prefixes()
+                    throws Exception {
+        // given
+        ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
+                        .withPrivateCopyOf(INTERFACE_NAME)
+                        .build();
+
+        // when
+        Class<?> aClass = cl.loadClass(CLASS_NAME_DEPENDING_ON_INTERFACE);
+
+        // then
+        assertThat(aClass).isNotNull();
+        assertThat(aClass.getClassLoader()).isEqualTo(cl);
+        assertThat(aClass.getInterfaces()[0].getClassLoader()).isEqualTo(cl);
+    }
+
+    @Test
+    public void isolated_class_loader_can_load_classes_isolated_classes_in_isolation()
+            throws Exception {
+        // given
+        ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
+                        .build();
+
+        // when
+        Class<?> aClass = cl.loadClass(AClass.class.getName());
+
+        // then
+        assertThat(aClass).isNotNull();
+        assertThat(aClass).isNotSameAs(AClass.class);
+        assertThat(aClass.getClassLoader()).isEqualTo(cl);
+    }
+
+    @Test
+    public void isolated_class_loader_cannot_load_classes_if_prefix_excluded() {
+        // given
+        ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
+                        .without(AClass.class.getName())
+                        .build();
+
+        // when
+        try {
+            cl.loadClass(AClass.class.getName());
+            fail();
+        } catch (ClassNotFoundException e) {
+            // then
+            assertThat(e)
+                    .hasMessageContaining("org.mockitoutil")
+                    .hasMessageContaining(AClass.class.getName());
+        }
+    }
+
+    @Test
+    public void isolated_class_loader_has_no_parent() {
+        ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
+                        .withPrivateCopyOf(INTERFACE_NAME)
+                        .build();
+
+        assertThat(cl.getParent()).isNull();
+    }
+
+    @Test
+    public void excluding_class_loader_cannot_load_classes_when_no_correct_source_url_set() {
+        // given
+        ClassLoader cl = excludingClassLoader().withCodeSourceUrlOf(this.getClass()).build();
+
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            cl.loadClass("org.mockito.Mockito");
+                        })
+                .isInstanceOf(ClassNotFoundException.class)
+                .hasMessage("org.mockito.Mockito");
+    }
+
+    @Test
+    public void excluding_class_loader_can_load_classes_when_correct_source_url_set()
+            throws Exception {
+        // given
+        ClassLoader cl = excludingClassLoader().withCodeSourceUrlOf(Mockito.class).build();
+
+        // when
+        cl.loadClass("org.mockito.Mockito");
+
+        // then class successfully loaded
+    }
+
+    @Test
+    public void excluding_class_loader_cannot_load_class_when_excluded_prefix_match_class_to_load()
+            throws Exception {
+        // given
+        ClassLoader cl =
+                excludingClassLoader()
+                        .withCodeSourceUrlOf(Mockito.class)
+                        .without("org.mockito.BDDMockito")
+                        .build();
+
+        cl.loadClass("org.mockito.Mockito");
+
+        // when
+        try {
+            cl.loadClass("org.mockito.BDDMockito");
+            fail("should have raise a ClassNotFoundException");
+        } catch (ClassNotFoundException e) {
+            assertThat(e.getMessage()).contains("org.mockito.BDDMockito");
+        }
+
+        // then class successfully loaded
+    }
+
+    @Test
+    public void can_not_load_a_class_not_previously_registered_in_builder() {
+        // given
+        ClassLoader cl =
+                ClassLoaders.inMemoryClassLoader()
+                        .withClassDefinition(
+                                "yop.Dude", SimpleClassGenerator.makeMarkerInterface("yop.Dude"))
+                        .build();
+
+        // when
+        try {
+            cl.loadClass("not.Defined");
+            fail();
+        } catch (ClassNotFoundException e) {
+            // then
+            assertThat(e.getMessage()).contains("not.Defined");
+        }
+    }
+
+    @Test
+    public void can_load_a_class_in_memory_from_bytes() throws Exception {
+        // given
+        ClassLoader cl =
+                ClassLoaders.inMemoryClassLoader()
+                        .withClassDefinition(
+                                "yop.Dude", SimpleClassGenerator.makeMarkerInterface("yop.Dude"))
+                        .build();
+
+        // when
+        Class<?> aClass = cl.loadClass("yop.Dude");
+
+        // then
+        assertThat(aClass).isNotNull();
+        assertThat(aClass.getClassLoader()).isEqualTo(cl);
+        assertThat(aClass.getName()).isEqualTo("yop.Dude");
+    }
+
+    @Test
+    public void cannot_load_a_class_file_not_in_parent() throws Exception {
+        // given
+        ClassLoader cl = ClassLoaders.inMemoryClassLoader().withParent(jdkClassLoader()).build();
+
+        cl.loadClass("java.lang.String");
+
+        try {
+            // when
+            cl.loadClass("org.mockito.Mockito");
+            fail("should have not found Mockito class");
+        } catch (ClassNotFoundException e) {
+            // then
+            assertThat(e.getMessage()).contains("org.mockito.Mockito");
+        }
+    }
+
+    @Test
+    public void can_list_all_classes_reachable_in_a_classloader() throws Exception {
+        ClassLoader classLoader =
+                ClassLoaders.inMemoryClassLoader()
+                        .withParent(jdkClassLoader())
+                        .withClassDefinition("a.A", SimpleClassGenerator.makeMarkerInterface("a.A"))
+                        .withClassDefinition(
+                                "a.b.B", SimpleClassGenerator.makeMarkerInterface("a.b.B"))
+                        .withClassDefinition("c.C", SimpleClassGenerator.makeMarkerInterface("c.C"))
+                        //                .withCodeSourceUrlOf(ClassLoaders.class)
+                        .build();
+
+        assertThat(ClassLoaders.in(classLoader).listOwnedClasses())
+                .containsOnly("a.A", "a.b.B", "c.C");
+        assertThat(ClassLoaders.in(classLoader).omit("b", "c").listOwnedClasses())
+                .containsOnly("a.A");
+    }
+
+    @Test
+    public void return_bootstrap_classloader() {
+        assertThat(jdkClassLoader()).isNotEqualTo(Mockito.class.getClassLoader());
+        assertThat(jdkClassLoader()).isNotEqualTo(ClassLoaders.class.getClassLoader());
+        assertThat(jdkClassLoader()).isEqualTo(Number.class.getClassLoader());
+        assertThat(jdkClassLoader()).isEqualTo(null);
+    }
+
+    @Test
+    public void return_current_classloader() {
+        assertThat(currentClassLoader()).isEqualTo(this.getClass().getClassLoader());
+    }
+
+    @Test
+    public void can_run_in_given_classloader() throws Exception {
+        // given
+        final ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withCodeSourceUrlOf(Assertions.class)
+                        .withPrivateCopyOf("org.assertj.core")
+                        .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
+                        .without(AClass.class.getName())
+                        .build();
+
+        final AtomicBoolean executed = new AtomicBoolean(false);
+
+        // when
+        ClassLoaders.using(cl)
+                .execute(
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                assertThat(this.getClass().getClassLoader())
+                                        .describedAs("runnable is reloaded in given classloader")
+                                        .isEqualTo(cl);
+                                assertThat(Thread.currentThread().getContextClassLoader())
+                                        .describedAs(
+                                                "Thread context classloader is using given classloader")
+                                        .isEqualTo(cl);
+
+                                try {
+                                    assertThat(
+                                                    Thread.currentThread()
+                                                            .getContextClassLoader()
+                                                            .loadClass("java.lang.String"))
+                                            .describedAs("can load JDK type")
+                                            .isNotNull();
+                                    assertThat(
+                                                    Thread.currentThread()
+                                                            .getContextClassLoader()
+                                                            .loadClass(
+                                                                    "org.mockitoutil.ClassLoadersTest$ClassUsingInterface1"))
+                                            .describedAs("can load classloader types")
+                                            .isNotNull();
+                                } catch (ClassNotFoundException cnfe) {
+                                    Assertions.fail("should not have raised a CNFE", cnfe);
+                                }
+                                executed.set(true);
+                            }
+                        });
+
+        // then
+        assertThat(executed.get()).isEqualTo(true);
+    }
+
+    @Test
+    public void cannot_load_runnable_in_given_classloader_if_some_type_cant_be_loaded()
+            throws Exception {
+        // given
+        final ClassLoader cl =
+                isolatedClassLoader()
+                        .withCurrentCodeSourceUrls()
+                        .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
+                        .without(AClass.class.getName())
+                        .build();
+
+        // when
+        try {
+            ClassLoaders.using(cl)
+                    .execute(
+                            new Runnable() {
+                                @Override
+                                public void run() {
+                                    AClass cant_be_found = new AClass();
+                                }
+                            });
+            Assertions.fail("should have raised a ClassNotFoundException");
+        } catch (IllegalStateException ise) {
+            // then
+            assertThat(ise)
+                    .hasCauseInstanceOf(NoClassDefFoundError.class)
+                    .hasMessageContaining("AClass");
+        }
+    }
+
+    @SuppressWarnings("unused")
+    static class AClass {}
+
+    @SuppressWarnings("unused")
+    static class ClassUsingInterface1 implements Interface1 {}
+
+    @SuppressWarnings("unused")
+    interface Interface1 {}
+}
diff --git a/src/test/java/org/mockitoutil/ConcurrentTesting.java b/mockito-core/src/testFixtures/java/org/mockitoutil/ConcurrentTesting.java
similarity index 91%
rename from src/test/java/org/mockitoutil/ConcurrentTesting.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/ConcurrentTesting.java
index 1722aeb0fa..f5717fe372 100644
--- a/src/test/java/org/mockitoutil/ConcurrentTesting.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/ConcurrentTesting.java
@@ -25,7 +25,7 @@ public static void inThread(Runnable r) throws InterruptedException {
      * Starts all supplied runnables and then waits for all of them to complete.
      * Runnables are executed concurrently.
      */
-    public static void concurrently(Runnable ... runnables) throws InterruptedException {
+    public static void concurrently(Runnable... runnables) throws InterruptedException {
         List<Thread> threads = new LinkedList<Thread>();
         for (Runnable r : runnables) {
             Thread t = new Thread(r);
diff --git a/src/test/java/org/mockitoutil/Conditions.java b/mockito-core/src/testFixtures/java/org/mockitoutil/Conditions.java
similarity index 76%
rename from src/test/java/org/mockitoutil/Conditions.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/Conditions.java
index a9658cbc30..96491faed6 100644
--- a/src/test/java/org/mockitoutil/Conditions.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/Conditions.java
@@ -23,10 +23,11 @@ public boolean matches(Throwable traceElements) {
                 StackTraceElement[] trace = traceElements.getStackTrace();
 
                 Assertions.assertThat(trace.length)
-                          .describedAs("Number of classes does not match.\nExpected: %s\nGot: %s",
-                                       Arrays.toString(classes),
-                                       Arrays.toString(traceElements.getStackTrace()))
-                          .isEqualTo(classes.length);
+                        .describedAs(
+                                "Number of classes does not match.\nExpected: %s\nGot: %s",
+                                Arrays.toString(classes),
+                                Arrays.toString(traceElements.getStackTrace()))
+                        .isEqualTo(classes.length);
 
                 for (int i = 0; i < trace.length; i++) {
                     Assertions.assertThat(trace[i].getClassName()).isEqualTo(classes[i]);
@@ -43,10 +44,10 @@ public static Condition<StackTraceElement[]> onlyThoseClasses(final String... cl
             @Override
             public boolean matches(StackTraceElement[] traceElements) {
                 Assertions.assertThat(traceElements.length)
-                          .describedAs("Number of classes does not match.\nExpected: %s\nGot: %s",
-                                       Arrays.toString(classes),
-                                       Arrays.toString(traceElements))
-                          .isEqualTo(classes.length);
+                        .describedAs(
+                                "Number of classes does not match.\nExpected: %s\nGot: %s",
+                                Arrays.toString(classes), Arrays.toString(traceElements))
+                        .isEqualTo(classes.length);
 
                 for (int i = 0; i < traceElements.length; i++) {
                     Assertions.assertThat(traceElements[i].getClassName()).isEqualTo(classes[i]);
@@ -61,7 +62,8 @@ public static Condition<Throwable> firstMethodInStackTrace(final String method)
         return methodInStackTraceAt(0, method);
     }
 
-    public static Condition<Throwable> methodInStackTraceAt(final int stackTraceIndex, final String method) {
+    public static Condition<Throwable> methodInStackTraceAt(
+            final int stackTraceIndex, final String method) {
         return new Condition<Throwable>() {
             private String actualMethodAtIndex;
 
@@ -74,7 +76,9 @@ public boolean matches(Throwable throwable) {
 
             @Override
             public Description description() {
-                return new TextDescription("Method at index: %d\nexpected to be: %s\nbut is: %s", stackTraceIndex, method, actualMethodAtIndex);
+                return new TextDescription(
+                        "Method at index: %d\nexpected to be: %s\nbut is: %s",
+                        stackTraceIndex, method, actualMethodAtIndex);
             }
         };
     }
@@ -111,12 +115,12 @@ public static Condition<Throwable> methodsInStackTrace(final String... methods)
             public boolean matches(Throwable value) {
                 StackTraceElement[] trace = value.getStackTrace();
                 for (int i = 0; i < methods.length; i++) {
-                    Assertions.assertThat(trace[i].getMethodName()).describedAs("Expected methods[%d] to be in the stack trace.", i).isEqualTo(methods[i]);
+                    Assertions.assertThat(trace[i].getMethodName())
+                            .describedAs("Expected methods[%d] to be in the stack trace.", i)
+                            .isEqualTo(methods[i]);
                 }
                 return true;
             }
         };
     }
-
-
 }
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/JUnitResultAssert.java b/mockito-core/src/testFixtures/java/org/mockitoutil/JUnitResultAssert.java
new file mode 100644
index 0000000000..76be637388
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/JUnitResultAssert.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.util.collections.Iterables.firstOf;
+import static org.mockitoutil.TestBase.filterLineNo;
+
+import java.util.List;
+
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+/**
+ * Assertion utility for cleaner and easier to debug tests that inspect on JUnit's Result object
+ */
+public class JUnitResultAssert {
+    private Result result;
+
+    private JUnitResultAssert(Result result) {
+        this.result = result;
+    }
+
+    public void isSuccessful() {
+        if (result.wasSuccessful()) {
+            return;
+        }
+
+        throw new AssertionError(formatFailures(result.getFailures()));
+    }
+
+    /**
+     * @param expectedFailureCount - expected number of failures
+     * @param expectedException - the exception of each failure
+     */
+    public JUnitResultAssert fails(int expectedFailureCount, Class expectedException) {
+        fails(expectedFailureCount);
+        for (Failure f : result.getFailures()) {
+            if (!expectedException.isInstance(f.getException())) {
+                throw new AssertionError(
+                        "Incorrect failure type, expected: "
+                                + expectedException
+                                + ", actual: "
+                                + f.getException().getClass().getSimpleName()
+                                + "\n"
+                                + formatFailures(result.getFailures()));
+            }
+        }
+        return this;
+    }
+
+    /**
+     * @param expectedFailureCount - exact number of expected failures
+     */
+    public JUnitResultAssert fails(int expectedFailureCount) {
+        if (result.getFailures().size() != expectedFailureCount) {
+            throw new AssertionError(
+                    "Wrong number of failures, expected: "
+                            + expectedFailureCount
+                            + ", actual: "
+                            + result.getFailures().size()
+                            + "\n"
+                            + formatFailures(result.getFailures()));
+        }
+        return this;
+    }
+
+    /**
+     * @param expectedExceptions - failures must match the supplied sequence in order,
+     *                           if supplied input is empty, this method is a no-op
+     */
+    public JUnitResultAssert failsExactly(Class... expectedExceptions) {
+        fails(expectedExceptions.length);
+        int i = 0;
+        for (Failure f : result.getFailures()) {
+            if (!expectedExceptions[i].isInstance(f.getException())) {
+                throw new AssertionError(
+                        "Actual failure #"
+                                + (i + 1)
+                                + " should be of type: "
+                                + expectedExceptions[i].getSimpleName()
+                                + " but is of type: "
+                                + f.getException().getClass().getSimpleName()
+                                + "\n"
+                                + formatFailures(result.getFailures()));
+            }
+            i++;
+        }
+        return this;
+    }
+
+    /**
+     * Expects single failure with specific exception and exception message.
+     * Automatically filters line numbers from exception messages.
+     */
+    public JUnitResultAssert fails(Class expectedException, String exceptionMessage) {
+        fails(1, expectedException);
+        Failure f = firstOf(result.getFailures());
+        assertEquals(filterLineNo(exceptionMessage), filterLineNo(f.getException().getMessage()));
+        return this;
+    }
+
+    /**
+     * Expects failure of given test method with given exception
+     */
+    public JUnitResultAssert fails(String methodName, Class expectedException) {
+        for (Failure f : result.getFailures()) {
+            if (methodName.equals(f.getDescription().getMethodName())
+                    && expectedException.isInstance(f.getException())) {
+                return this;
+            }
+        }
+        throw new AssertionError(
+                "Method '"
+                        + methodName
+                        + "' did not fail with: "
+                        + expectedException.getSimpleName()
+                        + "\n"
+                        + formatFailures(result.getFailures()));
+    }
+
+    /**
+     * Expects given amount of failures, with given exception triggered by given test method
+     */
+    public JUnitResultAssert fails(
+            int expectedFailureCount, String methodName, Class expectedException) {
+        return fails(expectedFailureCount, expectedException).fails(methodName, expectedException);
+    }
+
+    public JUnitResultAssert succeeds(int successCount) {
+        int i = result.getRunCount() - result.getFailureCount();
+        if (i != successCount) {
+            throw new AssertionError(
+                    "Expected "
+                            + successCount
+                            + " passes but "
+                            + i
+                            + "/"
+                            + result.getRunCount()
+                            + " passed."
+                            + "\n"
+                            + formatFailures(result.getFailures()));
+        }
+        return this;
+    }
+
+    private static String formatFailures(List<Failure> failures) {
+        if (failures.isEmpty()) {
+            return "<no failures>";
+        }
+        StringBuilder sb = new StringBuilder("There were " + failures.size() + " test failures:\n");
+        int count = 0;
+        for (Failure f : failures) {
+            sb.append("  <-----> ").append(++count).append(". ").append(f.getTrace()).append("\n");
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Clean assertions for JUnit's result object
+     */
+    public static JUnitResultAssert assertThat(Result result) {
+        return new JUnitResultAssert(result);
+    }
+}
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/SafeJUnitRule.java b/mockito-core/src/testFixtures/java/org/mockitoutil/SafeJUnitRule.java
new file mode 100644
index 0000000000..701c3eb443
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/SafeJUnitRule.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import org.assertj.core.api.AbstractThrowableAssert;
+import org.assertj.core.api.Assertions;
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+/**
+ * Junit rule for testing exception handling other JUnit rules, like Mockito JUnit rules.
+ * Makes it easy to assert on expected exceptions triggered by the rule under test.
+ */
+public class SafeJUnitRule implements MethodRule {
+
+    private final MethodRule testedRule;
+    private FailureAssert failureAssert = null;
+    private Runnable successAssert =
+            new Runnable() {
+                public void run() {}
+            };
+
+    /**
+     * Wraps rule under test with exception handling so that it is easy to assert on exceptions fired from the tested rule.
+     */
+    public SafeJUnitRule(MethodRule testedRule) {
+        this.testedRule = testedRule;
+    }
+
+    public Statement apply(
+            final Statement base, final FrameworkMethod method, final Object target) {
+        return new Statement() {
+            public void evaluate() throws Throwable {
+                try {
+                    testedRule.apply(base, method, target).evaluate();
+                    successAssert.run();
+                } catch (Throwable t) {
+                    if (failureAssert == null) {
+                        throw t;
+                    }
+                    failureAssert.doAssert(t);
+                    return;
+                }
+                if (failureAssert != null) {
+                    // looks like the user expects a throwable but it was not thrown!
+                    throw new ExpectedThrowableNotReported(
+                            "Expected the tested rule to throw an exception but it did not.");
+                }
+            }
+        };
+    }
+
+    /**
+     * Expects that _after_ the test, the rule will fire specific exception with specific exception message
+     */
+    public void expectFailure(
+            final Class<? extends Throwable> expected, final String expectedMessage) {
+        this.expectFailure(
+                new FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertThrowable(t, expected).hasMessage(expectedMessage);
+                    }
+                });
+    }
+
+    /**
+     * Expects that _after_ the test, the rule will fire specific exception with specific exception message
+     */
+    public void expectFailure(final Class<? extends Throwable> expected) {
+        this.expectFailure(
+                new FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        assertThrowable(t, expected);
+                    }
+                });
+    }
+
+    private static AbstractThrowableAssert assertThrowable(
+            Throwable throwable, Class<? extends Throwable> expected) {
+        return Assertions.assertThat(throwable).isInstanceOf(expected);
+    }
+
+    /**
+     * Expects that _after_ the test, the rule will fire an exception
+     */
+    public void expectFailure(FailureAssert failureAssert) {
+        this.failureAssert = failureAssert;
+    }
+
+    /**
+     * Expects that _after_ the test, given assert will run
+     */
+    public void expectSuccess(Runnable successAssert) {
+        this.successAssert = successAssert;
+    }
+
+    /**
+     * Offers a way to assert the throwable triggered by the tested rule
+     */
+    public interface FailureAssert {
+        void doAssert(Throwable t);
+    }
+
+    /**
+     * Thrown when user expects the tested rule to throw an exception but no exception was thrown
+     */
+    class ExpectedThrowableNotReported extends Throwable {
+        public ExpectedThrowableNotReported(String message) {
+            super(message);
+        }
+    }
+}
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/SafeJUnitRuleTest.java b/mockito-core/src/testFixtures/java/org/mockitoutil/SafeJUnitRuleTest.java
new file mode 100644
index 0000000000..cfc4dd1c4a
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/SafeJUnitRuleTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class SafeJUnitRuleTest {
+
+    MethodRuleStub delegate = new MethodRuleStub();
+    SafeJUnitRule rule = new SafeJUnitRule(delegate);
+
+    @Test
+    public void happy_path_no_exception() throws Throwable {
+        // when
+        rule.apply(
+                        new Statement() {
+                            public void evaluate() {
+                                // all good
+                            }
+                        },
+                        mock(FrameworkMethod.class),
+                        this)
+                .evaluate();
+
+        // then
+        assertTrue(delegate.statementEvaluated);
+    }
+
+    @Test
+    public void regular_failing_test() {
+        // given
+        Statement baseStatement =
+                new Statement() {
+                    public void evaluate() {
+                        throw new IllegalArgumentException();
+                    }
+                };
+        Statement statement = rule.apply(baseStatement, mock(FrameworkMethod.class), this);
+
+        // when / then
+        assertThatThrownBy(
+                        () -> {
+                            statement.evaluate();
+                        })
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void rule_threw_exception() throws Throwable {
+        // expect
+        rule.expectFailure(AssertionError.class, "x");
+
+        // when
+        rule.apply(
+                        new Statement() {
+                            public void evaluate() {
+                                throw new AssertionError("x");
+                            }
+                        },
+                        mock(FrameworkMethod.class),
+                        this)
+                .evaluate();
+    }
+
+    @Test
+    public void expected_exception_but_no_exception() throws Throwable {
+        // expect
+        rule.expectFailure(AssertionError.class, "x");
+
+        // when
+        try {
+            rule.apply(
+                            new Statement() {
+                                public void evaluate() {
+                                    // all good
+                                }
+                            },
+                            mock(FrameworkMethod.class),
+                            this)
+                    .evaluate();
+            fail();
+
+            // then
+        } catch (SafeJUnitRule.ExpectedThrowableNotReported t) {
+            // yup, expected
+        }
+    }
+
+    @Test
+    public void expected_exception_message_did_not_match() throws Throwable {
+        // expect
+        rule.expectFailure(AssertionError.class, "FOO");
+
+        // when
+        try {
+            rule.apply(
+                            new Statement() {
+                                public void evaluate() {
+                                    throw new AssertionError("BAR");
+                                }
+                            },
+                            mock(FrameworkMethod.class),
+                            this)
+                    .evaluate();
+            fail();
+        } catch (AssertionError throwable) {
+            Assertions.assertThat(throwable).hasMessageContaining("Expecting message");
+        }
+    }
+
+    @Test
+    public void expected_exception_type_did_not_match() throws Throwable {
+        // expect
+        rule.expectFailure(AssertionError.class, "x");
+
+        // when
+        try {
+            rule.apply(
+                            new Statement() {
+                                public void evaluate() {
+                                    throw new RuntimeException("x");
+                                }
+                            },
+                            mock(FrameworkMethod.class),
+                            this)
+                    .evaluate();
+            fail();
+        } catch (AssertionError throwable) {
+            Assertions.assertThat(throwable).hasMessageContaining("but was:");
+        }
+    }
+
+    @Test
+    public void expected_exception_assert_did_not_match() throws Throwable {
+        // expect
+        rule.expectFailure(
+                new SafeJUnitRule.FailureAssert() {
+                    public void doAssert(Throwable t) {
+                        throw new AssertionError("x");
+                    }
+                });
+
+        // when
+        try {
+            rule.apply(
+                            new Statement() {
+                                public void evaluate() {
+                                    throw new RuntimeException();
+                                }
+                            },
+                            mock(FrameworkMethod.class),
+                            this)
+                    .evaluate();
+            fail();
+        } catch (AssertionError throwable) {
+            assertEquals(throwable.getMessage(), "x");
+        }
+    }
+
+    private static class MethodRuleStub implements MethodRule {
+        private boolean statementEvaluated;
+
+        public Statement apply(final Statement base, FrameworkMethod method, Object target) {
+            return new Statement() {
+                public void evaluate() throws Throwable {
+                    statementEvaluated = true;
+                    base.evaluate();
+                }
+            };
+        }
+    }
+}
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/SimpleClassGenerator.java b/mockito-core/src/testFixtures/java/org/mockitoutil/SimpleClassGenerator.java
new file mode 100644
index 0000000000..9ec5194471
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/SimpleClassGenerator.java
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import net.bytebuddy.ByteBuddy;
+
+public class SimpleClassGenerator {
+
+    public static byte[] makeMarkerInterface(String qualifiedName) {
+        return new ByteBuddy().makeInterface().name(qualifiedName).make().getBytes();
+    }
+}
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/SimplePerRealmReloadingClassLoader.java b/mockito-core/src/testFixtures/java/org/mockitoutil/SimplePerRealmReloadingClassLoader.java
new file mode 100644
index 0000000000..7e3c25a2d3
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/SimplePerRealmReloadingClassLoader.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import java.lang.StackWalker.StackFrame;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+/**
+ * Custom classloader to load classes in hierarchic realm.
+ * <p>
+ * Each class can be reloaded in the realm if the LoadClassPredicate says so.
+ */
+public class SimplePerRealmReloadingClassLoader extends URLClassLoader {
+
+    private final Map<String, Class<?>> classHashMap = new HashMap<String, Class<?>>();
+    private ReloadClassPredicate reloadClassPredicate;
+
+    public SimplePerRealmReloadingClassLoader(ReloadClassPredicate reloadClassPredicate) {
+        super(getPossibleClassPathsUrls());
+        this.reloadClassPredicate = reloadClassPredicate;
+    }
+
+    public SimplePerRealmReloadingClassLoader(
+            ClassLoader parentClassLoader, ReloadClassPredicate reloadClassPredicate) {
+        super(getPossibleClassPathsUrls(), parentClassLoader);
+        this.reloadClassPredicate = reloadClassPredicate;
+    }
+
+    private static URL[] getPossibleClassPathsUrls() {
+        return new URL[] {
+            obtainThisClassPath(),
+            detectCallerClassPath(),
+            obtainClassPath("org.mockito.Mockito"),
+            obtainClassPath("net.bytebuddy.ByteBuddy")
+        };
+    }
+
+    private static URL obtainThisClassPath() {
+        String className = SimplePerRealmReloadingClassLoader.class.getName();
+        return obtainClassPath(className);
+    }
+
+    private static URL detectCallerClassPath() {
+        StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
+        // skip getPossibleClassPathsUrls, detectCallerClassPath and constructor
+        int skippedFrames = 3;
+        Class<?> aClass =
+                walker.walk(
+                                frames ->
+                                        frames.peek(System.out::println)
+                                                .skip(skippedFrames)
+                                                .findFirst())
+                        .map(StackFrame::getDeclaringClass)
+                        .orElseThrow(() -> new RuntimeException("Couldn't detect caller class"));
+
+        return obtainClassPath(aClass.getName());
+    }
+
+    private static URL obtainClassPath(String className) {
+        String path = className.replace('.', '/') + ".class";
+        String url =
+                SimplePerRealmReloadingClassLoader.class
+                        .getClassLoader()
+                        .getResource(path)
+                        .toExternalForm();
+
+        try {
+            return new URL(url.substring(0, url.length() - path.length()));
+        } catch (MalformedURLException e) {
+            throw new RuntimeException("Classloader couldn't obtain a proper classpath URL", e);
+        }
+    }
+
+    @Override
+    public Class<?> loadClass(String qualifiedClassName) throws ClassNotFoundException {
+        if (reloadClassPredicate.acceptReloadOf(qualifiedClassName)) {
+            // return customLoadClass(qualifiedClassName);
+            //            Class<?> loadedClass = findLoadedClass(qualifiedClassName);
+            if (!classHashMap.containsKey(qualifiedClassName)) {
+                Class<?> foundClass = findClass(qualifiedClassName);
+                saveFoundClass(qualifiedClassName, foundClass);
+                return foundClass;
+            }
+
+            return classHashMap.get(qualifiedClassName);
+        }
+        return useParentClassLoaderFor(qualifiedClassName);
+    }
+
+    private void saveFoundClass(String qualifiedClassName, Class<?> foundClass) {
+        classHashMap.put(qualifiedClassName, foundClass);
+    }
+
+    private Class<?> useParentClassLoaderFor(String qualifiedName) throws ClassNotFoundException {
+        return super.loadClass(qualifiedName);
+    }
+
+    public Object doInRealm(String callableCalledInClassLoaderRealm) throws Exception {
+        ClassLoader current = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(this);
+            Object instance =
+                    this.loadClass(callableCalledInClassLoaderRealm).getConstructor().newInstance();
+            if (instance instanceof Callable) {
+                Callable<?> callableInRealm = (Callable<?>) instance;
+                return callableInRealm.call();
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(current);
+        }
+        throw new IllegalArgumentException(
+                "qualified name '"
+                        + callableCalledInClassLoaderRealm
+                        + "' should represent a class implementing Callable");
+    }
+
+    public Object doInRealm(
+            String callableCalledInClassLoaderRealm, Class<?>[] argTypes, Object[] args)
+            throws Exception {
+        ClassLoader current = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(this);
+            Object instance =
+                    this.loadClass(callableCalledInClassLoaderRealm)
+                            .getConstructor(argTypes)
+                            .newInstance(args);
+            if (instance instanceof Callable) {
+                Callable<?> callableInRealm = (Callable<?>) instance;
+                return callableInRealm.call();
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(current);
+        }
+
+        throw new IllegalArgumentException(
+                "qualified name '"
+                        + callableCalledInClassLoaderRealm
+                        + "' should represent a class implementing Callable");
+    }
+
+    public interface ReloadClassPredicate {
+        boolean acceptReloadOf(String qualifiedName);
+    }
+}
diff --git a/src/test/java/org/mockitoutil/SimpleSerializationUtil.java b/mockito-core/src/testFixtures/java/org/mockitoutil/SimpleSerializationUtil.java
similarity index 75%
rename from src/test/java/org/mockitoutil/SimpleSerializationUtil.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/SimpleSerializationUtil.java
index 152b54d042..fd336e0348 100644
--- a/src/test/java/org/mockitoutil/SimpleSerializationUtil.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/SimpleSerializationUtil.java
@@ -6,24 +6,30 @@
 
 import static org.junit.Assert.assertNotNull;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 
 public abstract class SimpleSerializationUtil {
 
-    //TODO use widely
+    // TODO use widely
     @SuppressWarnings("unchecked")
     public static <T> T serializeAndBack(T obj) throws Exception {
         ByteArrayOutputStream os = serializeMock(obj);
         return (T) deserializeMock(os, Object.class);
     }
 
-    public static <T> T deserializeMock(ByteArrayOutputStream serialized, Class<T> type) throws IOException,
-            ClassNotFoundException {
+    public static <T> T deserializeMock(ByteArrayOutputStream serialized, Class<T> type)
+            throws IOException, ClassNotFoundException {
         InputStream unserialize = new ByteArrayInputStream(serialized.toByteArray());
         return deserializeMock(unserialize, type);
     }
 
-    public static <T> T deserializeMock(InputStream unserialize, Class<T> type) throws IOException, ClassNotFoundException {
+    public static <T> T deserializeMock(InputStream unserialize, Class<T> type)
+            throws IOException, ClassNotFoundException {
         Object readObject = new ObjectInputStream(unserialize).readObject();
         assertNotNull(readObject);
         return type.cast(readObject);
diff --git a/src/test/java/org/mockitoutil/Stopwatch.java b/mockito-core/src/testFixtures/java/org/mockitoutil/Stopwatch.java
similarity index 75%
rename from src/test/java/org/mockitoutil/Stopwatch.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/Stopwatch.java
index 7c9e5c80a3..5c0ea2d1bf 100644
--- a/src/test/java/org/mockitoutil/Stopwatch.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/Stopwatch.java
@@ -25,8 +25,7 @@ public class Stopwatch {
     /**
      * To create an instance use {@link #createNotStarted()}
      */
-    private Stopwatch() {
-    }
+    private Stopwatch() {}
 
     /**
      * Return a new and not started {@link Stopwatch}.
@@ -47,7 +46,9 @@ public void assertElapsedTimeIsMoreThan(long expected, TimeUnit unit) {
         long expectedNanos = unit.toNanos(expected);
 
         if (elapsedNanos <= expectedNanos)
-            fail("Expected that more than %dms elapsed! But was: %dms", expectedNanos, elapsedNanos);
+            fail(
+                    "Expected that more than %dms elapsed! But was: %dms",
+                    expectedNanos, elapsedNanos);
     }
 
     public void assertElapsedTimeIsLessThan(long expected, TimeUnit unit) {
@@ -55,17 +56,22 @@ public void assertElapsedTimeIsLessThan(long expected, TimeUnit unit) {
         long expectedNanos = unit.toNanos(expected);
 
         if (elapsedNanos >= expectedNanos)
-            fail("Expected that less than %dms elapsed! But was: %dms", expectedNanos, elapsedNanos);
+            fail(
+                    "Expected that less than %dms elapsed! But was: %dms",
+                    expectedNanos, elapsedNanos);
     }
 
     private long elapsedNanos() {
-        if (startNanos == null)
-            throw new IllegalStateException("This stop watch is not started!");
+        if (startNanos == null) throw new IllegalStateException("This stop watch is not started!");
         return nanoTime() - startNanos;
     }
 
     private static void fail(String message, long expectedNanos, long elapsedNanos) {
-        throw new MockitoAssertionError(format(message, NANOSECONDS.toMillis(expectedNanos), NANOSECONDS.toMillis(elapsedNanos)));
+        throw new MockitoAssertionError(
+                format(
+                        message,
+                        NANOSECONDS.toMillis(expectedNanos),
+                        NANOSECONDS.toMillis(elapsedNanos)));
     }
 
     /**
diff --git a/src/test/java/org/mockitoutil/TestBase.java b/mockito-core/src/testFixtures/java/org/mockitoutil/TestBase.java
similarity index 81%
rename from src/test/java/org/mockitoutil/TestBase.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/TestBase.java
index fdd1231c54..3f772d020b 100644
--- a/src/test/java/org/mockitoutil/TestBase.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/TestBase.java
@@ -17,7 +17,7 @@
 import org.mockito.StateMaster;
 import org.mockito.internal.MockitoCore;
 import org.mockito.internal.configuration.ConfigurationAccess;
-import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.debugging.LocationFactory;
 import org.mockito.internal.invocation.InterceptedInvocation;
 import org.mockito.internal.invocation.InvocationBuilder;
 import org.mockito.internal.invocation.InvocationMatcher;
@@ -48,16 +48,17 @@ public void cleanUpConfigInAnyCase() {
         ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
         ConfigurationAccess.getConfig().overrideDefaultAnswer(null);
         StateMaster state = new StateMaster();
-        //catch any invalid state left over after test case run
-        //this way we can catch early if some Mockito operations leave weird state afterwards
+        // catch any invalid state left over after test case run
+        // this way we can catch early if some Mockito operations leave weird state afterwards
         state.validate();
-        //reset the state, especially, reset any ongoing stubbing for correct error messages of tests that assert unhappy paths
+        // reset the state, especially, reset any ongoing stubbing for correct error messages of
+        // tests that assert unhappy paths
         state.reset();
     }
 
     @Before
     public void init() {
-        MockitoAnnotations.initMocks(this);
+        MockitoAnnotations.openMocks(this);
     }
 
     public static void makeStackTracesClean() {
@@ -72,14 +73,19 @@ public static Invocation getLastInvocation() {
         return new MockitoCore().getLastInvocation();
     }
 
-    protected static Invocation invocationOf(Class<?> type, String methodName, Object ... args) throws NoSuchMethodException {
+    protected static Invocation invocationOf(Class<?> type, String methodName, Object... args)
+            throws NoSuchMethodException {
         Class<?>[] types = new Class<?>[args.length];
         for (int i = 0; i < args.length; i++) {
             types[i] = args[i].getClass();
         }
-        return new InterceptedInvocation(new MockStrongReference<Object>(mock(type), false),
-            new SerializableMethod(type.getMethod(methodName, types)), args, InterceptedInvocation.NO_OP,
-            new LocationImpl(), 1);
+        return new InterceptedInvocation(
+                new MockStrongReference<Object>(mock(type), false),
+                new SerializableMethod(type.getMethod(methodName, types)),
+                args,
+                InterceptedInvocation.NO_OP,
+                LocationFactory.create(),
+                1);
     }
 
     protected static Invocation invocationAt(String location) {
@@ -95,7 +101,8 @@ protected String getStackTrace(Throwable e) {
         e.printStackTrace(new PrintStream(out));
         try {
             out.close();
-        } catch (IOException ex) {}
+        } catch (IOException ex) {
+        }
         return out.toString();
     }
 
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/TestBaseTest.java b/mockito-core/src/testFixtures/java/org/mockitoutil/TestBaseTest.java
new file mode 100644
index 0000000000..aa98f33e75
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/TestBaseTest.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class TestBaseTest extends TestBase {
+
+    @Test
+    public void filters_line_no_from_stack_trace() {
+        assertEquals("", filterLineNo(""));
+        assertEquals("asdf", filterLineNo("asdf"));
+        assertEquals("asdf (FooBar.java:0) blah", filterLineNo("asdf (FooBar.java:23) blah"));
+        assertEquals(
+                "asdf\n(FooBar.java:0)\nblah", filterLineNo("asdf\n(FooBar.java:123123)\nblah"));
+        assertEquals(
+                "asdf\n(FooBar.java:0)\n(Xxx.java:0)blah",
+                filterLineNo("asdf\n(FooBar.java:2)\n(Xxx.java:1)blah"));
+
+        assertEquals(
+                "asdf\n(FooBar.java:0)\nXxx.java:20)blah",
+                filterLineNo("asdf\n(FooBar.java:2)\nXxx.java:20)blah"));
+    }
+}
diff --git a/src/test/java/org/mockitoutil/ThrowableAssert.java b/mockito-core/src/testFixtures/java/org/mockitoutil/ThrowableAssert.java
similarity index 77%
rename from src/test/java/org/mockitoutil/ThrowableAssert.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/ThrowableAssert.java
index c58ca8e3d9..54c4b27631 100644
--- a/src/test/java/org/mockitoutil/ThrowableAssert.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/ThrowableAssert.java
@@ -24,10 +24,12 @@ private ThrowableAssert(Runnable runnable) {
     }
 
     public ThrowableAssert throwsException(Class<? extends Throwable> exceptionType) {
-        if(!exceptionType.isInstance(reportedException)) {
-            throw new AssertionError("Exception should be of type: "
-                    + exceptionType.getSimpleName() + " but it was: "
-                    + reportedException.getClass().getSimpleName());
+        if (!exceptionType.isInstance(reportedException)) {
+            throw new AssertionError(
+                    "Exception should be of type: "
+                            + exceptionType.getSimpleName()
+                            + " but it was: "
+                            + reportedException.getClass().getSimpleName());
         }
         return this;
     }
diff --git a/src/test/java/org/mockitoutil/VmArgAssumptions.java b/mockito-core/src/testFixtures/java/org/mockitoutil/VmArgAssumptions.java
similarity index 99%
rename from src/test/java/org/mockitoutil/VmArgAssumptions.java
rename to mockito-core/src/testFixtures/java/org/mockitoutil/VmArgAssumptions.java
index 1eba1bdeab..4ab606e65f 100644
--- a/src/test/java/org/mockitoutil/VmArgAssumptions.java
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/VmArgAssumptions.java
@@ -28,5 +28,4 @@ private static boolean assertEnabled(String vmArg) {
         }
         return false;
     }
-
 }
diff --git a/mockito-core/src/testFixtures/java/org/mockitoutil/async/AsyncTesting.java b/mockito-core/src/testFixtures/java/org/mockitoutil/async/AsyncTesting.java
new file mode 100644
index 0000000000..855d3fbd11
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/async/AsyncTesting.java
@@ -0,0 +1,86 @@
+/*
+ * 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)
+ *
+ * //TODO convert to test rule
+ */
+public class AsyncTesting {
+
+    // Sanity limit of threas. Increase it if justified.
+    private static final int MAX_THREADS = 4;
+
+    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/mockito-core/src/testFixtures/java/org/mockitoutil/async/AsyncTestingTest.java b/mockito-core/src/testFixtures/java/org/mockitoutil/async/AsyncTestingTest.java
new file mode 100644
index 0000000000..e6d7cdf564
--- /dev/null
+++ b/mockito-core/src/testFixtures/java/org/mockitoutil/async/AsyncTestingTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoutil.async;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockitoutil.Stopwatch.createNotStarted;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockitoutil.Stopwatch;
+
+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/mockito-extensions/mockito-android/build.gradle.kts b/mockito-extensions/mockito-android/build.gradle.kts
new file mode 100644
index 0000000000..58c61f11af
--- /dev/null
+++ b/mockito-extensions/mockito-android/build.gradle.kts
@@ -0,0 +1,15 @@
+plugins {
+    id("mockito.java-library-conventions")
+    id("mockito.publication-conventions")
+}
+
+description = "Mockito for Android"
+
+dependencies {
+    api(project(":mockito-core"))
+    implementation(libs.bytebuddy.android)
+}
+
+tasks.javadoc {
+    isEnabled = false
+}
diff --git a/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java b/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java
new file mode 100644
index 0000000000..3cf42e310f
--- /dev/null
+++ b/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.android.internal.creation;
+
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker;
+import org.mockito.internal.util.Platform;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockMaker;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+public class AndroidByteBuddyMockMaker implements MockMaker {
+
+    private final MockMaker delegate;
+
+    public AndroidByteBuddyMockMaker() {
+        if (Platform.isAndroid() || Platform.isAndroidMockMakerRequired()) {
+            delegate = new SubclassByteBuddyMockMaker(new AndroidLoadingStrategy());
+        } else {
+            Plugins.getMockitoLogger()
+                    .log(
+                            join(
+                                    "IMPORTANT NOTE FROM MOCKITO:",
+                                    "",
+                                    "You included the 'mockito-android' dependency in a non-Android environment.",
+                                    "The Android mock maker was disabled. You should only include the latter in your 'androidTestCompile' configuration",
+                                    "If disabling was a mistake, you can set the 'org.mockito.mock.android' property to 'true' to override this detection.",
+                                    "",
+                                    "Visit https://javadoc.io/page/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html#0.1 for more information"));
+            delegate = new SubclassByteBuddyMockMaker();
+        }
+    }
+
+    @Override
+    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+        return delegate.createMock(settings, handler);
+    }
+
+    @Override
+    public MockHandler getHandler(Object mock) {
+        return delegate.getHandler(mock);
+    }
+
+    @Override
+    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+        delegate.resetMock(mock, newHandler, settings);
+    }
+
+    @Override
+    public TypeMockability isTypeMockable(Class<?> type) {
+        return delegate.isTypeMockable(type);
+    }
+
+    @Override
+    public void clearAllCaches() {
+        delegate.clearAllCaches();
+    }
+}
diff --git a/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java b/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java
new file mode 100644
index 0000000000..01bea0a5a3
--- /dev/null
+++ b/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.android.internal.creation;
+
+import net.bytebuddy.android.AndroidClassLoadingStrategy;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.bytebuddy.ModuleHandler;
+
+import java.io.File;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+class AndroidLoadingStrategy extends ModuleHandler.NoModuleSystemFound {
+
+    @Override
+    public ClassLoadingStrategy<ClassLoader> classLoadingStrategy() {
+        File target = AndroidTempFileLocator.target;
+        if (target == null) {
+            throw new MockitoException(
+                    join(
+                            "Could not look up implicit location for storing generated classes",
+                            "",
+                            "You can configure an explicit location by setting the system property",
+                            "'org.mockito.android.target' to a folder for storing generated class files",
+                            "This location must be in private scope for most API versions, for example:",
+                            "",
+                            "MyActivity.this.getDir(\"target\", Context.MODE_PRIVATE)",
+                            "or",
+                            "getInstrumentation().getTargetContext().getCacheDir().getPath()"));
+        }
+        return new AndroidClassLoadingStrategy.Injecting(target);
+    }
+}
diff --git a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java b/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java
similarity index 91%
rename from subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java
rename to mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java
index 4d193ba8c4..37cad83592 100644
--- a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java
+++ b/mockito-extensions/mockito-android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java
@@ -11,7 +11,7 @@
 
 class AndroidTempFileLocator {
 
-    final static File target;
+    static final File target;
 
     static {
         File t = null;
@@ -23,7 +23,9 @@ class AndroidTempFileLocator {
         } catch (Throwable ignored) {
         }
         if (t == null) {
-            t = getCacheDirFromInstrumentationRegistry("android.support.test.InstrumentationRegistry");
+            t =
+                    getCacheDirFromInstrumentationRegistry(
+                            "android.support.test.InstrumentationRegistry");
         }
         if (t == null) {
             t = getCacheDirFromInstrumentationRegistry("androidx.test.InstrumentationRegistry");
@@ -33,7 +35,8 @@ class AndroidTempFileLocator {
                 Class<?> clazz = Class.forName("dalvik.system.PathClassLoader");
                 Field pathField = clazz.getDeclaredField("path");
                 pathField.setAccessible(true);
-                String pathFromThisClassLoader = (String) pathField.get(AndroidTempFileLocator.class.getClassLoader());
+                String pathFromThisClassLoader =
+                        (String) pathField.get(AndroidTempFileLocator.class.getClassLoader());
                 File[] results = guessPath(pathFromThisClassLoader);
                 if (results.length > 0) {
                     t = results[0];
diff --git a/mockito-extensions/mockito-android/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor b/mockito-extensions/mockito-android/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
new file mode 100644
index 0000000000..71111e3378
--- /dev/null
+++ b/mockito-extensions/mockito-android/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
@@ -0,0 +1 @@
+member-accessor-reflection
diff --git a/subprojects/android/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-extensions/mockito-android/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
similarity index 100%
rename from subprojects/android/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
rename to mockito-extensions/mockito-android/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
diff --git a/mockito-extensions/mockito-android/src/test/README.md b/mockito-extensions/mockito-android/src/test/README.md
new file mode 100644
index 0000000000..029eea2266
--- /dev/null
+++ b/mockito-extensions/mockito-android/src/test/README.md
@@ -0,0 +1 @@
+Tests are located in `:mockito-extensions:android-tests` subproject.
diff --git a/mockito-extensions/mockito-errorprone/build.gradle.kts b/mockito-extensions/mockito-errorprone/build.gradle.kts
new file mode 100644
index 0000000000..16751515c5
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/build.gradle.kts
@@ -0,0 +1,57 @@
+plugins {
+    id("mockito.library-conventions")
+}
+
+description = "ErrorProne plugins for Mockito"
+
+dependencies {
+    compileOnly(libs.autoservice)
+    annotationProcessor(libs.autoservice)
+
+    implementation(project(":mockito-core"))
+    implementation(libs.errorprone)
+
+    testImplementation("junit:junit:4.13.2")
+    testImplementation(libs.errorprone.test.api)
+}
+
+tasks {
+    test {
+        inputs.files(configurations.errorproneJavac).withNormalizer(ClasspathNormalizer::class)
+        jvmArgumentProviders.add(
+            CommandLineArgumentProvider {
+                listOf(
+                    "-Xbootclasspath/a:${configurations.errorproneJavac.get().asPath}",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.type=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+                    "--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
+                )
+            }
+        )
+    }
+
+    withType<JavaCompile> {
+        options.compilerArgs.addAll(
+            listOf(
+                "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+                "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+                "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
+            )
+        )
+    }
+
+    withType<Javadoc> {
+        javadocDocletOptions {
+            addBooleanOption(
+                "-add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+                true
+            )
+        }
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/AbstractMockitoAnyForPrimitiveType.java b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/AbstractMockitoAnyForPrimitiveType.java
new file mode 100644
index 0000000000..ac6ecdece8
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/AbstractMockitoAnyForPrimitiveType.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import static com.google.errorprone.matchers.Description.NO_MATCH;
+
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Symbol.VarSymbol;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Type.ArrayType;
+import java.util.List;
+import javax.lang.model.type.TypeKind;
+
+/** Base for {@link BugChecker}s that detect issues with any() matchers and primitive types. */
+public abstract class AbstractMockitoAnyForPrimitiveType extends BugChecker
+        implements MethodInvocationTreeMatcher {
+
+    protected abstract Matcher<? super MethodInvocationTree> matcher();
+
+    protected abstract String formatMessage(
+            String expectedTypeAsString, Type matcherType, String replacementName);
+
+    @Override
+    public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+        if (!matcher().matches(tree, state)) {
+            return NO_MATCH;
+        }
+
+        MethodSymbol method = ASTHelpers.getSymbol(tree);
+        Type matcherType = method.getReturnType();
+
+        // It is expected that the call to anyX() is itself the argument to another call which is
+        // the one being mocked, e.g. something like this:
+        //   when(mock.call(..., anyInt(), ...))...
+        TreePath path = state.getPath();
+        Tree parentTree = path.getParentPath().getLeaf();
+        if (!(parentTree instanceof MethodInvocationTree)) {
+            // Ignore calls that are not arguments to another method call.
+            // TODO: Report this as a problem because it makes little sense.
+            // TODO: Support casting.
+            return NO_MATCH;
+        }
+
+        MethodInvocationTree parentCall = (MethodInvocationTree) parentTree;
+        MethodSymbol parentMethod = ASTHelpers.getSymbol(parentCall);
+
+        // Find the index of the argument in the parent call.
+        int argumentIndex = -1;
+        List<? extends ExpressionTree> parentArguments = parentCall.getArguments();
+        for (int i = 0; i < parentArguments.size(); i++) {
+            ExpressionTree argumentTree = parentArguments.get(i);
+            if (argumentTree == tree) {
+                argumentIndex = i;
+                break;
+            }
+        }
+        if (argumentIndex == -1) {
+            throw new IllegalStateException(
+                    "Cannot find argument "
+                            + state.getSourceForNode(tree)
+                            + " in argument list from "
+                            + state.getSourceForNode(parentTree));
+        }
+
+        Type parameterType = getParameterType(parentMethod, argumentIndex);
+
+        TypeKind parameterTypeKind = parameterType.getKind();
+        if (parameterTypeKind.isPrimitive() && parameterTypeKind != matcherType.getKind()) {
+            String expectedTypeAsString = parameterType.toString();
+            String replacementName =
+                    "any"
+                            + Character.toUpperCase(expectedTypeAsString.charAt(0))
+                            + expectedTypeAsString.substring(1);
+
+            String message = formatMessage(expectedTypeAsString, matcherType, replacementName);
+
+            SuggestedFix.Builder fixBuilder = SuggestedFix.builder();
+
+            ExpressionTree methodSelect = tree.getMethodSelect();
+            String replacement;
+            if (methodSelect instanceof MemberSelectTree) {
+                MemberSelectTree qualifier = (MemberSelectTree) methodSelect;
+                replacement =
+                        state.getSourceForNode(qualifier.getExpression()) + "." + replacementName;
+            } else {
+                replacement = replacementName;
+                String staticImport = method.owner + "." + replacementName;
+                fixBuilder.addStaticImport(staticImport);
+            }
+
+            SuggestedFix fix = fixBuilder.replace(tree, replacement + "()").build();
+
+            return buildDescription(tree).setMessage(message).addFix(fix).build();
+        }
+
+        return NO_MATCH;
+    }
+
+    /**
+     * Get the type of the parameter for a supplied argument.
+     *
+     * @param method the method symbol that is being called.
+     * @param argumentIndex the index of the argument, can be greater than the number of parameters
+     *     for a var arg method.
+     * @return the type of the associated parameter.
+     */
+    private Type getParameterType(MethodSymbol method, int argumentIndex) {
+        List<VarSymbol> parameters = method.getParameters();
+        Type parameterType;
+        int parameterCount = parameters.size();
+        if (argumentIndex >= parameterCount && method.isVarArgs()) {
+            VarSymbol varArgParameter = parameters.get(parameterCount - 1);
+            parameterType = ((ArrayType) varArgParameter.asType()).getComponentType();
+        } else {
+            parameterType = parameters.get(argumentIndex).asType();
+        }
+        return parameterType;
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveType.java b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveType.java
new file mode 100644
index 0000000000..583fe0208e
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveType.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.matchers.Matchers;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Type;
+
+/**
+ * Matches on usage of {@code Mockito.argThat(Matcher)} with a matcher that does not extend
+ * ArgumentMatcher.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+        name = "MockitoAnyClassWithPrimitiveType",
+        summary = "Matcher inconsistency: use of any(Class) to match a primitive argument",
+        severity = WARNING,
+        linkType = CUSTOM,
+        link = "site.mockito.org/usage/bugpattern/MockitoAnyClassWithPrimitiveType",
+        explanation =
+                "Mockito relies on Java type checking to ensure that parameter matchers are"
+                        + " type safe but there are some discrepancies between what the Java type checker"
+                        + " allows and what Mockito expects. e.g. Java will allow anyInt() to be used as a"
+                        + " matcher for a long parameter because an int can be widened to a long. This"
+                        + " checker highlights those incorrect usages and suggests replacements. In Mockito"
+                        + " 1.x this was not really an issue because the anyX() methods did not do runtime"
+                        + " type checking of the arguments but in Mockito 2.x they do.")
+public class MockitoAnyClassWithPrimitiveType extends AbstractMockitoAnyForPrimitiveType {
+
+    private static final String[] CLASS_NAMES = {
+        "org.mockito.Mockito", "org.mockito.ArgumentMatchers", "org.mockito.Matchers"
+    };
+
+    // Match against the any() or any(Class) methods.
+    private static final Matcher<ExpressionTree> GENERIC_ANY =
+            Matchers.staticMethod().onClassAny(CLASS_NAMES).named("any");
+
+    @Override
+    protected Matcher<? super MethodInvocationTree> matcher() {
+        return GENERIC_ANY;
+    }
+
+    @Override
+    protected String formatMessage(
+            String expectedTypeAsString, Type matcherType, String replacementName) {
+        return String.format(
+                "Matcher mismatch: use %s() matcher to match primitive %s arguments",
+                replacementName, expectedTypeAsString);
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java
new file mode 100644
index 0000000000..6f5fe6f174
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
+import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
+import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.matchers.Matcher;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.tools.javac.code.Type;
+import java.util.regex.Pattern;
+
+/**
+ * Matches on usage of {@code Mockito.argThat(Matcher)} with a matcher that does not extend
+ * ArgumentMatcher.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+        name = "MockitoAnyIncorrectPrimitiveType",
+        summary =
+                "Matcher mismatch: incorrect use of any() or anyX() to match a primitive argument",
+        severity = ERROR,
+        linkType = CUSTOM,
+        link = "site.mockito.org/usage/bugpattern/MockitoAnyIncorrectPrimitiveType",
+        explanation =
+                "Mockito relies on Java type checking to ensure that parameter matchers are"
+                        + " type safe but there are some discrepancies between what the Java type checker"
+                        + " allows and what Mockito expects. e.g. Java will allow anyInt() to be used as a"
+                        + " matcher for a long parameter because an int can be widened to a long. This"
+                        + " checker highlights those incorrect usages and suggests replacements. In Mockito"
+                        + " 1.x this was not really an issue because the anyX() methods did not do runtime"
+                        + " type checking of the arguments but in Mockito 2.x they do."
+                        + " Java will also allow any() to be used within a primitive but any() returns null and"
+                        + " the compiler wraps that call in unboxing which leads to a NPE.")
+public class MockitoAnyIncorrectPrimitiveType extends AbstractMockitoAnyForPrimitiveType {
+
+    // Match against any() or any of the any<x>() methods.
+    private static final Pattern METHOD_NAME_PATTERN =
+            Pattern.compile("any(Boolean|Byte|Char|Double|Float|Int|Long|Short)?");
+
+    private static final String[] CLASS_NAMES = {
+        "org.mockito.ArgumentMatchers", "org.mockito.Mockito", "org.mockito.Matchers"
+    };
+
+    private static final Matcher<ExpressionTree> METHOD_MATCHER =
+            staticMethod()
+                    .onClassAny(CLASS_NAMES)
+                    .withNameMatching(METHOD_NAME_PATTERN)
+                    .withNoParameters();
+
+    @Override
+    protected Matcher<? super MethodInvocationTree> matcher() {
+        return METHOD_MATCHER;
+    }
+
+    @Override
+    protected String formatMessage(
+            String expectedTypeAsString, Type matcherType, String replacementName) {
+        return String.format(
+                "Matcher mismatch: expected matcher for parameter of type '%s',"
+                        + " found matcher for parameter of type '%s'",
+                expectedTypeAsString, matcherType);
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsage.java b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsage.java
new file mode 100644
index 0000000000..05f900bf0b
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsage.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import static com.google.errorprone.matchers.Matchers.packageStartsWith;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.BugPattern.SeverityLevel;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MemberSelectTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Symbol;
+
+/**
+ * {@link com.google.errorprone.bugpatterns.BugChecker} that detects usages of
+ * org.mockito.internal.*
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+        name = "MockitoInternalUsage",
+        summary = "org.mockito.internal.* is a private API and should not be used by clients",
+        explanation =
+                "Classes under `org.mockito.internal.*` are internal implementation details and are"
+                        + " not part of Mockito's public API. Mockito team does not support them, and they"
+                        + " may change at any time. Depending on them may break your code when you upgrade"
+                        + " to new versions of Mockito."
+                        + "This checker ensures that your code will not break with future Mockito upgrades."
+                        + "Mockito's public API is documented at"
+                        + " https://www.javadoc.io/doc/org.mockito/mockito-core/. If you believe that there"
+                        + " is no replacement available in the public API for your use-case, contact the"
+                        + " Mockito team at https://github.com/mockito/mockito/issues.",
+        severity = SeverityLevel.WARNING)
+public class MockitoInternalUsage extends BugChecker implements MemberSelectTreeMatcher {
+
+    private static final Matcher<Tree> INSIDE_MOCKITO = packageStartsWith("org.mockito");
+
+    @Override
+    public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
+        if (INSIDE_MOCKITO.matches(tree, state)) {
+            return Description.NO_MATCH;
+        }
+        Symbol symbol = ASTHelpers.getSymbol(tree);
+        if (symbol != null
+                && symbol.getQualifiedName().toString().startsWith("org.mockito.internal")) {
+            return describeMatch(tree);
+        }
+        return Description.NO_MATCH;
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java
new file mode 100644
index 0000000000..0ca66a3564
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import static com.google.errorprone.matchers.Description.NO_MATCH;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.BugPattern.SeverityLevel;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ClassTree;
+
+/** Finds subclasses of @NotExtensible interfaces. */
+@AutoService(BugChecker.class)
+@BugPattern(
+        name = "MockitoNotExtensible",
+        summary =
+                "Some types that are a part of Mockito public API are not intended to be extended.",
+        explanation =
+                "Some types that are a part of Mockito public API are not intended to be extended."
+                        + " It's because Mockito team needs to be able to add new methods to some types"
+                        + " without breaking compatibility contract. Any type that is not intended"
+                        + " to be extended is annotated with @NotExtensible.",
+        severity = SeverityLevel.ERROR)
+public class MockitoNotExtensible extends BugChecker implements ClassTreeMatcher {
+
+    @Override
+    public Description matchClass(ClassTree tree, VisitorState state) {
+        if (tree.getImplementsClause().stream()
+                .anyMatch(
+                        implementing ->
+                                ASTHelpers.hasAnnotation(
+                                        ASTHelpers.getSymbol(implementing),
+                                        "org.mockito.NotExtensible",
+                                        state))) {
+            return describeMatch(tree);
+        }
+
+        return NO_MATCH;
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveTypeTest.java b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveTypeTest.java
new file mode 100644
index 0000000000..4a42c287b9
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveTypeTest.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Verify that there are no Mockito `any(Class)` matchers for arguments that are primitives.
+ *
+ * @author tvanderlippe@google.com (Tim van der Lippe)
+ */
+@RunWith(JUnit4.class)
+public class MockitoAnyClassWithPrimitiveTypeTest {
+
+    private CompilationTestHelper compilationHelper;
+    private BugCheckerRefactoringTestHelper refactoringHelper;
+
+    @Before
+    public void setUp() {
+        compilationHelper =
+                CompilationTestHelper.newInstance(
+                        MockitoAnyClassWithPrimitiveType.class, getClass());
+        refactoringHelper =
+                BugCheckerRefactoringTestHelper.newInstance(
+                        new MockitoAnyClassWithPrimitiveType(), getClass());
+    }
+
+    @Test
+    public void testPositiveCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.run(any(Integer.class))).thenReturn(5);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.run(any())).thenReturn(5);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.runWithBoth(any(String.class), any())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(int arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, int arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testNegativeCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "import static org.mockito.ArgumentMatchers.anyInt;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    when(foo.run(any(String.class))).thenReturn(5);",
+                        "    when(foo.runWithInt(anyInt())).thenReturn(5);",
+                        "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(String arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithInt(int arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, int arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testPositivesSubclass() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "import static org.mockito.Mockito.any;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.run(any(Integer.class))).thenReturn(5);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.run(any())).thenReturn(5);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.runWithBoth(any(String.class), any())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(int arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, int arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testRefactoring() {
+        refactoringHelper
+                .addInputLines(
+                        "Test.java",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    when(foo.run(any(Integer.class))).thenReturn(5);",
+                        "    when(foo.run(any())).thenReturn(5);",
+                        "    when(foo.runWithBoth(any(String.class), any())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(int arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, long arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .addOutputLines(
+                        "Test.java",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "import static org.mockito.ArgumentMatchers.anyInt;",
+                        "import static org.mockito.ArgumentMatchers.anyLong;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    when(foo.run(anyInt())).thenReturn(5);",
+                        "    when(foo.run(anyInt())).thenReturn(5);",
+                        "    when(foo.runWithBoth(any(String.class), anyLong())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(int arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, long arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveTypeTest.java b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveTypeTest.java
new file mode 100644
index 0000000000..a41310502f
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveTypeTest.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Verify that there are no Mockito `any(Class)` matchers for arguments that are primitives.
+ *
+ * @author tvanderlippe@google.com (Tim van der Lippe)
+ */
+@RunWith(JUnit4.class)
+public class MockitoAnyIncorrectPrimitiveTypeTest {
+
+    private CompilationTestHelper compilationHelper;
+    private BugCheckerRefactoringTestHelper refactoringHelper;
+
+    @Before
+    public void setUp() {
+        compilationHelper =
+                CompilationTestHelper.newInstance(
+                        MockitoAnyIncorrectPrimitiveType.class, getClass());
+        refactoringHelper =
+                BugCheckerRefactoringTestHelper.newInstance(
+                        new MockitoAnyIncorrectPrimitiveType(), getClass());
+    }
+
+    @Test
+    public void testPositiveCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "import static org.mockito.ArgumentMatchers.anyInt;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.run(anyInt())).thenReturn(5);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(long arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, long arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testNegativeCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "import static org.mockito.ArgumentMatchers.anyFloat;",
+                        "import static org.mockito.ArgumentMatchers.anyLong;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    when(foo.runWithInt(anyFloat())).thenReturn(5);",
+                        "    when(foo.runWithBoth(any(String.class), anyLong())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(String arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithInt(float arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, long arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testPositivesSubclass() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "import static org.mockito.Mockito.any;",
+                        "import static org.mockito.Mockito.anyInt;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.run(anyInt())).thenReturn(5);",
+                        "    // BUG: Diagnostic contains:",
+                        "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(long arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, float arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testRefactoring() {
+        refactoringHelper
+                .addInputLines(
+                        "Test.java",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "import static org.mockito.ArgumentMatchers.anyInt;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    when(foo.run(anyInt())).thenReturn(5);",
+                        "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(float arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, long arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .addOutputLines(
+                        "Test.java",
+                        "import static org.mockito.ArgumentMatchers.any;",
+                        "import static org.mockito.ArgumentMatchers.anyFloat;",
+                        "import static org.mockito.ArgumentMatchers.anyInt;",
+                        "import static org.mockito.ArgumentMatchers.anyLong;",
+                        "import static org.mockito.Mockito.mock;",
+                        "import static org.mockito.Mockito.when;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    Foo foo = mock(Foo.class);",
+                        "    when(foo.run(anyFloat())).thenReturn(5);",
+                        "    when(foo.runWithBoth(any(String.class), anyLong())).thenReturn(5);",
+                        "  }",
+                        "  static class Foo {",
+                        "    int run(float arg) {",
+                        "      return 42;",
+                        "    }",
+                        "    int runWithBoth(String arg1, long arg2) {",
+                        "      return 42;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsageTest.java b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsageTest.java
new file mode 100644
index 0000000000..b1467abcba
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsageTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Verify that there are no usages of Mockito internal implementations.
+ *
+ * @author tvanderlippe@google.com (Tim van der Lippe)
+ */
+@RunWith(JUnit4.class)
+public class MockitoInternalUsageTest {
+
+    private CompilationTestHelper compilationHelper;
+
+    @Before
+    public void setUp() {
+        compilationHelper =
+                CompilationTestHelper.newInstance(MockitoInternalUsage.class, getClass());
+    }
+
+    @Test
+    public void testPositiveCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "import java.io.Serializable;",
+                        "class MockitoInternalUsagePositiveCases {",
+                        "  public void newObject() {",
+                        "    // BUG: Diagnostic contains:",
+                        "    new org.mockito.internal.MockitoCore();",
+                        "    // BUG: Diagnostic contains:",
+                        "    new InternalConsumer(new org.mockito.internal.MockitoCore());",
+                        "  }",
+                        "  public void staticMethodInvocation() {",
+                        "    // BUG: Diagnostic contains:",
+                        "    org.mockito.internal.configuration.GlobalConfiguration.validate();",
+                        "  }",
+                        "  public void variableTypeDeclaration() {",
+                        "    // BUG: Diagnostic contains:",
+                        "    org.mockito.internal.stubbing.InvocationContainerImpl container = null;",
+                        "  }",
+                        "  // BUG: Diagnostic contains:",
+                        "  class ExtendsClause extends org.mockito.internal.MockitoCore {}",
+                        "  // BUG: Diagnostic contains:",
+                        "  abstract class ImplementsClause implements"
+                                + " org.mockito.internal.junit.MockitoTestListener {}",
+                        "  abstract class SecondImplementsClause",
+                        "      // BUG: Diagnostic contains:",
+                        "      implements Serializable, org.mockito.internal.junit.MockitoTestListener {}",
+                        "  // BUG: Diagnostic contains:",
+                        "  class ExtendsGeneric<T extends org.mockito.internal.stubbing.InvocationContainerImpl>"
+                                + " {}",
+                        "  // BUG: Diagnostic contains:",
+                        "  class SecondExtendsGeneric<R, T extends"
+                                + " org.mockito.internal.stubbing.InvocationContainerImpl> {}",
+                        "  class FieldClause {",
+                        "    // BUG: Diagnostic contains:",
+                        "    org.mockito.internal.MockitoCore core;",
+                        "  }",
+                        "  class MethodArgumentClause {",
+                        "    // BUG: Diagnostic contains:",
+                        "    public void methodArgument(org.mockito.internal.MockitoCore core) {}",
+                        "  }",
+                        "  static class InternalConsumer {",
+                        "    // BUG: Diagnostic contains:",
+                        "    InternalConsumer(org.mockito.internal.MockitoCore core) {}",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testPositiveImportsCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package foo;",
+                        "// BUG: Diagnostic contains:",
+                        "import org.mockito.internal.MockitoCore;",
+                        "// BUG: Diagnostic contains:",
+                        "import org.mockito.internal.stubbing.InvocationContainerImpl;",
+                        "// BUG: Diagnostic contains:",
+                        "import org.mockito.internal.*;",
+                        "class Test {}")
+                .doTest();
+    }
+
+    @Test
+    public void testNegativeCases() {
+        compilationHelper
+                .addSourceLines(
+                        "Test.java",
+                        "package org.mockito;",
+                        "import org.mockito.internal.MockitoCore;",
+                        "class Mockito {}")
+                .doTest();
+    }
+}
diff --git a/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java
new file mode 100644
index 0000000000..872f21a66b
--- /dev/null
+++ b/mockito-extensions/mockito-errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.errorprone.bugpatterns;
+
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Verifies that there are no subclasses of {@link org.mockito.NotExtensible} Mockito types. */
+@RunWith(JUnit4.class)
+public class MockitoNotExtensibleTest {
+
+    private CompilationTestHelper compilationTestHelper;
+
+    @Before
+    public void setup() {
+        compilationTestHelper =
+                CompilationTestHelper.newInstance(MockitoNotExtensible.class, getClass());
+    }
+
+    @Test
+    public void notExtensibleSubclass_shouldWarn() {
+        compilationTestHelper
+                .addSourceLines(
+                        "input.java",
+                        "import org.mockito.invocation.InvocationOnMock;",
+                        "// BUG: Diagnostic contains:",
+                        "abstract class Invocation implements InvocationOnMock { }")
+                .doTest();
+    }
+
+    @Test
+    public void anonymousClassImplementingNotExtensible_shouldWarn() {
+        compilationTestHelper
+                .addSourceLines(
+                        "input.java",
+                        "import org.mockito.NotExtensible;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    // BUG: Diagnostic contains:",
+                        "    new Anonymous() { };",
+                        "  }",
+                        "  @NotExtensible",
+                        "  interface Anonymous {}",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void anonymousClassImplementingOtherAnnotation_shouldNotWarn() {
+        compilationTestHelper
+                .addSourceLines(
+                        "input.java",
+                        "import org.mockito.NotExtensible;",
+                        "class Test {",
+                        "  public void test() {",
+                        "    new Anonymous() { };",
+                        "  }",
+                        "  @OtherAnnotation",
+                        "  interface Anonymous {}",
+                        "  @interface OtherAnnotation {}",
+                        "}")
+                .doTest();
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/build.gradle.kts b/mockito-extensions/mockito-junit-jupiter/build.gradle.kts
new file mode 100644
index 0000000000..7f0dca43dd
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/build.gradle.kts
@@ -0,0 +1,102 @@
+import aQute.bnd.gradle.Resolve
+
+plugins {
+    id("mockito.library-conventions")
+    id("mockito.javadoc-conventions")
+}
+
+description = "Mockito JUnit 5 support"
+
+dependencies {
+    api(project(":mockito-core"))
+    implementation(libs.junit.jupiter.api)
+    testImplementation(libs.assertj)
+    testImplementation(libs.junit.platform.launcher)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+}
+
+mockitoJavadoc {
+    title = "Mockito JUnit Jupiter ${project.version} API"
+    docTitle = """<h1>Mockito JUnit Jupiter ${project.version} API.</h1>"""
+}
+
+tasks {
+    withType<Test> {
+        useJUnitPlatform()
+    }
+
+    jar {
+        bundle { // this: BundleTaskExtension
+            classpath = project.configurations.runtimeClasspath.get()
+            bnd("""
+                # Bnd instructions for the Mockito Junit Jupiter.
+
+                # Set a bundle name slightly different from project description.
+                Bundle-Name: Mockito Extension Library for JUnit 5.
+
+                # Set the Bundle-SymbolicName to "org.mockito.junit-jupiter".
+                # Otherwise bnd plugin will use archiveClassifier by default.
+                Bundle-SymbolicName: org.mockito.junit-jupiter
+
+                # Version rules for the bundle.
+                # https://bnd.bndtools.org/macros/version_cleanup.html
+                Bundle-Version: ${'$'}{version_cleanup;${project.version}}
+
+                # Set bundle license
+                Bundle-License: MIT
+
+                # Export rules for public and internal packages
+                # https://bnd.bndtools.org/heads/export_package.html
+                Export-Package: org.mockito.junit.jupiter.*;version=${archiveVersion.get()}
+
+                # Don't add the Private-Package header.
+                # See https://bnd.bndtools.org/instructions/removeheaders.html
+                -removeheaders: Private-Package
+
+                # Don't add all the extra headers bnd normally adds.
+                # See https://bnd.bndtools.org/instructions/noextraheaders.html
+                -noextraheaders: true
+
+                # Instruct the APIGuardianAnnotations how to operate.
+                # See https://bnd.bndtools.org/instructions/export-apiguardian.html
+                -export-apiguardian: org.mockito.internal.*
+            """.trimIndent())
+        }
+    }
+
+    // Bnd's Resolve task uses a properties file for its configuration. This
+    // task writes out the properties necessary for it to verify the OSGi
+    // metadata.
+    val osgiProperties by registering(WriteProperties::class) {
+        destinationFile.set(layout.buildDirectory.file("verifyOSGiProperties.bndrun"))
+        property("-standalone", true)
+        property("-runee", "JavaSE-${java.targetCompatibility}")
+        property("-runrequires", "osgi.identity;filter:=\"(osgi.identity=org.mockito.junit-jupiter)\"")
+    }
+
+    // Bnd's Resolve task is what verifies that a jar can be used in OSGi and
+    // that its metadata is valid. If the metadata is invalid, this task will
+    // fail.
+    val verifyOSGi by registering(Resolve::class) {
+        bndrun = osgiProperties.flatMap { it.destinationFile }
+        outputBndrun = layout.buildDirectory.file("resolvedOSGiProperties.bndrun")
+        isReportOptional = false
+    }
+
+    check {
+        dependsOn(verifyOSGi)
+    }
+
+    javadoc {
+        // Handle https://bugs.openjdk.org/browse/JDK-8274639
+        // Note: Might be solved by a toolchain launcher for the javadoc.
+        if (JavaVersion.current() >= JavaVersion.VERSION_18) {
+            javadocDocletOptions {
+                addStringOption("-link-modularity-mismatch", "info")
+                links("https://junit.org/junit5/docs/${libs.versions.junit.jupiter.get()}/api/")
+            }
+        } else {
+            logger.info("Javadoc tool below 18, links to JUnit Jupiter javadocs was not added.")
+        }
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/main/java/module-info.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/module-info.java
new file mode 100644
index 0000000000..1119e9a6c0
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/main/java/module-info.java
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+module org.mockito.junit.jupiter {
+    requires transitive org.mockito;
+    requires transitive org.junit.jupiter.api;
+
+    exports org.mockito.junit.jupiter;
+    exports org.mockito.junit.jupiter.resolver;
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java
new file mode 100644
index 0000000000..684e25bd05
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit.jupiter;
+
+import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.create;
+import static org.junit.platform.commons.support.AnnotationSupport.findAnnotation;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.mockito.Mockito;
+import org.mockito.MockitoSession;
+import org.mockito.ScopedMock;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.session.MockitoSessionLoggerAdapter;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.resolver.CaptorParameterResolver;
+import org.mockito.junit.jupiter.resolver.CompositeParameterResolver;
+import org.mockito.junit.jupiter.resolver.MockParameterResolver;
+import org.mockito.quality.Strictness;
+
+/**
+ * Extension that initializes mocks and handles strict stubbings. This extension is the JUnit Jupiter equivalent
+ * of our JUnit4 {@link MockitoJUnitRunner}.
+ *
+ * Example usage:
+ *
+ * <pre class="code"><code class="java">
+ * <b>&#064;ExtendWith(MockitoExtension.class)</b>
+ * public class ExampleTest {
+ *
+ *     &#064;Mock
+ *     private List&lt;Integer&gt; list;
+ *
+ *     &#064;Test
+ *     public void shouldDoSomething() {
+ *         list.add(100);
+ *     }
+ * }
+ * </code></pre>
+ *
+ * If you would like to configure the used strictness for the test class, use {@link MockitoSettings}.
+ *
+ * <pre class="code"><code class="java">
+ * <b>&#064;MockitoSettings(strictness = Strictness.STRICT_STUBS)</b>
+ * public class ExampleTest {
+ *
+ *     &#064;Mock
+ *     private List&lt;Integer&gt; list;
+ *
+ *     &#064;Test
+ *     public void shouldDoSomething() {
+ *         list.add(100);
+ *     }
+ * }
+ * </code></pre>
+ *
+ * This extension also supports JUnit Jupiter's method parameters.
+ * Use parameters for initialization of mocks that you use only in that specific test method.
+ * In other words, where you would initialize local mocks in JUnit 4 by calling {@link Mockito#mock(Class)},
+ * use the method parameter. This is especially beneficial when initializing a mock with generics, as you no
+ * longer get a warning about "Unchecked assignment".
+ * Please refer to JUnit Jupiter's documentation to learn when method parameters are useful.
+ *
+ * <pre class="code"><code class="java">
+ * <b>&#064;ExtendWith(MockitoExtension.class)</b>
+ * public class ExampleTest {
+ *
+ *     &#064;Mock
+ *     private List&lt;Integer&gt; sharedList;
+ *
+ *     &#064;Test
+ *     public void shouldDoSomething() {
+ *         sharedList.add(100);
+ *     }
+ *
+ *     &#064;Test
+ *     public void hasLocalMockInThisTest(@Mock List&lt;Integer&gt; localList) {
+ *         localList.add(100);
+ *         sharedList.add(100);
+ *     }
+ * }
+ * </code></pre>
+ *
+ * Lastly, the extension supports JUnit Jupiter's constructor parameters.
+ * This allows you to do setup work in the constructor and set
+ * your fields to <code>final</code>.
+ * Please refer to JUnit Jupiter's documentation to learn when constructor parameters are useful.
+ *
+ * <pre class="code"><code class="java">
+ * <b>&#064;ExtendWith(MockitoExtension.class)</b>
+ * public class ExampleTest {
+ *
+ *      private final List&lt;Integer&gt; sharedList;
+ *
+ *      ExampleTest(&#064;Mock sharedList) {
+ *          this.sharedList = sharedList;
+ *      }
+ *
+ *      &#064;Test
+ *      public void shouldDoSomething() {
+ *          sharedList.add(100);
+ *      }
+ * }
+ * </code></pre>
+ */
+public class MockitoExtension implements BeforeEachCallback, AfterEachCallback, ParameterResolver {
+
+    private static final Namespace MOCKITO = create("org.mockito");
+
+    private static final String SESSION = "session", MOCKS = "mocks";
+
+    private final Strictness strictness;
+
+    private final ParameterResolver parameterResolver;
+
+    // This constructor is invoked by JUnit Jupiter via reflection or ServiceLoader
+    @SuppressWarnings("unused")
+    public MockitoExtension() {
+        this(Strictness.STRICT_STUBS);
+    }
+
+    private MockitoExtension(Strictness strictness) {
+        this.strictness = strictness;
+        this.parameterResolver =
+                new CompositeParameterResolver(
+                        new MockParameterResolver(), new CaptorParameterResolver());
+    }
+
+    /**
+     * Callback that is invoked <em>before</em> each test is invoked.
+     *
+     * @param context the current extension context; never {@code null}
+     */
+    @Override
+    public void beforeEach(final ExtensionContext context) {
+        List<Object> testInstances = context.getRequiredTestInstances().getAllInstances();
+
+        Strictness actualStrictness =
+                this.retrieveAnnotationFromTestClasses(context)
+                        .map(MockitoSettings::strictness)
+                        .orElse(strictness);
+
+        MockitoSession session =
+                Mockito.mockitoSession()
+                        .initMocks(testInstances.toArray())
+                        .strictness(actualStrictness)
+                        .logger(new MockitoSessionLoggerAdapter(Plugins.getMockitoLogger()))
+                        .startMocking();
+
+        context.getStore(MOCKITO).put(MOCKS, new HashSet<>());
+        context.getStore(MOCKITO).put(SESSION, session);
+    }
+
+    private Optional<MockitoSettings> retrieveAnnotationFromTestClasses(
+            final ExtensionContext context) {
+        ExtensionContext currentContext = context;
+        Optional<MockitoSettings> annotation;
+
+        do {
+            annotation = findAnnotation(currentContext.getElement(), MockitoSettings.class);
+
+            if (currentContext.getParent().isEmpty()) {
+                break;
+            }
+
+            currentContext = currentContext.getParent().get();
+        } while (annotation.isEmpty() && currentContext != context.getRoot());
+
+        return annotation;
+    }
+
+    /**
+     * Callback that is invoked <em>after</em> each test has been invoked.
+     *
+     * @param context the current extension context; never {@code null}
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    public void afterEach(ExtensionContext context) {
+        ExtensionContext.Store store = context.getStore(MOCKITO);
+
+        Optional.ofNullable(store.remove(MOCKS, Set.class))
+                .ifPresent(mocks -> mocks.forEach(mock -> ((ScopedMock) mock).closeOnDemand()));
+
+        Optional.ofNullable(store.remove(SESSION, MockitoSession.class))
+                .ifPresent(
+                        session ->
+                                session.finishMocking(
+                                        context.getExecutionException().orElse(null)));
+    }
+
+    @Override
+    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext context)
+            throws ParameterResolutionException {
+        return parameterResolver.supportsParameter(parameterContext, context);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context)
+            throws ParameterResolutionException {
+        Object resolvedParameter = parameterResolver.resolveParameter(parameterContext, context);
+        if (resolvedParameter instanceof ScopedMock) {
+            context.getStore(MOCKITO).get(MOCKS, Set.class).add(resolvedParameter);
+        }
+        return resolvedParameter;
+    }
+}
diff --git a/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoSettings.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoSettings.java
similarity index 100%
rename from subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoSettings.java
rename to mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoSettings.java
diff --git a/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CaptorParameterResolver.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CaptorParameterResolver.java
new file mode 100644
index 0000000000..79ecaf7d99
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CaptorParameterResolver.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit.jupiter.resolver;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.mockito.Captor;
+import org.mockito.internal.configuration.CaptorAnnotationProcessor;
+
+public class CaptorParameterResolver implements ParameterResolver {
+
+    @Override
+    public boolean supportsParameter(
+            ParameterContext parameterContext, ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        return parameterContext.isAnnotated(Captor.class);
+    }
+
+    @Override
+    public Object resolveParameter(
+            ParameterContext parameterContext, ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        return CaptorAnnotationProcessor.process(parameterContext.getParameter());
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java
new file mode 100644
index 0000000000..4e99a369f1
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit.jupiter.resolver;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+import java.util.List;
+import java.util.Optional;
+
+public class CompositeParameterResolver implements ParameterResolver {
+
+    private final List<ParameterResolver> delegates;
+
+    public CompositeParameterResolver(final ParameterResolver... delegates) {
+        this.delegates = List.of(delegates);
+    }
+
+    @Override
+    public boolean supportsParameter(
+            ParameterContext parameterContext, ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        return findDelegate(parameterContext, extensionContext).isPresent();
+    }
+
+    @Override
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    public Object resolveParameter(
+            ParameterContext parameterContext, ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        final ParameterResolver delegate = findDelegate(parameterContext, extensionContext).get();
+        return delegate.resolveParameter(parameterContext, extensionContext);
+    }
+
+    private Optional<ParameterResolver> findDelegate(
+            final ParameterContext parameterContext, final ExtensionContext extensionContext) {
+        return delegates.stream()
+                .filter(delegate -> delegate.supportsParameter(parameterContext, extensionContext))
+                .findFirst();
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/MockParameterResolver.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/MockParameterResolver.java
new file mode 100644
index 0000000000..b6ed64cf31
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/MockParameterResolver.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.junit.jupiter.resolver;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.mockito.Mock;
+import org.mockito.internal.configuration.MockAnnotationProcessor;
+
+import java.lang.reflect.Parameter;
+
+public class MockParameterResolver implements ParameterResolver {
+
+    @Override
+    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext context)
+            throws ParameterResolutionException {
+        return parameterContext.isAnnotated(Mock.class);
+    }
+
+    @Override
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context)
+            throws ParameterResolutionException {
+        final Parameter parameter = parameterContext.getParameter();
+
+        return MockAnnotationProcessor.processAnnotationForMock(
+                parameterContext.findAnnotation(Mock.class).get(),
+                parameter.getType(),
+                parameter::getParameterizedType,
+                parameter.getName());
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/GenericTypeMockMultipleMatchesTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/GenericTypeMockMultipleMatchesTest.java
new file mode 100644
index 0000000000..825ca7fca8
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/GenericTypeMockMultipleMatchesTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+/**
+ * Verify that a {@link MockitoException} is thrown when there are multiple {@link Mock} fields that
+ * do match a candidate field by type, but cannot be matched by name.
+ *
+ * Uses a JUnit 5 extension to obtain the JUnit 5 {@link ExtensionContext} and
+ * pass it to {@link MockitoExtension#beforeEach(ExtensionContext)}, as the exception
+ * is thrown during {@link org.junit.jupiter.api.BeforeEach}.
+ */
+@ExtendWith(GenericTypeMockMultipleMatchesTest.ContextProvidingExtension.class)
+public class GenericTypeMockMultipleMatchesTest {
+
+    private static ExtensionContext currentExtensionContext;
+
+    public static class ContextProvidingExtension implements BeforeEachCallback {
+        @Override
+        public void beforeEach(ExtensionContext context) throws Exception {
+            currentExtensionContext = context;
+        }
+    }
+
+    private void startMocking(Object testInstance) {
+        MockitoExtension mockitoExtension = new MockitoExtension();
+        mockitoExtension.beforeEach(currentExtensionContext);
+    }
+
+    @Nested
+    public class MultipleCandidatesByTypeTest {
+        public class UnderTestWithMultipleCandidatesByType {
+            List<String> stringList;
+        }
+
+        @Mock List<String> stringList1;
+
+        @Mock List<String> stringList2;
+
+        @InjectMocks
+        UnderTestWithMultipleCandidatesByType underTestWithMultipleCandidates =
+                new UnderTestWithMultipleCandidatesByType();
+
+        @Test
+        void testMultipleCandidatesByTypes() {
+            assertThrows(MockitoException.class, () -> startMocking(this));
+        }
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/GenericTypeMockTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/GenericTypeMockTest.java
new file mode 100644
index 0000000000..d87fd4d646
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/GenericTypeMockTest.java
@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.mockito.MockitoAnnotations.*;
+
+import java.io.Serializable;
+import java.sql.Time;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+/**
+ * Tests that verify Mockito can discern mocks by generic types, so if there are multiple mock candidates
+ * with the same generic type but different type parameters available for injection into a given field,
+ * Mockito won't fail to inject (even if mock field name doesn't match under test's field name).
+ */
+@ExtendWith(MockitoExtension.class)
+public class GenericTypeMockTest {
+
+    @Nested
+    public class SingleTypeParamTest {
+        public class UnderTestWithSingleTypeParam {
+            List<String> stringList;
+            List<Integer> intList;
+        }
+
+        @Mock private List<String> stringListMock;
+
+        @Mock private List<Integer> intListMock;
+
+        // must construct non-static inner class ourselves here
+        // (making it public static classes doesn't work either)
+        @InjectMocks
+        private UnderTestWithSingleTypeParam underTestWithSingleTypeParam =
+                new UnderTestWithSingleTypeParam();
+
+        @Test
+        void testSingleTypeParam() {
+            // testing for not null first before testing for equals,
+            // because assertEquals(null, null) == true,
+            // so test would succeed if both @Mock and @InjectMocks
+            // don't work at all
+            assertNotNull(stringListMock);
+            assertNotNull(intListMock);
+
+            assertEquals(stringListMock, underTestWithSingleTypeParam.stringList);
+            assertEquals(intListMock, underTestWithSingleTypeParam.intList);
+        }
+    }
+
+    @Nested
+    public class WildcardTest {
+        class UnderTestWithWildcard {
+            Set<? extends Date> dateSet;
+            Set<? extends Number> numberSet;
+        }
+
+        @Mock Set<Time> timeSetMock; // java.sql.Time extends Date
+
+        @Mock Set<Integer> integerSetMock;
+
+        @InjectMocks UnderTestWithWildcard underTestWithWildcard = new UnderTestWithWildcard();
+
+        @Test
+        void testWildcard() {
+            assertNotNull(timeSetMock);
+            assertNotNull(integerSetMock);
+
+            // this also tests whether WildcardType.upperBounds() is evaluated,
+            // i.e. that we match <? extends Date> to <Time> type parameter
+            assertEquals(timeSetMock, underTestWithWildcard.dateSet);
+            assertEquals(integerSetMock, underTestWithWildcard.numberSet);
+        }
+    }
+
+    @Nested
+    public class NestedTypeParametersTest {
+        public class UnderTestWithNestedTypeParameters {
+            Map<Integer, Collection<String>> intToStringCollectionMap;
+            Map<Integer, Collection<Integer>> intoToIntCollectionMap;
+        }
+
+        @Mock Map<Integer, Collection<String>> intToStringCollectionMapMock;
+
+        @Mock Map<Integer, Collection<Integer>> intToIntCollectionMapMock;
+
+        @InjectMocks
+        UnderTestWithNestedTypeParameters underTestWithNestedTypeParameters =
+                new UnderTestWithNestedTypeParameters();
+
+        @Test
+        void testNestedTypeParameters() {
+            assertNotNull(intToStringCollectionMapMock);
+            assertNotNull(intToIntCollectionMapMock);
+
+            assertEquals(
+                    intToStringCollectionMapMock,
+                    underTestWithNestedTypeParameters.intToStringCollectionMap);
+            assertEquals(
+                    intToIntCollectionMapMock,
+                    underTestWithNestedTypeParameters.intoToIntCollectionMap);
+        }
+    }
+
+    @Nested
+    public class GenericSubclassTest {
+        public class UnderTestWithGenericSubclass {
+            Set<String> stringSet;
+            Set<Integer> intSet;
+        }
+
+        @Mock TreeSet<String> stringTreeSetMock;
+
+        @Mock HashSet<Integer> intHashSetMock;
+
+        @InjectMocks
+        UnderTestWithGenericSubclass underTestWithGenericSubclass =
+                new UnderTestWithGenericSubclass();
+
+        @Test
+        void testGenericSubclass() {
+            assertNotNull(stringTreeSetMock);
+            assertNotNull(intHashSetMock);
+
+            assertEquals(stringTreeSetMock, underTestWithGenericSubclass.stringSet);
+            assertEquals(intHashSetMock, underTestWithGenericSubclass.intSet);
+        }
+    }
+
+    @Nested
+    public class MultipleCandidatesOneByNameTest {
+        public class UnderTestWithMultipleCandidatesOneByName {
+            List<String> stringList;
+        }
+
+        @Mock List<String> stringList;
+
+        @Mock List<String> stringListMock;
+
+        @InjectMocks
+        UnderTestWithMultipleCandidatesOneByName underTestWithMultipleCandidatesOneByName =
+                new UnderTestWithMultipleCandidatesOneByName();
+
+        @Test
+        void testMultipleCandidatesOneByName() {
+            // verify that when multiple mock candidates exist by type, and one of them matches by
+            // field name, that one is injected
+            assertNotNull(underTestWithMultipleCandidatesOneByName.stringList);
+            assertEquals(stringList, underTestWithMultipleCandidatesOneByName.stringList);
+        }
+    }
+
+    @Nested
+    public class NoneMatchByTypeParameterTest {
+        public class UnderTestWithNoMatches {
+            List<Integer> intList;
+        }
+
+        @Mock List<String> stringList;
+
+        @InjectMocks UnderTestWithNoMatches underTestWithNoMatches = new UnderTestWithNoMatches();
+
+        @Test
+        void testNoneMatchByTypeParameter() {
+            assertNotNull(stringList);
+
+            // verify that when no candidate matches by type parameter, none is injected
+            assertNull(underTestWithNoMatches.intList);
+        }
+    }
+
+    @Nested
+    public class NoneMatchByRawTypeTest {
+        public class UnderTestWithNoMatches {
+            List<Integer> intList;
+        }
+
+        @Mock Set<Integer> intSet;
+
+        @InjectMocks
+        UnderTestWithNoMatches underTestWithNoMatchesByRawType = new UnderTestWithNoMatches();
+
+        @Test
+        void testNoneMatchByRawType() {
+            assertNotNull(intSet);
+
+            // verify that when no candidate matches by raw type, none is injected
+            assertNull(underTestWithNoMatchesByRawType.intList);
+        }
+    }
+
+    @Nested
+    public class ClassWithTypeParameterNoMatchTest {
+        public class UnderTestWithTypeParameter<T> {
+            List<T> tList;
+        }
+
+        @Mock List<Integer> intList;
+
+        @InjectMocks
+        UnderTestWithTypeParameter<String> underTestWithTypeParameterNoMatch =
+                new UnderTestWithTypeParameter<String>();
+
+        @Test
+        void testWithTypeParameterNoMatch() {
+            assertNotNull(intList);
+
+            // verify that when no candidate matches by type parameter of class under test, none is
+            // injected
+            assertNull(underTestWithTypeParameterNoMatch.tList);
+        }
+    }
+
+    @Nested
+    public class ClassWithTypeParametersTest {
+        public class UnderTestWithTypeParameters<T1, T2> {
+            List<T1> t1List;
+            List<T2> t2List;
+        }
+
+        @Mock List<String> stringList;
+
+        @Mock List<Integer> intList;
+
+        @InjectMocks
+        UnderTestWithTypeParameters<String, Integer> underTestWithTypeParameters =
+                new UnderTestWithTypeParameters<String, Integer>();
+
+        @Test
+        void testWithTypeParameters() {
+            assertNotNull(stringList);
+            assertNotNull(intList);
+
+            // verify that we can match the type parameters of the class under test
+            assertEquals(stringList, underTestWithTypeParameters.t1List);
+            assertEquals(intList, underTestWithTypeParameters.t2List);
+        }
+    }
+
+    @Nested
+    public class InjectConcreteClassInFieldWithTypeParameter {
+        public class UnderTestWithTypeParameter<T> {
+            List<T> tList;
+        }
+
+        public class ConcreteStringList extends ArrayList<String> {}
+
+        @Mock ConcreteStringList concreteStringList;
+
+        @InjectMocks
+        UnderTestWithTypeParameter<String> underTestWithTypeParameters =
+                new UnderTestWithTypeParameter<String>();
+
+        @Test
+        void testWithTypeParameters() {
+            assertNotNull(concreteStringList);
+
+            // verify that we can match the type parameters of the class under test
+            assertEquals(concreteStringList, underTestWithTypeParameters.tList);
+        }
+    }
+
+    @Nested
+    public class NoneMatchInjectConcreteClassInFieldWithTypeParameterTest {
+        public class UnderTestWithTypeParameter<T> {
+            List<T> tList;
+        }
+
+        public class ConcreteStringList extends ArrayList<String> {}
+
+        @Mock ConcreteStringList concreteStringList;
+
+        @InjectMocks
+        UnderTestWithTypeParameter<Integer> underTestWithTypeParameters =
+                new UnderTestWithTypeParameter<Integer>();
+
+        @Test
+        void testWithTypeParameters() {
+            assertNotNull(concreteStringList);
+
+            // verify that when no concrete type candidate matches, none is injected
+            assertNull(underTestWithTypeParameters.tList);
+        }
+    }
+
+    /**
+     * Verify regression https://github.com/mockito/mockito/issues/2958 is fixed.
+     */
+    @Nested
+    public class RegressionClassCastException {
+        public class AbstractUnderTest<A extends AbstractUnderTest<A>> {
+            UnderTestInstance<A> instance;
+        }
+
+        public class UnderTestInstance<I extends AbstractUnderTest<I>> {}
+
+        public class ConcreteUnderTest extends AbstractUnderTest<ConcreteUnderTest> {}
+
+        @Mock UnderTestInstance<ConcreteUnderTest> instanceMock;
+
+        @InjectMocks protected ConcreteUnderTest concreteUnderTest = new ConcreteUnderTest();
+
+        @BeforeEach
+        public void initMocks() {
+            openMocks(this);
+        }
+
+        @Test
+        public void testMockExists() {
+            assertNotNull(instanceMock);
+            assertEquals(instanceMock, concreteUnderTest.instance);
+        }
+    }
+
+    /**
+     * Verify regression https://github.com/mockito/mockito/issues/2974 is fixed.
+     */
+    @Nested
+    public class RegressionNpe {
+        public abstract class Change {}
+
+        public class ChangeCollection<TChange extends Change> implements Iterable<TChange> {
+            private List<TChange> changes = new ArrayList<TChange>();
+
+            @Override
+            public Iterator<TChange> iterator() {
+                return null;
+            }
+        }
+
+        @Mock Change change0;
+
+        @InjectMocks ChangeCollection spiedImpl = new ChangeCollection();
+
+        @Mock(name = "changes")
+        List<Change> innerList;
+
+        @Test
+        public void testNoNpe() {
+            assertSame(innerList, spiedImpl.changes);
+        }
+    }
+
+    /* cannot define interface in nested test class RegressionArrayIndexOutOfBoundsExcepton ,
+     * because interface cannot be defined in a non-static inner class,
+     * and nested test class must be non-static in order for JUnit 5 to be able to run it */
+    public interface BaseRepository<E, I extends Serializable> {
+        E findById(I id);
+
+        E save(E entity);
+    }
+
+    /**
+     * Verify regression https://github.com/mockito/mockito/issues/3000 is fixed.
+     */
+    @Nested
+    public class RegressionArrayIndexOutOfBoundsException {
+
+        public class BaseService<E, I extends Serializable> {
+            private BaseRepository<E, I> repository;
+        }
+
+        public class OneRepository implements BaseRepository<Map<String, String>, String> {
+            public Map<String, String> findById(String id) {
+                return Map.of();
+            }
+
+            public Map<String, String> save(Map<String, String> entity) {
+                return entity;
+            }
+        }
+
+        public class TwoRepository implements BaseRepository<Map<Integer, String>, String> {
+            public Map<Integer, String> findById(String id) {
+                return Map.of();
+            }
+
+            public Map<Integer, String> save(Map<Integer, String> entity) {
+                return entity;
+            }
+        }
+
+        public class One {}
+        ;
+
+        public class Two implements Serializable {
+            private static final long serialVersionUID = 1L;
+        }
+
+        public class UnderTest extends BaseService<One, Two> {
+            private OneRepository oneRepository;
+            private TwoRepository twoRepository;
+        }
+
+        @Mock OneRepository oneRepository;
+
+        @Mock TwoRepository twoRepository;
+
+        @InjectMocks UnderTest underTest = new UnderTest();
+
+        @Test
+        public void testNoAioobe() {
+            assertNotNull(oneRepository);
+            assertNotNull(twoRepository);
+            assertNotNull(underTest);
+        }
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/InjectMocksTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/InjectMocksTest.java
new file mode 100644
index 0000000000..61cc79510d
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/InjectMocksTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ToBeMockedInTestSuperClass {
+    int identifier;
+
+    public ToBeMockedInTestSuperClass(int identifier) {
+        this.identifier = identifier;
+    }
+}
+
+class ToBeMocked {
+    int identifier;
+
+    public ToBeMocked(int identifier) {
+        this.identifier = identifier;
+    }
+}
+
+class TestClassToBeInitiatedViaConstructorInSuperClass {
+    ToBeMockedInTestSuperClass toBeMockedInTestSuperClass;
+
+    public TestClassToBeInitiatedViaConstructorInSuperClass(
+            ToBeMockedInTestSuperClass toBeMockedInTestSuperClass) {
+        assertThat(toBeMockedInTestSuperClass).isNotNull();
+        this.toBeMockedInTestSuperClass = new ToBeMockedInTestSuperClass(42);
+    }
+}
+
+class TestClassToBeInitiatedViaConstructor {
+    ToBeMockedInTestSuperClass toBeMockedInTestSuperClass;
+    ToBeMocked toBeMocked;
+
+    public TestClassToBeInitiatedViaConstructor(
+            ToBeMocked toBeMocked, ToBeMockedInTestSuperClass toBeMockedInTestSuperClass) {
+        assertThat(toBeMocked).isNotNull();
+        assertThat(toBeMockedInTestSuperClass).isNotNull();
+        this.toBeMocked = new ToBeMocked(42);
+        this.toBeMockedInTestSuperClass = new ToBeMockedInTestSuperClass(42);
+    }
+}
+
+class SuperTestClass {
+    @Mock ToBeMockedInTestSuperClass toBeMockedInTestSuperClass;
+
+    @InjectMocks
+    TestClassToBeInitiatedViaConstructorInSuperClass
+            testClassToBeInitiatedViaConstructorInSuperClass;
+}
+
+@ExtendWith(MockitoExtension.class)
+class InjectMocksTest extends SuperTestClass {
+
+    @Mock ToBeMocked toBeMocked;
+
+    @InjectMocks TestClassToBeInitiatedViaConstructor testClassToBeInitiatedViaConstructor;
+
+    /**
+     * Checks that {@link #testClassToBeInitiatedViaConstructor} holds instances that have identifier 42.
+     * It being 42 is proof that constructor injection was used over field injection.
+     */
+    @Test
+    void
+            given_instanceToBeInitializedByMockito_when_mocksRequestedByConstructorAreInTestAndSuperClass_should_useConstructorInjection() {
+        assertThat(testClassToBeInitiatedViaConstructor)
+                .extracting(
+                        testInstance -> testInstance.toBeMocked.identifier,
+                        testInstance -> testInstance.toBeMockedInTestSuperClass.identifier)
+                .containsExactly(42, 42);
+    }
+
+    /**
+     * Checks that {@link #testClassToBeInitiatedViaConstructorInSuperClass} holds instances that have identifier 42.
+     * It being 42 is proof that constructor injection was used over field injection.
+     */
+    @Test
+    public void
+            given_instanceInSuperClassToBeInitializedByMockito_when_mocksRequestedAreInSuperClass_should_useConstructorInjection() {
+        assertThat(testClassToBeInitiatedViaConstructorInSuperClass)
+                .extracting(
+                        yetAnotherClas1 -> yetAnotherClas1.toBeMockedInTestSuperClass.identifier)
+                .isEqualTo(42);
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/JunitJupiterSkippedTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/JunitJupiterSkippedTest.java
new file mode 100644
index 0000000000..94bd0aed12
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/JunitJupiterSkippedTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.opentest4j.TestAbortedException;
+
+class JunitJupiterSkippedTest {
+    @Nested
+    class NestedSkipBeforeEachMockito {
+        @Test
+        @ExtendWith({SkipTestBeforeEachExtension.class, MockitoExtension.class})
+        void should_handle_skip_in_before_each() {}
+
+        @Test
+        @ExtendWith({MockitoExtension.class, SkipTestBeforeEachExtension.class})
+        void should_handle_skip_after_before_each() {}
+
+        @Test
+        @ExtendWith(MockitoExtension.class)
+        void should_handle_skip_in_test() {
+            skipTest();
+        }
+    }
+
+    @Nested
+    @ExtendWith({SkipTestBeforeAllExtension.class, MockitoExtension.class})
+    class NestedSkipBeforeAllSkipThenMockito {
+        @Test
+        void should_handle_skip_in_before_all() {}
+    }
+
+    @Nested
+    @ExtendWith({MockitoExtension.class, SkipTestBeforeAllExtension.class})
+    class NestedSkipBeforeAllMockitoThenSkip {
+        @Test
+        void should_handle_skip_in_before_all() {}
+    }
+
+    private static class SkipTestBeforeEachExtension implements BeforeEachCallback {
+        @Override
+        public void beforeEach(ExtensionContext context) {
+            skipTest();
+        }
+    }
+
+    private static class SkipTestBeforeAllExtension implements BeforeAllCallback {
+        @Override
+        public void beforeAll(ExtensionContext context) {
+            skipTest();
+        }
+    }
+
+    private static void skipTest() {
+        throw new TestAbortedException("Skipped test");
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java
new file mode 100644
index 0000000000..31490477cc
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Captor;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class JunitJupiterTest {
+
+    @Mock private Function<Integer, String> rootMock;
+
+    @Captor private ArgumentCaptor<String> rootCaptor;
+
+    @InjectMocks private ClassWithDependency classWithDependency;
+
+    @Test
+    void ensure_mock_creation_works() {
+        assertThat(rootMock).isNotNull();
+    }
+
+    @Test
+    void can_set_stubs_on_initialized_mock() {
+        Mockito.when(rootMock.apply(10)).thenReturn("Return");
+        assertThat(rootMock.apply(10)).isEqualTo("Return");
+    }
+
+    @Test
+    void ensure_captor_creation_works() {
+        assertThat(rootCaptor).isNotNull();
+    }
+
+    @Test
+    void can_capture_with_initialized_captor() {
+        assertCaptor(rootCaptor);
+    }
+
+    @Test
+    void initializes_parameters(
+            @Mock Function<String, String> localMock, @Captor ArgumentCaptor<String> localCaptor) {
+        Mockito.when(localMock.apply("Para")).thenReturn("Meter");
+        assertThat(localMock.apply("Para")).isEqualTo("Meter");
+
+        assertCaptor(localCaptor);
+    }
+
+    @Test
+    void initializes_parameters_with_custom_configuration(
+            @Mock(name = "overriddenName") Function<String, String> localMock) {
+        assertThat(MockUtil.getMockName(localMock).toString()).isEqualTo("overriddenName");
+    }
+
+    @Nested
+    class NestedTestWithConstructorParameter {
+        private final Function<Integer, String> constructorMock;
+        private final ArgumentCaptor<String> constructorCaptor;
+
+        NestedTestWithConstructorParameter(
+                @Mock Function<Integer, String> constructorMock,
+                @Captor ArgumentCaptor<String> constructorCaptor) {
+            this.constructorMock = constructorMock;
+            this.constructorCaptor = constructorCaptor;
+        }
+
+        @Test
+        void can_inject_into_constructor_parameter() {
+            Mockito.when(constructorMock.apply(42)).thenReturn("42");
+            assertThat(constructorMock.apply(42)).isEqualTo("42");
+
+            assertCaptor(constructorCaptor);
+        }
+    }
+
+    @Nested
+    class NestedTestWithExtraMock {
+        @Mock Runnable nestedMock;
+
+        @Test
+        void nested_mock_created() {
+            assertThat(nestedMock).isNotNull();
+        }
+
+        @Test
+        void root_mock_created() {
+            assertThat(rootMock).isNotNull();
+        }
+    }
+
+    @Nested
+    class NestedClassWithExtraCaptor {
+        @Captor ArgumentCaptor<Integer> nestedCaptor;
+
+        @Test
+        void nested_captor_created() {
+            assertThat(nestedCaptor).isNotNull();
+        }
+
+        @Test
+        void root_captor_created() {
+            assertThat(rootCaptor).isNotNull();
+        }
+    }
+
+    @Nested
+    @ExtendWith(MockitoExtension.class)
+    // ^^ duplicate registration should be ignored by JUnit
+    // see https://junit.org/junit5/docs/current/user-guide/#extensions-registration-inheritance
+    class DuplicateExtensionOnNestedTest {
+
+        @Mock Object nestedMock;
+
+        @Mock ArgumentCaptor<String> nestedCaptor;
+
+        @Test
+        void ensure_mocks_are_created_for_nested_tests() {
+            assertThat(nestedMock).isNotNull();
+        }
+
+        @Test
+        void ensure_captor_is_created_for_nested_tests() {
+            assertThat(nestedCaptor).isNotNull();
+        }
+    }
+
+    @Nested
+    class NestedWithoutExtraMock {
+        @Test
+        // mock is initialized by mockito session
+        void shouldWeCreateMocksInTheParentContext() {
+            assertThat(rootMock).isNotNull();
+        }
+    }
+
+    @Test
+    void should_be_injected_correct_instance_of_mock() {
+        assertThat(classWithDependency.dependency).isSameAs(rootMock);
+    }
+
+    private static class ClassWithDependency {
+        private final Function<Integer, String> dependency;
+
+        private ClassWithDependency(Function<Integer, String> dependency) {
+            this.dependency = dependency;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void assertCaptor(ArgumentCaptor<String> captor) {
+        Predicate<String> mock = Mockito.mock(Predicate.class);
+        ProductionCode.simpleMethod(mock, "parameter");
+        verify(mock).test(captor.capture());
+        assertThat(captor.getValue()).isEqualTo("parameter");
+    }
+}
diff --git a/subprojects/junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java
similarity index 95%
rename from subprojects/junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java
rename to mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java
index 58a42f97e4..16f85599b3 100644
--- a/subprojects/junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java
@@ -15,8 +15,7 @@
 @ExtendWith(MockitoExtension.class)
 class MultiLevelNestedTest {
 
-    @Mock
-    private Runnable level1Mock;
+    @Mock private Runnable level1Mock;
 
     @Nested
     class Level2Class {
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/ProductionCode.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/ProductionCode.java
new file mode 100644
index 0000000000..f2953c7bc6
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/ProductionCode.java
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import java.util.function.Predicate;
+
+public class ProductionCode {
+
+    @SuppressWarnings("ReturnValueIgnored")
+    public static void simpleMethod(Predicate<String> mock, String argument) {
+        mock.test(argument);
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/StrictnessTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/StrictnessTest.java
new file mode 100644
index 0000000000..4b676f6844
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/StrictnessTest.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.platform.engine.TestExecutionResult;
+import org.junit.platform.launcher.Launcher;
+import org.junit.platform.launcher.LauncherDiscoveryRequest;
+import org.junit.platform.launcher.TestExecutionListener;
+import org.junit.platform.launcher.TestIdentifier;
+import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
+import org.junit.platform.launcher.core.LauncherFactory;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;
+
+/**
+ * Test that runs the inner test using a launcher {@see #invokeTestClassAndRetrieveMethodResult}.
+ * We then assert on the actual test run output, to see if test actually failed as a result
+ * of our extension.
+ */
+class StrictnessTest {
+
+    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
+    static class StrictStubs {
+        @Mock private Function<Integer, String> rootMock;
+
+        @Test
+        void should_throw_an_exception_on_strict_stubs() {
+            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
+        }
+    }
+
+    @Test
+    void session_checks_for_strict_stubs() {
+        TestExecutionResult result = invokeTestClassAndRetrieveMethodResult(StrictStubs.class);
+
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
+        assertThat(result.getThrowable().get()).isInstanceOf(UnnecessaryStubbingException.class);
+    }
+
+    static class MyAssertionError extends AssertionError {}
+
+    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
+    static class StrictStubsNotReportedOnTestFailure {
+        @Mock private Function<Integer, String> rootMock;
+
+        @Test
+        void should_not_throw_exception_on_strict_stubs_because_of_test_failure() {
+            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
+            throw new MyAssertionError();
+        }
+    }
+
+    @Test
+    void session_does_not_check_for_strict_stubs_on_test_failure() {
+        TestExecutionResult result =
+                invokeTestClassAndRetrieveMethodResult(StrictStubsNotReportedOnTestFailure.class);
+
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
+        Throwable throwable = result.getThrowable().get();
+        assertThat(throwable).isInstanceOf(MyAssertionError.class);
+        assertThat(throwable.getSuppressed()).isEmpty();
+    }
+
+    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
+    static class ConfiguredStrictStubs {
+        @Nested
+        class NestedStrictStubs {
+            @Mock private Function<Integer, String> rootMock;
+
+            @Test
+            void should_throw_an_exception_on_strict_stubs_in_a_nested_class() {
+                Mockito.when(rootMock.apply(10)).thenReturn("Foo");
+            }
+        }
+    }
+
+    @Test
+    void session_can_retrieve_strictness_from_parent_class() {
+        TestExecutionResult result =
+                invokeTestClassAndRetrieveMethodResult(ConfiguredStrictStubs.class);
+
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
+        assertThat(result.getThrowable().get()).isInstanceOf(UnnecessaryStubbingException.class);
+    }
+
+    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
+    static class ParentConfiguredStrictStubs {
+        @Nested
+        @MockitoSettings(strictness = Strictness.WARN)
+        class ChildConfiguredWarnStubs {
+            @Mock private Function<Integer, String> rootMock;
+
+            @Test
+            void should_throw_an_exception_on_strict_stubs_in_a_nested_class() {
+                Mockito.when(rootMock.apply(10)).thenReturn("Foo");
+            }
+        }
+    }
+
+    @Test
+    void session_retrieves_closest_strictness_configuration() {
+        TestExecutionResult result =
+                invokeTestClassAndRetrieveMethodResult(ParentConfiguredStrictStubs.class);
+
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.SUCCESSFUL);
+    }
+
+    @ExtendWith(MockitoExtension.class)
+    static class ByDefaultUsesStrictStubs {
+
+        @Mock private Function<Integer, String> rootMock;
+
+        @Test
+        void should_throw_an_exception_on_strict_stubs_configured_by_default() {
+            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
+        }
+    }
+
+    @Test
+    void by_default_configures_strict_stubs_in_runner() {
+        TestExecutionResult result =
+                invokeTestClassAndRetrieveMethodResult(ByDefaultUsesStrictStubs.class);
+
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
+        assertThat(result.getThrowable().get()).isInstanceOf(UnnecessaryStubbingException.class);
+    }
+
+    @MockitoSettings(strictness = Strictness.WARN)
+    static class BaseWarnStubs {}
+
+    static class InheritedWarnStubs extends BaseWarnStubs {
+        @Mock private Function<Integer, String> rootMock;
+
+        @Test
+        void should_execute_successfully_on_warn_stubs_inherited_from_base_class() {
+            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
+        }
+    }
+
+    @Test
+    void inherits_strictness_from_base_class() {
+        TestExecutionResult result =
+                invokeTestClassAndRetrieveMethodResult(InheritedWarnStubs.class);
+
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.SUCCESSFUL);
+    }
+
+    @ExtendWith(MockitoExtension.class)
+    @MockitoSettings(strictness = Strictness.LENIENT)
+    static class LenientMockitoSettings {
+
+        @Mock private Predicate<String> rootMock;
+
+        @Test
+        void should_not_throw_on_potential_stubbing_issue() {
+            Mockito.doReturn(true).when(rootMock).test("Foo");
+
+            ProductionCode.simpleMethod(rootMock, "Bar");
+        }
+    }
+
+    @Test
+    void use_strictness_from_settings_annotation() {
+        TestExecutionResult result =
+                invokeTestClassAndRetrieveMethodResult(LenientMockitoSettings.class);
+
+        assertThat(result.getThrowable()).isEqualTo(Optional.empty());
+        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.SUCCESSFUL);
+    }
+
+    private TestExecutionResult invokeTestClassAndRetrieveMethodResult(Class<?> clazz) {
+        LauncherDiscoveryRequest request =
+                LauncherDiscoveryRequestBuilder.request().selectors(selectClass(clazz)).build();
+
+        Launcher launcher = LauncherFactory.create();
+
+        final TestExecutionResult[] result = new TestExecutionResult[1];
+
+        launcher.registerTestExecutionListeners(
+                new TestExecutionListener() {
+                    @Override
+                    public void executionFinished(
+                            TestIdentifier testIdentifier,
+                            TestExecutionResult testExecutionResult) {
+                        if (testIdentifier.getDisplayName().endsWith("()")) {
+                            result[0] = testExecutionResult;
+                        }
+                    }
+                });
+
+        launcher.execute(request);
+
+        return result[0];
+    }
+}
diff --git a/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/annotation/CaptorAnnotationWithPrimitiveTest.java b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/annotation/CaptorAnnotationWithPrimitiveTest.java
new file mode 100644
index 0000000000..6301414c4e
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/test/java/org/mockitousage/annotation/CaptorAnnotationWithPrimitiveTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.doNothing;
+
+@ExtendWith(MockitoExtension.class)
+public class CaptorAnnotationWithPrimitiveTest {
+    @Mock private Foo foo;
+
+    static class Foo {
+        void doSomething(int value) {}
+    }
+
+    @Test
+    public void shouldCaptorPrimitive(@Captor ArgumentCaptor<Integer> captor) {
+        // Given
+        int value = 1;
+
+        // When
+        doNothing().when(foo).doSomething(captor.capture());
+
+        // Then
+        foo.doSomething(value);
+        assertEquals(1, captor.getValue());
+    }
+}
diff --git a/mockito-extensions/mockito-proxy/build.gradle.kts b/mockito-extensions/mockito-proxy/build.gradle.kts
new file mode 100644
index 0000000000..64368c07ce
--- /dev/null
+++ b/mockito-extensions/mockito-proxy/build.gradle.kts
@@ -0,0 +1,15 @@
+plugins {
+    id("mockito.library-conventions")
+}
+
+description = "Mockito preconfigured proxy mock mock maker (to support interfaces without code generation)"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
+
+tasks.javadoc {
+    isEnabled = false
+}
diff --git a/mockito-extensions/mockito-proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor b/mockito-extensions/mockito-proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
new file mode 100644
index 0000000000..71111e3378
--- /dev/null
+++ b/mockito-extensions/mockito-proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
@@ -0,0 +1 @@
+member-accessor-reflection
diff --git a/mockito-extensions/mockito-proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-extensions/mockito-proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
new file mode 100644
index 0000000000..d71325d9a6
--- /dev/null
+++ b/mockito-extensions/mockito-proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
@@ -0,0 +1 @@
+mock-maker-proxy
diff --git a/mockito-extensions/mockito-proxy/src/test/java/org/mockitoproxy/MocksTest.java b/mockito-extensions/mockito-proxy/src/test/java/org/mockitoproxy/MocksTest.java
new file mode 100644
index 0000000000..263294030e
--- /dev/null
+++ b/mockito-extensions/mockito-proxy/src/test/java/org/mockitoproxy/MocksTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoproxy;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Proxy;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+
+public class MocksTest {
+
+    @Test
+    public void can_create_mock_interface() {
+        SomeInterface mock = Mockito.mock(SomeInterface.class);
+        assertThat(mock, instanceOf(Proxy.class));
+
+        when(mock.m()).thenReturn("value");
+
+        assertThat(mock.m(), is("value"));
+
+        verify(mock).m();
+    }
+
+    @Test
+    public void can_create_mock_object() {
+        Object mock = Mockito.mock(Object.class);
+        assertThat(mock, instanceOf(Proxy.class));
+
+        when(mock.toString()).thenReturn("value");
+
+        assertThat(mock.toString(), is("value"));
+    }
+
+    @Test
+    public void can_call_default_method_if_available() {
+        SomeInterface mock = Mockito.mock(SomeInterface.class);
+        assertThat(mock, instanceOf(Proxy.class));
+
+        when(mock.d()).thenCallRealMethod();
+
+        assertThat(mock.d(), is("default"));
+
+        verify(mock).d();
+    }
+
+    @Test
+    public void cannot_call_default_method_if_not_available() {
+        SomeInterface mock = Mockito.mock(SomeInterface.class);
+        assertThat(mock, instanceOf(Proxy.class));
+
+        try {
+            when(mock.m()).thenCallRealMethod();
+            fail("Expected failure when requesting real method for non-default method");
+        } catch (MockitoException e) {
+            assertThat(e.getMessage(), CoreMatchers.containsString("real method"));
+        }
+    }
+
+    @Test
+    public void can_create_mock_different_class_loader() throws Exception {
+        ClassLoader loader =
+                new ClassLoader(null) {
+                    @Override
+                    public Class<?> findClass(String name) throws ClassNotFoundException {
+                        if (name.startsWith(MocksTest.class.getPackage().getName())) {
+                            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+                            try (InputStream inputStream =
+                                    MocksTest.class
+                                            .getClassLoader()
+                                            .getResourceAsStream(
+                                                    name.replace('.', '/') + ".class")) {
+                                int length;
+                                byte[] buffer = new byte[1024];
+                                while ((length = inputStream.read(buffer)) != -1) {
+                                    outputStream.write(buffer, 0, length);
+                                }
+                            } catch (IOException e) {
+                                throw new AssertionError(e);
+                            }
+                            byte[] classFile = outputStream.toByteArray();
+                            return defineClass(name, classFile, 0, classFile.length);
+                        }
+                        return super.loadClass(name);
+                    }
+                };
+
+        Object mock = Mockito.mock(Class.forName(SomeInterface.class.getName(), true, loader));
+        assertThat(mock, instanceOf(Proxy.class));
+
+        when(mock.toString()).thenReturn("value");
+
+        assertThat(mock.toString(), is("value"));
+    }
+
+    @Test
+    public void cannot_create_mock_of_non_object_class() {
+        assertThatThrownBy(
+                        () -> {
+                            Number number = Mockito.mock(Number.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "Cannot mock/spy class",
+                        "Mockito cannot mock/spy because :",
+                        " - non-interface");
+    }
+
+    public interface SomeInterface {
+
+        Object m();
+
+        default Object d() {
+            return "default";
+        }
+    }
+}
diff --git a/mockito-extensions/mockito-subclass/build.gradle.kts b/mockito-extensions/mockito-subclass/build.gradle.kts
new file mode 100644
index 0000000000..b95d97684c
--- /dev/null
+++ b/mockito-extensions/mockito-subclass/build.gradle.kts
@@ -0,0 +1,15 @@
+plugins {
+    id("mockito.library-conventions")
+}
+
+description = "Mockito preconfigured subclass mock maker"
+
+dependencies {
+    api(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
+
+tasks.javadoc {
+    isEnabled = false
+}
diff --git a/mockito-extensions/mockito-subclass/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor b/mockito-extensions/mockito-subclass/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
new file mode 100644
index 0000000000..1422f9900b
--- /dev/null
+++ b/mockito-extensions/mockito-subclass/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
@@ -0,0 +1 @@
+member-accessor-module
diff --git a/mockito-extensions/mockito-subclass/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-extensions/mockito-subclass/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
new file mode 100644
index 0000000000..fdbd0b1579
--- /dev/null
+++ b/mockito-extensions/mockito-subclass/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
@@ -0,0 +1 @@
+mock-maker-subclass
diff --git a/mockito-extensions/mockito-subclass/src/test/java/org/mockitosubclass/PluginTest.java b/mockito-extensions/mockito-subclass/src/test/java/org/mockitosubclass/PluginTest.java
new file mode 100644
index 0000000000..c64ecbbe04
--- /dev/null
+++ b/mockito-extensions/mockito-subclass/src/test/java/org/mockitosubclass/PluginTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitosubclass;
+
+import org.junit.Test;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker;
+import org.mockito.internal.util.reflection.ModuleMemberAccessor;
+
+import static org.junit.Assert.*;
+
+public class PluginTest {
+
+    @Test
+    public void mock_maker_should_be_inline() throws Exception {
+        assertTrue(Plugins.getMockMaker() instanceof ByteBuddyMockMaker);
+    }
+
+    @Test
+    public void member_accessor_should_be_module() throws Exception {
+        assertTrue(Plugins.getMemberAccessor() instanceof ModuleMemberAccessor);
+    }
+}
diff --git a/mockito-integration-tests/android-tests/.gitignore b/mockito-integration-tests/android-tests/.gitignore
new file mode 100644
index 0000000000..9315ad56f4
--- /dev/null
+++ b/mockito-integration-tests/android-tests/.gitignore
@@ -0,0 +1,4 @@
+/captures
+.externalNativeBuild
+.cxx
+local.properties
diff --git a/mockito-integration-tests/android-tests/README.md b/mockito-integration-tests/android-tests/README.md
new file mode 100644
index 0000000000..68adf0bd33
--- /dev/null
+++ b/mockito-integration-tests/android-tests/README.md
@@ -0,0 +1,30 @@
+# Android Testing Project
+## Overview
+Unlike the other subprojects, this project is designed to run against the Android toolchain rather than standard Kotlin/Java. This means it should be opened in Android Studio, rather than IntelliJ.
+
+This project was introduced to provide a basic level of assurance for Mockito's correct operation on the Android platform.
+
+This project features the following:
+* the minimum app project prerequisites - it is not intended to be run as an actual app
+* basic JUnit tests
+* basic instrumented tests
+
+While JUnit tests run on the local machine, instrumented tests in the Android context run on a device, which can be an emulator. Due to the Android runtime design, the implementation options for instrumented tests are constrained compared to normal JUnit tests; for example, it is not possible to mock final classes.
+
+## Library Version Definitions / ByteBuddy
+
+Libraries and their versions are defined in `ext.library-versions.gradle`. It is here that you can specify which version of Mockito to test.
+
+ByteBuddy is an optional declaration. If you specify '0' for the ByteBuddy version, e.g.
+
+`bytebuddy_version = '0'`
+
+then ByteBuddy will be as declared by Mockito's own dependencies.
+
+However you are able to specify a _newer_ version if you would like to test an update, and you can do this by specifying a real version, e.g.:
+
+`bytebuddy_version = '1.11.7'`
+
+This will cause ByteBuddy to be directly included in this project using the specified version.
+
+This override is subject to Gradle's dependency resolution process where it reconciles different versions - Mockito's library inclusion vs. the project one. This usually means the newest version is accepted; therefore if you specify a version of ByteBuddy that's _older_ than Mockito's one, it's unlikely to apply it. You would need to use Gradle's `resolutionStrategy` definition to force this.
diff --git a/mockito-integration-tests/android-tests/build.gradle.kts b/mockito-integration-tests/android-tests/build.gradle.kts
new file mode 100644
index 0000000000..565fb8816a
--- /dev/null
+++ b/mockito-integration-tests/android-tests/build.gradle.kts
@@ -0,0 +1,89 @@
+import com.android.build.gradle.internal.coverage.JacocoReportTask
+
+// Module-level android configuration.
+// https://developer.android.com/build/migrate-to-catalogs
+
+plugins {
+    alias(libs.plugins.android.application)
+    id("kotlin-android")
+    id("mockito.test-conventions")
+}
+
+android {
+    namespace = "org.mockitousage.androidtest"
+    compileSdk = 33
+
+    defaultConfig {
+        minSdk = 26
+        targetSdk = 33
+        versionCode = 1
+        versionName = "1.0"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        debug {
+            enableUnitTestCoverage = true
+            enableAndroidTestCoverage = true
+        }
+    }
+    afterEvaluate {
+        // Enable coverage of mockito classes which are not part of this module.
+        // Without these added classFileCollection dependencies the coverage data/report is empty.
+        tasks.named<JacocoReportTask>("createDebugAndroidTestCoverageReport") jacocoTask@{
+            // Clear the production code of this module: src/main/java, it has no mockito-user-visible code.
+            classFileCollection.setFrom()
+            rootProject.allprojects currentProject@{
+                plugins.withId("java") {
+                    val sourceSets = this@currentProject.sourceSets
+                    // Mimic org.gradle.testing.jacoco.tasks.JacocoReportBase.sourceSets().
+                    // Not possible to set task.javaSources because it's initialized with setDisallowChanges.
+                    //task.javaSources.add({ [ sourceSets.main.allJava.srcDirs ] })
+                    this@jacocoTask.classFileCollection.from(
+                        sourceSets.named("main").get().output.asFileTree.matching {
+                            exclude("**/internal/util/concurrent/**")
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+}
+
+androidComponents {
+    beforeVariants(selector().withBuildType("release")) {
+        it.enable = false
+    }
+}
+
+// Exclude mockito-android from JVM tests, because otherwise it clashes with :mockito-core.
+configurations.testImplementation {
+    exclude (group = "org.mockito", module = "mockito-android")
+}
+
+dependencies {
+    implementation(libs.kotlin.stdlib)
+
+    // Add :android on the classpath so that AGP's jacoco setup thinks it's "production code to be tested".
+    // Essentially a way to say: tasks.createDebugAndroidTestCoverageReport.classFileCollection.from(project(":android"))
+    runtimeOnly(project(":mockito-extensions:mockito-android"))
+
+    testImplementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.engine)
+
+    androidTestImplementation(libs.android.runner)
+    androidTestImplementation(libs.android.junit)
+    androidTestImplementation(project(":mockito-extensions:mockito-android"))
+}
diff --git a/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/AaaMustRunFirstLocationTests.kt b/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/AaaMustRunFirstLocationTests.kt
new file mode 100644
index 0000000000..c7e497581b
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/AaaMustRunFirstLocationTests.kt
@@ -0,0 +1,26 @@
+package org.mockitousage.androidtest
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.withSettings
+import org.mockito.internal.creation.proxy.ProxyMockMaker
+
+@RunWith(AndroidJUnit4::class)
+class AaaMustRunFirstLocationTests {
+
+    /**
+     *  Regression test for https://github.com/mockito/mockito/issues/3171 and
+     *  https://github.com/linkedin/dexmaker/issues/190.
+     *
+     *  Bug only triggers if the first time LocationImpl is used is with ProxyMockMaker, therefore
+     *  this test must be the first to run.
+     */
+    @Test
+    fun mockAndUseInterfaceWithProxyMockMaker() {
+        val basicInterface = mock(BasicInterface::class.java,
+            withSettings().mockMaker(ProxyMockMaker::class.java.name))
+        basicInterface.interfaceMethod()
+    }
+}
diff --git a/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/BasicInstrumentedTests.kt b/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/BasicInstrumentedTests.kt
new file mode 100644
index 0000000000..07378171fc
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/BasicInstrumentedTests.kt
@@ -0,0 +1,77 @@
+package org.mockitousage.androidtest
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.verify
+
+@RunWith(AndroidJUnit4::class)
+class BasicInstrumentedTests {
+
+    private var closeable: AutoCloseable? = null
+
+    @Mock private lateinit var mockedViaAnnotationBasicOpenClass: BasicOpenClass
+    @Mock private lateinit var mockedViaAnnotationBasicInterface: BasicInterface
+
+    @Before
+    fun setup() {
+        closeable = MockitoAnnotations.openMocks(this)
+    }
+
+    @After
+    @Throws(Exception::class)
+    fun releaseMocks() {
+        closeable?.close()
+    }
+
+//Open class
+
+    @Test
+    fun mockAndUseBasicClassUsingAnnotatedMock() {
+        val basicClass = BasicOpenClassReceiver(mockedViaAnnotationBasicOpenClass)
+        basicClass.callDependencyMethod()
+    }
+
+    @Test
+    fun mockAndUseBasicClassUsingLocalMock() {
+        val basicOpenClass = mock(BasicOpenClass::class.java)
+        val basicReceiver = BasicOpenClassReceiver(basicOpenClass)
+        basicReceiver.callDependencyMethod()
+    }
+
+    @Test
+    fun mockAndUseBasicClassWithVerify() {
+        val basicClass = BasicOpenClassReceiver(mockedViaAnnotationBasicOpenClass)
+        basicClass.callDependencyMethod()
+        verify(mockedViaAnnotationBasicOpenClass).emptyMethod()
+    }
+
+//Interface
+
+    @Test
+    fun mockAndUseBasicInterfaceUsingAnnotatedMock() {
+        val receiver = BasicInterfaceReceiver(mockedViaAnnotationBasicInterface)
+        receiver.callInterfaceMethod()
+        verify(mockedViaAnnotationBasicInterface).interfaceMethod()
+    }
+
+    @Test
+    fun mockAndUseBasicInterfaceUsingLocalMock() {
+        val basicInterface = mock(BasicInterface::class.java)
+        val receiver = BasicInterfaceReceiver(basicInterface)
+        receiver.callInterfaceMethod()
+    }
+
+    @Test
+    fun mockAndUseBasicInterfaceAndVerify() {
+        val basicInterface = mock(BasicInterface::class.java)
+        val receiver = BasicInterfaceReceiver(basicInterface)
+        receiver.callInterfaceMethod()
+        verify(basicInterface).interfaceMethod()
+    }
+}
diff --git a/mockito-integration-tests/android-tests/src/main/AndroidManifest.xml b/mockito-integration-tests/android-tests/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..955375b4e3
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/main/AndroidManifest.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:allowBackup="true"
+        android:icon="@android:mipmap/sym_def_app_icon"
+        android:label="@string/app_name"
+        android:supportsRtl="true" />
+
+</manifest>
diff --git a/mockito-integration-tests/android-tests/src/main/java/org/mockitousage/androidtest/BasicClassesForTesting.kt b/mockito-integration-tests/android-tests/src/main/java/org/mockitousage/androidtest/BasicClassesForTesting.kt
new file mode 100644
index 0000000000..4c01ef6453
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/main/java/org/mockitousage/androidtest/BasicClassesForTesting.kt
@@ -0,0 +1,35 @@
+package org.mockitousage.androidtest
+
+open class BasicOpenClass {
+    open fun emptyMethod() {
+        //do nothing
+    }
+}
+
+class BasicClosedClass {
+    fun emptyMethod() {
+        //do nothing
+    }
+}
+
+interface BasicInterface {
+    fun interfaceMethod()
+}
+
+class BasicOpenClassReceiver(private val basicOpenClass: BasicOpenClass) {
+    fun callDependencyMethod() {
+        basicOpenClass.emptyMethod()
+    }
+}
+
+class BasicClosedClassReceiver(private val basicClosedClass: BasicClosedClass) {
+    fun callDependencyMethod() {
+        basicClosedClass.emptyMethod()
+    }
+}
+
+class BasicInterfaceReceiver(private val basicInterface: BasicInterface) {
+    fun callInterfaceMethod() {
+        basicInterface.interfaceMethod()
+    }
+}
diff --git a/mockito-integration-tests/android-tests/src/main/res/values/strings.xml b/mockito-integration-tests/android-tests/src/main/res/values/strings.xml
new file mode 100644
index 0000000000..33d20491a8
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/main/res/values/strings.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+ Copyright (c) 2023 Mockito contributors
+ This program is made available under the terms of the MIT License.
+-->
+<resources>
+    <string name="app_name">Mockito Android Tests</string>
+</resources>
diff --git a/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/JUnit4BasicTests.kt b/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/JUnit4BasicTests.kt
new file mode 100644
index 0000000000..e8b66d5836
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/JUnit4BasicTests.kt
@@ -0,0 +1,83 @@
+package org.mockitousage.androidtest
+
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+class JUnit4BasicTests {
+
+    private var closeable: AutoCloseable? = null
+    private lateinit var sharedJUnitTests: SharedJUnitTests
+
+    @Mock private lateinit var mockedViaAnnotationBasicOpenClass: BasicOpenClass
+    @Mock private lateinit var mockedViaAnnotationBasicClosedClass: BasicClosedClass
+    @Mock private lateinit var mockedViaAnnotationBasicInterface: BasicInterface
+
+    @Before
+    fun setup() {
+        closeable = MockitoAnnotations.openMocks(this)
+        sharedJUnitTests = SharedJUnitTests(
+            mockedViaAnnotationBasicOpenClass,
+            mockedViaAnnotationBasicClosedClass,
+            mockedViaAnnotationBasicInterface)
+    }
+
+    @After
+    @Throws(Exception::class)
+    fun releaseMocks() {
+        closeable?.close()
+    }
+
+//Open class
+
+    @Test
+    fun mockAndUseBasicOpenClassUsingAnnotatedMock() {
+        sharedJUnitTests.mockAndUseBasicOpenClassUsingAnnotatedMock()
+    }
+
+    @Test
+    fun mockAndUseBasicOpenClassUsingLocalMock() {
+        sharedJUnitTests.mockAndUseBasicOpenClassUsingLocalMock()
+    }
+
+    @Test
+    fun mockAndUseBasicOpenClassWithVerify() {
+        sharedJUnitTests.mockAndUseBasicOpenClassWithVerify()
+    }
+
+//Closed class
+
+    @Test
+    fun mockAndUseBasicClosedClassUsingAnnotatedMock() {
+        sharedJUnitTests.mockAndUseBasicClosedClassUsingAnnotatedMock()
+    }
+
+    @Test
+    fun mockAndUseBasicClosedClassUsingLocalMock() {
+        sharedJUnitTests.mockAndUseBasicClosedClassUsingLocalMock()
+    }
+
+    @Test
+    fun mockAndUseBasicClosedClassWithVerify() {
+        sharedJUnitTests.mockAndUseBasicClosedClassWithVerify()
+    }
+
+//Interface
+
+    @Test
+    fun mockAndUseBasicInterfaceUsingAnnotatedMock() {
+        sharedJUnitTests.mockAndUseBasicInterfaceUsingAnnotatedMock()
+    }
+
+    @Test
+    fun mockAndUseBasicInterfaceUsingLocalMock() {
+        sharedJUnitTests.mockAndUseBasicInterfaceUsingLocalMock()
+    }
+
+    @Test
+    fun mockAndUseBasicInterfaceAndVerify() {
+        sharedJUnitTests.mockAndUseBasicInterfaceAndVerify()
+    }
+}
diff --git a/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/JUnit5BasicTests.kt b/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/JUnit5BasicTests.kt
new file mode 100644
index 0000000000..855e49ffd7
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/JUnit5BasicTests.kt
@@ -0,0 +1,84 @@
+package org.mockitousage.androidtest
+
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+class JUnit5BasicTests {
+
+    private lateinit var closeable: AutoCloseable
+    private lateinit var sharedJUnitTests: SharedJUnitTests
+
+    @Mock private lateinit var mockedViaAnnotationBasicOpenClass: BasicOpenClass
+    @Mock private lateinit var mockedViaAnnotationBasicClosedClass: BasicClosedClass
+    @Mock private lateinit var mockedViaAnnotationBasicInterface: BasicInterface
+
+    @BeforeEach
+    fun setup() {
+        closeable = MockitoAnnotations.openMocks(this)
+        sharedJUnitTests = SharedJUnitTests(
+            mockedViaAnnotationBasicOpenClass,
+            mockedViaAnnotationBasicClosedClass,
+            mockedViaAnnotationBasicInterface)
+    }
+
+    @AfterEach
+    @Throws(Exception::class)
+    fun releaseMocks() {
+        closeable.close()
+    }
+
+
+//Open class
+
+    @Test
+    fun mockAndUseBasicOpenClassUsingAnnotatedMock() {
+        sharedJUnitTests.mockAndUseBasicOpenClassUsingAnnotatedMock()
+    }
+
+    @Test
+    fun mockAndUseBasicOpenClassUsingLocalMock() {
+        sharedJUnitTests.mockAndUseBasicOpenClassUsingLocalMock()
+    }
+
+    @Test
+    fun mockAndUseBasicOpenClassWithVerify() {
+        sharedJUnitTests.mockAndUseBasicOpenClassWithVerify()
+    }
+
+//Closed class
+
+    @Test
+    fun mockAndUseBasicClosedClassUsingAnnotatedMock() {
+        sharedJUnitTests.mockAndUseBasicClosedClassUsingAnnotatedMock()
+    }
+
+    @Test
+    fun mockAndUseBasicClosedClassUsingLocalMock() {
+        sharedJUnitTests.mockAndUseBasicClosedClassUsingLocalMock()
+    }
+
+    @Test
+    fun mockAndUseBasicClosedClassWithVerify() {
+        sharedJUnitTests.mockAndUseBasicClosedClassWithVerify()
+    }
+
+//Interface
+
+    @Test
+    fun mockAndUseBasicInterfaceUsingAnnotatedMock() {
+        sharedJUnitTests.mockAndUseBasicInterfaceUsingAnnotatedMock()
+    }
+
+    @Test
+    fun mockAndUseBasicInterfaceUsingLocalMock() {
+        sharedJUnitTests.mockAndUseBasicInterfaceUsingLocalMock()
+    }
+
+    @Test
+    fun mockAndUseBasicInterfaceAndVerify() {
+        sharedJUnitTests.mockAndUseBasicInterfaceAndVerify()
+    }
+}
diff --git a/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/SharedJUnitTests.kt b/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/SharedJUnitTests.kt
new file mode 100644
index 0000000000..11a6a12e5b
--- /dev/null
+++ b/mockito-integration-tests/android-tests/src/test/java/org/mockitousage/androidtest/SharedJUnitTests.kt
@@ -0,0 +1,68 @@
+package org.mockitousage.androidtest
+
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.verify
+
+class SharedJUnitTests(
+    private val mockedViaAnnotationBasicOpenClass: BasicOpenClass,
+    private val mockedViaAnnotationBasicClosedClass: BasicClosedClass,
+    private val mockedViaAnnotationBasicInterface: BasicInterface,
+)
+{
+    fun mockAndUseBasicOpenClassUsingAnnotatedMock() {
+        val basicClass = BasicOpenClassReceiver(mockedViaAnnotationBasicOpenClass)
+        basicClass.callDependencyMethod()
+    }
+
+    fun mockAndUseBasicOpenClassUsingLocalMock() {
+        val basicOpenClass = mock(BasicOpenClass::class.java)
+        val basicReceiver = BasicOpenClassReceiver(basicOpenClass)
+        basicReceiver.callDependencyMethod()
+    }
+
+    fun mockAndUseBasicOpenClassWithVerify() {
+        val basicClass = BasicOpenClassReceiver(mockedViaAnnotationBasicOpenClass)
+        basicClass.callDependencyMethod()
+        verify(mockedViaAnnotationBasicOpenClass).emptyMethod()
+    }
+
+//Closed class
+
+    fun mockAndUseBasicClosedClassUsingAnnotatedMock() {
+        val basicReceiver = BasicClosedClassReceiver(mockedViaAnnotationBasicClosedClass)
+        basicReceiver.callDependencyMethod()
+    }
+
+    fun mockAndUseBasicClosedClassUsingLocalMock() {
+        val basicClosedClass = mock(BasicClosedClass::class.java)
+        val basicReceiver = BasicClosedClassReceiver(basicClosedClass)
+        basicReceiver.callDependencyMethod()
+    }
+
+    fun mockAndUseBasicClosedClassWithVerify() {
+        val basicReceiver = BasicClosedClassReceiver(mockedViaAnnotationBasicClosedClass)
+        basicReceiver.callDependencyMethod()
+        verify(mockedViaAnnotationBasicClosedClass).emptyMethod()
+    }
+
+//Interface
+
+    fun mockAndUseBasicInterfaceUsingAnnotatedMock() {
+        val receiver = BasicInterfaceReceiver(mockedViaAnnotationBasicInterface)
+        receiver.callInterfaceMethod()
+        verify(mockedViaAnnotationBasicInterface).interfaceMethod()
+    }
+
+    fun mockAndUseBasicInterfaceUsingLocalMock() {
+        val basicInterface = mock(BasicInterface::class.java)
+        val receiver = BasicInterfaceReceiver(basicInterface)
+        receiver.callInterfaceMethod()
+    }
+
+    fun mockAndUseBasicInterfaceAndVerify() {
+        val basicInterface = mock(BasicInterface::class.java)
+        val receiver = BasicInterfaceReceiver(basicInterface)
+        receiver.callInterfaceMethod()
+        verify(basicInterface).interfaceMethod()
+    }
+}
diff --git a/mockito-integration-tests/extensions-tests/build.gradle.kts b/mockito-integration-tests/extensions-tests/build.gradle.kts
new file mode 100644
index 0000000000..6c88678016
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/build.gradle.kts
@@ -0,0 +1,30 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "End-to-end tests for Mockito and its extensions."
+
+dependencies {
+    testImplementation(project(":mockito-core"))
+    testImplementation(project(":mockito-extensions:mockito-junit-jupiter"))
+    testImplementation(testFixtures(project(":mockito-core")))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.junit.vintage.engine)
+    testRuntimeOnly(libs.junit.platform.launcher)
+}
+
+tasks {
+    withType<Test> {
+        useJUnitPlatform()
+    }
+}
+
+configurations.configureEach {
+    //TODO SF enable when #154 is implemented
+    //let's make those tests not use hamcrest
+    //exclude group: 'org.hamcrest', module: 'hamcrest-core'
+}
diff --git a/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java
new file mode 100644
index 0000000000..5649610c87
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins.donotmockenforcer;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+
+import org.junit.Test;
+import org.mockito.DoNotMock;
+import org.mockito.MockedStatic;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.DoNotMockException;
+
+public class DoNotmockEnforcerTest {
+
+    @Test
+    public void uses_custom_enforcer_disallows_mocks_of_types_in_this_package() {
+        assertThatThrownBy(
+                        () -> {
+                            NotMockable notMockable = mock(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
+    @Test
+    public void uses_custom_enforcer_allows_special_cased_class() {
+        NotMockableButSpecialCased notMockable = mock(NotMockableButSpecialCased.class);
+    }
+
+    @Test
+    public void uses_custom_enforcer_allows_statically_non_mockable() {
+        StaticallyNotMockable notMockable = mock(StaticallyNotMockable.class);
+    }
+
+    @Test
+    public void uses_custom_enforcer_disallows_static_mocks_of_type_with_specific_name() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyNotMockable> notMockable =
+                                    mockStatic(StaticallyNotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Cannot mockStatic!");
+    }
+
+    @Test
+    public void
+            uses_custom_enforcer_disallows_static_mocks_of_type_that_inherits_from_non_statically_mockable() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyNotMockableChild> notMockable =
+                                    mockStatic(StaticallyNotMockableChild.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Cannot mockStatic!");
+    }
+
+    @Test
+    public void uses_custom_enforcer_allows_static_mocks_of_type_with_specific_name() {
+        /*
+         Current MockMaker does not support static mocks, so asserting we get its exception rather than
+         a DoNotMockException is enough to assert the DoNotMockEnforcer let it through.
+        */
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyMockable> notMockable =
+                                    mockStatic(StaticallyMockable.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .isNotInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("does not support the creation of static mocks");
+    }
+
+    @Test
+    public void uses_custom_enforcer_has_custom_message() {
+        assertThatThrownBy(
+                        () -> {
+                            NotMockable notMockable = mock(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Custom message!");
+    }
+
+    static class NotMockable {}
+
+    @DoNotMock
+    static class NotMockableButSpecialCased {}
+
+    static class StaticallyNotMockable {}
+
+    static class StaticallyNotMockableChild extends StaticallyNotMockable {}
+
+    static class StaticallyMockable {}
+}
diff --git a/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java
new file mode 100644
index 0000000000..ae450806e0
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins.donotmockenforcer;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockType;
+import org.mockito.plugins.DoNotMockEnforcer;
+
+public class MyDoNotMockEnforcer implements DoNotMockEnforcer {
+
+    @Override
+    public String checkTypeForDoNotMockViolation(Class<?> type) {
+        // Special case a type, because we want to opt-out of enforcing
+        if (type.getName().endsWith("NotMockableButSpecialCased")) {
+            return null;
+        }
+        // Special case for allowing StaticallyNotMockable to still be used for regular mocks
+        if (type.getName().endsWith("StaticallyNotMockable")) {
+            return null;
+        }
+        if (type.getName().startsWith("org.mockitousage.plugins.donotmockenforcer")) {
+            return "Custom message!";
+        }
+        return null;
+    }
+
+    @Override
+    public String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings) {
+        if (creationSettings.getMockType() == MockType.STATIC) {
+            Class<?> type = creationSettings.getTypeToMock();
+            if (type.getName().endsWith("StaticallyMockable")) {
+                return null;
+            }
+            if (type.getName().startsWith("org.mockitousage.plugins.donotmockenforcer")) {
+                return "Cannot mockStatic!";
+            }
+            return null;
+        }
+        return DoNotMockEnforcer.super.checkTypeForDoNotMockViolation(creationSettings);
+    }
+}
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/InstantiatorProviderTest.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/instantiator/InstantiatorProviderTest.java
similarity index 92%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/InstantiatorProviderTest.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/instantiator/InstantiatorProviderTest.java
index 45391d31fe..20e8f2fd72 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/InstantiatorProviderTest.java
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/instantiator/InstantiatorProviderTest.java
@@ -17,13 +17,13 @@ public class InstantiatorProviderTest {
     @SuppressWarnings("CheckReturnValue")
     @Test
     public void uses_custom_instantiator_provider() {
-        //given mocking works:
+        // given mocking works:
         mock(List.class);
 
-        //when
+        // when
         MyInstantiatorProvider2.explosive.set(true);
 
-        //then
+        // then
         try {
             mock(List.class);
             fail();
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider2.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider2.java
similarity index 100%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider2.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider2.java
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/logger/MockitoLoggerTest.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/logger/MockitoLoggerTest.java
similarity index 85%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/logger/MockitoLoggerTest.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/logger/MockitoLoggerTest.java
index c1cce51221..e614a4bb66 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/logger/MockitoLoggerTest.java
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/logger/MockitoLoggerTest.java
@@ -34,12 +34,11 @@ void strictness_warn_logged_into_custom_logger() {
     @AfterAll
     static void tearDown() {
         final List<Object> loggedItems = MyMockitoLogger.getLoggedItems();
-        assertThat(loggedItems)
-            .hasSize(1);
+        assertThat(loggedItems).hasSize(1);
         assertThat(loggedItems.get(0).toString())
-            .contains("[MockitoHint]")
-            .contains("org.mockitousage.plugins.logger.MockitoLoggerTest")
-            .contains("Unused");
+                .contains("[MockitoHint]")
+                .contains("org.mockitousage.plugins.logger.MockitoLoggerTest")
+                .contains("Unused");
 
         MyMockitoLogger.clear();
     }
diff --git a/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/logger/MyMockitoLogger.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/logger/MyMockitoLogger.java
new file mode 100644
index 0000000000..7f5c3abc63
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/logger/MyMockitoLogger.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins.logger;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.internal.util.ConsoleMockitoLogger;
+import org.mockito.plugins.MockitoLogger;
+
+public class MyMockitoLogger implements MockitoLogger {
+    private static final ThreadLocal<Boolean> enabled =
+            new ThreadLocal<Boolean>() {
+                @Override
+                protected Boolean initialValue() {
+                    return false;
+                }
+            };
+    private static final ThreadLocal<List<Object>> loggedItems =
+            new ThreadLocal<List<Object>>() {
+                @Override
+                protected List<Object> initialValue() {
+                    return new ArrayList<Object>();
+                }
+            };
+
+    private final MockitoLogger defaultLogger = new ConsoleMockitoLogger();
+
+    @Override
+    public void log(Object what) {
+        if (enabled.get()) {
+            loggedItems.get().add(what);
+        } else {
+            defaultLogger.log(what);
+        }
+    }
+
+    static void enable() {
+        enabled.set(true);
+    }
+
+    static List<Object> getLoggedItems() {
+        return loggedItems.get();
+    }
+
+    static void clear() {
+        enabled.remove();
+        loggedItems.remove();
+    }
+}
diff --git a/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/resolver/MockResolverTest.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/resolver/MockResolverTest.java
new file mode 100644
index 0000000000..48d41b90d7
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/resolver/MockResolverTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins.resolver;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.*;
+
+@MockitoSettings(strictness = Strictness.WARN)
+@ExtendWith(MockitoExtension.class)
+class MockResolverTest {
+
+    @Test
+    void mock_resolver_can_unwrap_mocked_instance() {
+        Foo mock = mock(Foo.class), wrapper = new MockWrapper(mock);
+        when(wrapper.doIt()).thenReturn(123);
+        assertThat(mock.doIt()).isEqualTo(123);
+        assertThat(wrapper.doIt()).isEqualTo(123);
+        verify(wrapper, times(2)).doIt();
+    }
+
+    interface Foo {
+        int doIt();
+    }
+
+    static class MockWrapper implements Foo {
+
+        private final Foo mock;
+
+        MockWrapper(Foo mock) {
+            this.mock = mock;
+        }
+
+        Object getMock() {
+            return mock;
+        }
+
+        @Override
+        public int doIt() {
+            return mock.doIt();
+        }
+    }
+}
diff --git a/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/resolver/MyMockResolver.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/resolver/MyMockResolver.java
new file mode 100644
index 0000000000..e14804f6c5
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/resolver/MyMockResolver.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins.resolver;
+
+import org.mockito.plugins.MockResolver;
+
+public class MyMockResolver implements MockResolver {
+
+    @Override
+    public Object resolve(Object instance) {
+        if (instance instanceof MockResolverTest.MockWrapper) {
+            return ((MockResolverTest.MockWrapper) instance).getMock();
+        }
+        return instance;
+    }
+}
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java
similarity index 79%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java
index 951c149d66..aa4efa4620 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java
@@ -16,13 +16,13 @@ public class MyStackTraceCleanerProvider implements StackTraceCleanerProvider {
 
     public StackTraceCleaner getStackTraceCleaner(final StackTraceCleaner defaultCleaner) {
         return new StackTraceCleaner() {
-			@Override
-			public boolean isIn(StackTraceElement candidate) {
-				if (ENABLED && candidate.getMethodName().contains("excludeMe")) {
+            @Override
+            public boolean isIn(StackTraceElement candidate) {
+                if (ENABLED && candidate.getMethodName().contains("excludeMe")) {
                     return false;
                 }
                 return defaultCleaner.isIn(candidate);
-			}
+            }
         };
     }
 }
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/PluginStackTraceFilteringTest.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/stacktrace/PluginStackTraceFilteringTest.java
similarity index 85%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/PluginStackTraceFilteringTest.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/stacktrace/PluginStackTraceFilteringTest.java
index 039363b240..fcd6b76eff 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/PluginStackTraceFilteringTest.java
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/stacktrace/PluginStackTraceFilteringTest.java
@@ -38,9 +38,7 @@ public void pluginFiltersOutStackTraceElement() {
             fail();
         } catch (WantedButNotInvoked e) {
             String trace = getStackTrace(e);
-            assertThat(trace)
-                    .contains("verifyMock_x")
-                    .doesNotContain("verify_excludeMe_x");
+            assertThat(trace).contains("verifyMock_x").doesNotContain("verify_excludeMe_x");
         }
     }
 
@@ -52,9 +50,7 @@ public void pluginDoesNotFilterOutStackTraceElement() {
             fail();
         } catch (WantedButNotInvoked e) {
             String trace = getStackTrace(e);
-            assertThat(trace)
-                    .contains("verifyMock_x")
-                    .contains("verify_excludeMe_x");
+            assertThat(trace).contains("verifyMock_x").contains("verify_excludeMe_x");
         }
     }
 
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyMockMaker.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/MyMockMaker.java
similarity index 100%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyMockMaker.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/MyMockMaker.java
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java
similarity index 83%
rename from subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java
rename to mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java
index eb4423f361..cf60ee63ec 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java
@@ -14,6 +14,10 @@ public class MyPluginSwitch implements PluginSwitch {
     static List<String> invokedFor = new LinkedList<String>();
 
     public boolean isEnabled(String pluginClassName) {
+        if (!pluginClassName.startsWith("org.mockitousage")) {
+            return false;
+        }
+
         invokedFor.add(pluginClassName);
         return true;
     }
diff --git a/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/PluginSwitchTest.java b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/PluginSwitchTest.java
new file mode 100644
index 0000000000..7737b569e8
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/java/org/mockitousage/plugins/switcher/PluginSwitchTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.plugins.switcher;
+
+import org.junit.Test;
+import org.mockitousage.plugins.donotmockenforcer.MyDoNotMockEnforcer;
+import org.mockitousage.plugins.instantiator.MyInstantiatorProvider2;
+import org.mockitousage.plugins.logger.MyMockitoLogger;
+import org.mockitousage.plugins.resolver.MyMockResolver;
+import org.mockitousage.plugins.stacktrace.MyStackTraceCleanerProvider;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+public class PluginSwitchTest {
+
+    @SuppressWarnings("CheckReturnValue")
+    @Test
+    public void plugin_switcher_is_used() {
+        mock(List.class);
+        assertThat(MyPluginSwitch.invokedFor)
+                .hasSameElementsAs(
+                        asList(
+                                MyMockMaker.class.getName(),
+                                MyStackTraceCleanerProvider.class.getName(),
+                                MyMockitoLogger.class.getName(),
+                                MyDoNotMockEnforcer.class.getName(),
+                                MyMockResolver.class.getName(),
+                                MyInstantiatorProvider2.class.getName()));
+    }
+
+    @Test
+    public void uses_custom_mock_maker() {
+        // when
+        MyMockMaker.explosive.set(new Object());
+
+        // when
+        try {
+            mock(List.class);
+            fail();
+        } catch (Exception e) {
+            assertEquals(MyMockMaker.class.getName(), e.getMessage());
+        } finally {
+            MyMockMaker.explosive.remove();
+        }
+    }
+}
diff --git a/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.DoNotMockEnforcer b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.DoNotMockEnforcer
new file mode 100644
index 0000000000..c8fff4f30b
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.DoNotMockEnforcer
@@ -0,0 +1 @@
+org.mockitousage.plugins.donotmockenforcer.MyDoNotMockEnforcer
diff --git a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider2 b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider2
similarity index 100%
rename from subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider2
rename to mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider2
diff --git a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
similarity index 100%
rename from subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
rename to mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
diff --git a/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockResolver b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockResolver
new file mode 100644
index 0000000000..7f2835f93a
--- /dev/null
+++ b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockResolver
@@ -0,0 +1 @@
+org.mockitousage.plugins.resolver.MyMockResolver
diff --git a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockitoLogger b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockitoLogger
similarity index 100%
rename from subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockitoLogger
rename to mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockitoLogger
diff --git a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.PluginSwitch b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.PluginSwitch
similarity index 100%
rename from subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.PluginSwitch
rename to mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.PluginSwitch
diff --git a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.StackTraceCleanerProvider b/mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.StackTraceCleanerProvider
similarity index 100%
rename from subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.StackTraceCleanerProvider
rename to mockito-integration-tests/extensions-tests/src/test/resources/mockito-extensions/org.mockito.plugins.StackTraceCleanerProvider
diff --git a/mockito-integration-tests/groovy-inline-tests/build.gradle.kts b/mockito-integration-tests/groovy-inline-tests/build.gradle.kts
new file mode 100644
index 0000000000..9e666b545d
--- /dev/null
+++ b/mockito-integration-tests/groovy-inline-tests/build.gradle.kts
@@ -0,0 +1,13 @@
+plugins {
+    id("groovy")
+    id("mockito.test-conventions")
+}
+
+
+description = "Integration test for using mockito-inline with Groovy."
+
+dependencies {
+    testImplementation(project(":mockito-core"))
+    testImplementation(libs.groovy)
+    testImplementation(libs.junit4)
+}
diff --git a/mockito-integration-tests/groovy-inline-tests/src/test/groovy/org/mockito/groovy/GroovyMockitoTest.groovy b/mockito-integration-tests/groovy-inline-tests/src/test/groovy/org/mockito/groovy/GroovyMockitoTest.groovy
new file mode 100644
index 0000000000..c327d0e1bb
--- /dev/null
+++ b/mockito-integration-tests/groovy-inline-tests/src/test/groovy/org/mockito/groovy/GroovyMockitoTest.groovy
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.groovy
+
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+
+import static org.mockito.Mockito.verify
+
+@RunWith(MockitoJUnitRunner)
+class GroovyMockitoTest {
+
+    @Mock Helper helper
+    @InjectMocks ClassUnderTest classUnderTest
+
+    /**
+     * Test that the Groovy class under test can call methods on a mocked Groovy
+     * helper class.
+     */
+    @Test
+    void testCallGroovyFromGroovy() {
+        classUnderTest.methodUnderTest()
+        verify(helper).helperMethod()
+    }
+
+    static class ClassUnderTest {
+        private final Helper helper
+
+        ClassUnderTest(Helper helper) {
+            this.helper = helper
+        }
+
+        void methodUnderTest() {
+            helper.helperMethod()
+        }
+    }
+
+    static class Helper {
+        void helperMethod() { }
+    }
+}
diff --git a/mockito-integration-tests/groovy-tests/build.gradle.kts b/mockito-integration-tests/groovy-tests/build.gradle.kts
new file mode 100644
index 0000000000..d09ff7835d
--- /dev/null
+++ b/mockito-integration-tests/groovy-tests/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+    id("groovy")
+    id("mockito.test-conventions")
+}
+
+description = "Integration test for using Mockito from Groovy."
+
+dependencies {
+    testImplementation(project(":mockito-core"))
+    testImplementation(libs.groovy)
+    testImplementation(libs.junit4)
+}
diff --git a/mockito-integration-tests/groovy-tests/src/test/groovy/org/mockito/groovy/GroovyMockitoTest.groovy b/mockito-integration-tests/groovy-tests/src/test/groovy/org/mockito/groovy/GroovyMockitoTest.groovy
new file mode 100644
index 0000000000..b472aaabcc
--- /dev/null
+++ b/mockito-integration-tests/groovy-tests/src/test/groovy/org/mockito/groovy/GroovyMockitoTest.groovy
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.groovy
+
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+
+import static org.mockito.Mockito.verify
+
+@RunWith(MockitoJUnitRunner)
+class GroovyMockitoTest {
+
+    @Mock Helper helper
+    @InjectMocks ClassUnderTest classUnderTest
+
+    /**
+     * Test that the Groovy class under test can call methods on a mocked Groovy
+     * helper class.
+     */
+    @Test
+    void testCallGroovyFromGroovy() {
+        classUnderTest.methodUnderTest()
+        verify(helper).helperMethod()
+    }
+
+    static class ClassUnderTest {
+        private final Helper helper
+
+        ClassUnderTest(Helper helper) {
+            this.helper = helper
+        }
+
+        void methodUnderTest() {
+            helper.helperMethod()
+        }
+    }
+
+    static class Helper {
+        void helperMethod() { }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/build.gradle.kts b/mockito-integration-tests/inline-mocks-tests/build.gradle.kts
new file mode 100644
index 0000000000..4a1a4f9953
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/build.gradle.kts
@@ -0,0 +1,28 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Mockito preconfigured inline mock maker (intermediate and to be superseeded by automatic usage in a future version)"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
+tasks {
+    test {
+        if (JavaVersion.VERSION_17 <= JavaVersion.current()) {
+            // For Java 17: https://openjdk.org/jeps/403
+            // > Ignoring option --illegal-access=deny; support was removed in 17.0
+        } else if (JavaVersion.VERSION_16 <= JavaVersion.current()) {
+            // For Java 16: https://openjdk.org/jeps/396
+            // --illegal-access=deny is the default.
+        } else if (JavaVersion.VERSION_1_9 <= JavaVersion.current()) {
+            // For Java 9-15: https://openjdk.org/jeps/261#Relaxed-strong-encapsulation
+            jvmArgs("--illegal-access=deny")
+        }
+        //required by the "StressTest.java" and "OneLinerStubStressTest.java"
+        maxHeapSize = "256m"
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/ConstructionMockRuleTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/ConstructionMockRuleTest.java
new file mode 100644
index 0000000000..53477f67ab
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/ConstructionMockRuleTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import static junit.framework.TestCase.*;
+
+public final class ConstructionMockRuleTest {
+
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock private MockedConstruction<Dummy> dummy;
+
+    @Test
+    public void testConstructionMockSimple() {
+        assertNull(new Dummy().foo());
+    }
+
+    @Test
+    public void testConstructionMockCollection() {
+        assertEquals(0, dummy.constructed().size());
+        Dummy mock = new Dummy();
+        assertEquals(1, dummy.constructed().size());
+        assertTrue(dummy.constructed().contains(mock));
+    }
+
+    static class Dummy {
+
+        String foo() {
+            return "foo";
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/ConstructionMockTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/ConstructionMockTest.java
new file mode 100644
index 0000000000..93bb0438a9
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/ConstructionMockTest.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertNull;
+import static junit.framework.TestCase.assertTrue;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.Collections;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+import org.mockito.MockMakers;
+import org.mockito.MockedConstruction;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+
+public final class ConstructionMockTest {
+
+    @Test
+    public void testConstructionMockSimple() {
+        assertEquals("foo", new Dummy().foo());
+        try (MockedConstruction<Dummy> ignored = Mockito.mockConstruction(Dummy.class)) {
+            assertNull(new Dummy().foo());
+        }
+        assertEquals("foo", new Dummy().foo());
+    }
+
+    @Test
+    public void testConstructionMockCollection() {
+        try (MockedConstruction<Dummy> dummy = Mockito.mockConstruction(Dummy.class)) {
+            assertEquals(0, dummy.constructed().size());
+            Dummy mock = new Dummy();
+            assertEquals(1, dummy.constructed().size());
+            assertTrue(dummy.constructed().contains(mock));
+        }
+    }
+
+    @Test
+    public void testConstructionMockDefaultAnswer() {
+        try (MockedConstruction<Dummy> ignored =
+                Mockito.mockConstructionWithAnswer(Dummy.class, invocation -> "bar")) {
+            assertEquals("bar", new Dummy().foo());
+        }
+    }
+
+    @Test
+    public void testConstructionMockDefaultAnswerMultiple() {
+        try (MockedConstruction<Dummy> ignored =
+                Mockito.mockConstructionWithAnswer(
+                        Dummy.class, invocation -> "bar", invocation -> "qux")) {
+            assertEquals("bar", new Dummy().foo());
+            assertEquals("qux", new Dummy().foo());
+            assertEquals("qux", new Dummy().foo());
+        }
+    }
+
+    /**
+     * Tests issue #2544
+     */
+    @Test
+    public void testConstructionMockDefaultAnswerMultipleMoreThanTwo() {
+        try (MockedConstruction<Dummy> ignored =
+                Mockito.mockConstructionWithAnswer(
+                        Dummy.class,
+                        invocation -> "bar",
+                        invocation -> "qux",
+                        invocation -> "baz")) {
+            assertEquals("bar", new Dummy().foo());
+            assertEquals("qux", new Dummy().foo());
+            assertEquals("baz", new Dummy().foo());
+            assertEquals("baz", new Dummy().foo());
+        }
+    }
+
+    @Test
+    public void testConstructionMockPrepared() {
+        try (MockedConstruction<Dummy> ignored =
+                Mockito.mockConstruction(
+                        Dummy.class, (mock, context) -> when(mock.foo()).thenReturn("bar"))) {
+            assertEquals("bar", new Dummy().foo());
+        }
+    }
+
+    @Test
+    public void testConstructionMockContext() {
+        try (MockedConstruction<Dummy> ignored =
+                Mockito.mockConstruction(
+                        Dummy.class,
+                        (mock, context) -> {
+                            assertEquals(1, context.getCount());
+                            assertEquals(Collections.singletonList("foobar"), context.arguments());
+                            assertEquals(
+                                    mock.getClass().getDeclaredConstructor(String.class),
+                                    context.constructor());
+                            when(mock.foo()).thenReturn("bar");
+                        })) {
+            assertEquals("bar", new Dummy("foobar").foo());
+        }
+    }
+
+    @Test
+    public void testConstructionMockDoesNotAffectDifferentThread() throws InterruptedException {
+        try (MockedConstruction<Dummy> ignored = Mockito.mockConstruction(Dummy.class)) {
+            Dummy dummy = new Dummy();
+            when(dummy.foo()).thenReturn("bar");
+            assertEquals("bar", dummy.foo());
+            verify(dummy).foo();
+            AtomicReference<String> reference = new AtomicReference<>();
+            Thread thread = new Thread(() -> reference.set(new Dummy().foo()));
+            thread.start();
+            thread.join();
+            assertEquals("foo", reference.get());
+            when(dummy.foo()).thenReturn("bar");
+            assertEquals("bar", dummy.foo());
+            verify(dummy, times(2)).foo();
+        }
+    }
+
+    @Test
+    public void testConstructionMockCanCoexistWithMockInDifferentThread()
+            throws InterruptedException {
+        try (MockedConstruction<Dummy> ignored = Mockito.mockConstruction(Dummy.class)) {
+            Dummy dummy = new Dummy();
+            when(dummy.foo()).thenReturn("bar");
+            assertEquals("bar", dummy.foo());
+            verify(dummy).foo();
+            AtomicReference<String> reference = new AtomicReference<>();
+            Thread thread =
+                    new Thread(
+                            () -> {
+                                try (MockedConstruction<Dummy> ignored2 =
+                                        Mockito.mockConstruction(Dummy.class)) {
+                                    Dummy other = new Dummy();
+                                    when(other.foo()).thenReturn("qux");
+                                    reference.set(other.foo());
+                                }
+                            });
+            thread.start();
+            thread.join();
+            assertEquals("qux", reference.get());
+            assertEquals("bar", dummy.foo());
+            verify(dummy, times(2)).foo();
+        }
+    }
+
+    @Test
+    public void testConstructionMockMustBeExclusiveInScopeWithinThread() {
+        assertThatThrownBy(
+                        () -> {
+                            try (MockedConstruction<Dummy> dummy =
+                                            Mockito.mockConstruction(Dummy.class);
+                                    MockedConstruction<Dummy> duplicate =
+                                            Mockito.mockConstruction(Dummy.class)) {}
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("static mocking is already registered in the current thread");
+    }
+
+    @Test
+    public void testConstructionMockMustNotTargetAbstractClass() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mockConstruction(Runnable.class).close();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining(
+                        "It is not possible to construct primitive types or abstract types");
+    }
+
+    @Test
+    public void testConstructionMocksMustNotUseCustomMockMaker() {
+        assertThatThrownBy(
+                        () -> {
+                            try (MockedConstruction<Dummy> ignored =
+                                    Mockito.mockConstruction(
+                                            Dummy.class,
+                                            withSettings().mockMaker(MockMakers.INLINE))) {
+                                new Dummy();
+                            }
+                        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("you cannot override the MockMaker for construction mocks");
+    }
+
+    static class Dummy {
+
+        public Dummy() {}
+
+        public Dummy(String value) {}
+
+        String foo() {
+            return "foo";
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/EnumMockingTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/EnumMockingTest.java
new file mode 100644
index 0000000000..a418aab7a4
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/EnumMockingTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class EnumMockingTest {
+
+    @Test
+    public void testMockEnum() {
+        Animal a = Mockito.mock(Animal.class);
+        assertThat(a, not(equalTo(Animal.CAT)));
+        assertThat(a.sound(), nullValue(String.class));
+        assertThat(a.name(), nullValue(String.class));
+    }
+
+    enum Animal {
+        CAT {
+            @Override
+            public String sound() {
+                return "meow";
+            }
+        };
+
+        public abstract String sound();
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/FinalClassMockingTest.java
similarity index 88%
rename from subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/FinalClassMockingTest.java
index 80c9de851a..306f59af1a 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/FinalClassMockingTest.java
@@ -15,8 +15,5 @@ public void no_exception_while_mocking_final_class() throws Exception {
         Mockito.mock(FinalClass.class);
     }
 
-    private static final class FinalClass {
-
-    }
-
+    private static final class FinalClass {}
 }
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/HierarchyPreInitializationTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/HierarchyPreInitializationTest.java
new file mode 100644
index 0000000000..cb9aeb5308
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/HierarchyPreInitializationTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+
+public class HierarchyPreInitializationTest {
+
+    @Test
+    @SuppressWarnings("CheckReturnValue")
+    public void testOrder() {
+        mock(MyClass.class);
+        mock(TestSubInterface.class);
+    }
+
+    public interface TestInterface {
+
+        @SuppressWarnings("unused")
+        MyClass INSTANCE = new MyClass().probe();
+    }
+
+    public interface TestSubInterface extends TestInterface {}
+
+    public static class MyClass {
+
+        private final Object obj;
+
+        public MyClass() {
+            obj = new Object();
+        }
+
+        public MyClass probe() {
+            if (obj == null) {
+                throw new RuntimeException();
+            }
+            return this;
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/InOrderVerificationTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/InOrderVerificationTest.java
new file mode 100644
index 0000000000..12ff170307
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/InOrderVerificationTest.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+
+import org.assertj.core.api.Assert;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.MockedStatic;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.verification.VerificationInOrderFailure;
+import org.mockito.verification.VerificationMode;
+
+public class InOrderVerificationTest {
+    @Test
+    public void shouldVerifyStaticMethods() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            InOrder inOrder = inOrder(StaticContext.class);
+
+            // when
+            StaticContext.firstMethod();
+            StaticContext.secondMethod(0);
+
+            // then
+            inOrder.verify(mockedStatic, StaticContext::firstMethod);
+            inOrder.verify(mockedStatic, () -> StaticContext.secondMethod(0));
+        }
+    }
+
+    @Test
+    public void shouldVerifyStaticAndInstanceMethods() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            StaticContext mocked = mock(StaticContext.class);
+            InOrder inOrder = inOrder(mocked, StaticContext.class);
+
+            // when
+            StaticContext.firstMethod();
+            mocked.instanceMethod();
+            StaticContext.secondMethod(10);
+
+            // then
+            inOrder.verify(mockedStatic, StaticContext::firstMethod);
+            inOrder.verify(mocked).instanceMethod();
+            inOrder.verify(mockedStatic, () -> StaticContext.secondMethod(10));
+        }
+    }
+
+    @Test
+    public void shouldVerifyStaticMethodsWithSimpleAndWrapperModes() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            InOrder inOrder = inOrder(StaticContext.class);
+
+            // when
+            StaticContext.firstMethod();
+            StaticContext.firstMethod();
+            StaticContext.secondMethod(0);
+
+            // then
+            inOrder.verify(mockedStatic, StaticContext::firstMethod, times(2));
+            inOrder.verify(
+                    mockedStatic, () -> StaticContext.secondMethod(0), timeout(100).atLeastOnce());
+        }
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenModeIsUnsupported() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            VerificationMode unsupportedMode = data -> {};
+            InOrder inOrder = inOrder(StaticContext.class);
+
+            // when
+            StaticContext.firstMethod();
+
+            // then
+            assertThatThrownBy(
+                            () ->
+                                    inOrder.verify(
+                                            mockedStatic,
+                                            StaticContext::firstMethod,
+                                            unsupportedMode))
+                    .isInstanceOf(MockitoException.class);
+        }
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenOrderIsWrong() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            InOrder inOrder = inOrder(StaticContext.class);
+
+            // when
+            StaticContext.firstMethod();
+            StaticContext.secondMethod(0);
+
+            // then
+            assertThatThrownBy(
+                            () -> {
+                                inOrder.verify(mockedStatic, () -> StaticContext.secondMethod(0));
+                                inOrder.verify(mockedStatic, StaticContext::firstMethod);
+                            })
+                    .isInstanceOf(VerificationInOrderFailure.class);
+        }
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenNoMoreInteractionsInvokedButThereAre() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            InOrder inOrder = inOrder(StaticContext.class);
+
+            // when
+            StaticContext.firstMethod();
+            StaticContext.secondMethod(0);
+
+            // then
+            inOrder.verify(mockedStatic, StaticContext::firstMethod);
+            assertThatThrownBy(inOrder::verifyNoMoreInteractions)
+                    .isInstanceOf(VerificationInOrderFailure.class);
+        }
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenNoMoreInteractionsInvokedWithoutVerifyingStaticMethods() {
+        try (MockedStatic<StaticContext> ignored = mockStatic(StaticContext.class)) {
+            // given
+            StaticContext mocked = mock(StaticContext.class);
+            InOrder inOrder = inOrder(StaticContext.class, mocked);
+
+            // when
+            mocked.instanceMethod();
+            StaticContext.firstMethod();
+
+            // then
+            inOrder.verify(mocked).instanceMethod();
+            assertThatThrownBy(inOrder::verifyNoMoreInteractions)
+                    .isInstanceOf(VerificationInOrderFailure.class);
+        }
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenClassIsNotMocked() {
+        assertThatThrownBy(() -> inOrder(StaticContext.class))
+                .isInstanceOf(NotAMockException.class);
+    }
+
+    @Test
+    public void shouldVerifyStaticMethodsWithoutInterferingWithMocking() {
+        try (MockedStatic<StaticContext> mockedStatic = mockStatic(StaticContext.class)) {
+            // given
+            InOrder inOrder = inOrder(StaticContext.class);
+            Exception expected = new RuntimeException();
+            mockedStatic.when(StaticContext::firstMethod).thenThrow(expected);
+
+            // when
+            Assert<?, ?> actual = assertThatThrownBy(StaticContext::firstMethod);
+
+            // then
+            actual.isSameAs(expected);
+            inOrder.verify(mockedStatic, StaticContext::firstMethod);
+            inOrder.verifyNoMoreInteractions();
+        }
+    }
+
+    @Test
+    public void shouldThrowExceptionWhenVerifyUsingInOrderWithoutValidClass() {
+        try (MockedStatic<StaticContext> mockedStaticContext = mockStatic(StaticContext.class)) {
+            try (MockedStatic<AnotherStaticContext> mockedAnotherStaticContext =
+                    mockStatic(AnotherStaticContext.class)) {
+                // given
+                InOrder inOrder = inOrder(AnotherStaticContext.class);
+
+                // when
+                mockedAnotherStaticContext
+                        .when(AnotherStaticContext::otherMethod)
+                        .thenReturn("mocked value");
+                StaticContext.firstMethod();
+
+                // then
+                assertThat(AnotherStaticContext.otherMethod()).isEqualTo("mocked value");
+                inOrder.verify(mockedAnotherStaticContext, AnotherStaticContext::otherMethod);
+                assertThatThrownBy(
+                                () ->
+                                        inOrder.verify(
+                                                mockedStaticContext, StaticContext::firstMethod))
+                        .isInstanceOf(VerificationInOrderFailure.class);
+            }
+        }
+    }
+
+    private static class AnotherStaticContext {
+        static String otherMethod() {
+            throw new AssertionError("otherMethod should be mocked");
+        }
+    }
+
+    private static class StaticContext {
+        static void firstMethod() {
+            fail("firstMethod should be mocked");
+        }
+
+        static void secondMethod(int n) {
+            fail("secondMethod should be mocked but was invoked with argument " + n);
+        }
+
+        void instanceMethod() {
+            fail("instanceMethod should be mocked");
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/InitializationTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/InitializationTest.java
new file mode 100644
index 0000000000..c4f62f400f
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/InitializationTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class InitializationTest {
+
+    @Test
+    public void assure_initialization_prior_to_instrumentation() {
+        @SuppressWarnings("unused")
+        SampleEnum mock = Mockito.mock(SampleEnum.class);
+        SampleEnum[] values = SampleEnum.values();
+        assertEquals("VALUE", values[0].name());
+    }
+
+    public enum SampleEnum {
+        VALUE
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/OneLinerStubStressTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/OneLinerStubStressTest.java
similarity index 81%
rename from subprojects/inline/src/test/java/org/mockitoinline/OneLinerStubStressTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/OneLinerStubStressTest.java
index 44ff95959e..7e7aa79c2c 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/OneLinerStubStressTest.java
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/OneLinerStubStressTest.java
@@ -29,12 +29,14 @@ private static String generateLargeString() {
 
     @Test
     public void call_a_lot_of_mocks_using_one_line_stubbing() {
-        //This requires smaller heap set for the test process, see "inline.gradle"
+        // This requires smaller heap set for the test process, see "inline.gradle"
         final String returnValue = generateLargeString();
         for (int i = 0; i < 50000; i++) {
             // make sure that mock object does not get cleaned up prematurely
             final OneLinerStubTestClass mock =
-                when(mock(OneLinerStubTestClass.class).getStuff()).thenReturn(returnValue).getMock();
+                    when(mock(OneLinerStubTestClass.class).getStuff())
+                            .thenReturn(returnValue)
+                            .getMock();
             assertEquals(returnValue, mock.getStuff());
         }
     }
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/PluginTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/PluginTest.java
new file mode 100644
index 0000000000..163567e4eb
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/PluginTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.internal.util.reflection.ModuleMemberAccessor;
+
+import static org.junit.Assert.*;
+
+public class PluginTest {
+
+    @Test
+    public void mock_maker_should_be_inline() throws Exception {
+        assertTrue(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker);
+    }
+
+    @Test
+    public void member_accessor_should_be_module() throws Exception {
+        assertTrue(Plugins.getMemberAccessor() instanceof ModuleMemberAccessor);
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/RecursionTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/RecursionTest.java
similarity index 100%
rename from subprojects/inline/src/test/java/org/mockitoinline/RecursionTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/RecursionTest.java
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SpyWithConstructorTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SpyWithConstructorTest.java
new file mode 100644
index 0000000000..99749b29a0
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SpyWithConstructorTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+import static org.mockito.Mockito.*;
+
+public class SpyWithConstructorTest {
+
+    private SomethingAbstract somethingAbstract;
+
+    @Before
+    public void setUp() {
+        somethingAbstract =
+                mock(
+                        SomethingAbstract.class,
+                        withSettings().useConstructor("foo").defaultAnswer(CALLS_REAL_METHODS));
+    }
+
+    @Test
+    public void shouldUseConstructor() {
+        assertEquals("foo", somethingAbstract.getValue());
+    }
+
+    abstract static class SomethingAbstract {
+
+        private final String value;
+
+        SomethingAbstract(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticMockRuleTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticMockRuleTest.java
new file mode 100644
index 0000000000..0753f789f6
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticMockRuleTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import static junit.framework.TestCase.*;
+
+public final class StaticMockRuleTest {
+
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock private MockedStatic<Dummy> dummy;
+
+    @Test
+    public void testStaticMockSimple() {
+        assertNull(Dummy.foo());
+    }
+
+    @Test
+    public void testStaticMockWithVerification() {
+        dummy.when(Dummy::foo).thenReturn("bar");
+        assertEquals("bar", Dummy.foo());
+        dummy.verify(Dummy::foo);
+    }
+
+    static class Dummy {
+
+        static String foo() {
+            return "foo";
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticMockTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticMockTest.java
new file mode 100644
index 0000000000..e63e5bba87
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticMockTest.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertNull;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+
+public final class StaticMockTest {
+
+    @Test
+    public void testStaticMockSimple() {
+        assertEquals("foo", Dummy.foo());
+        try (MockedStatic<Dummy> ignored = Mockito.mockStatic(Dummy.class)) {
+            assertNull(Dummy.foo());
+        }
+        assertEquals("foo", Dummy.foo());
+    }
+
+    @Test
+    public void testStaticMockWithVerification() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo);
+        }
+    }
+
+    @Test
+    public void testStaticMockWithVerificationFailed() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            assertThatThrownBy(
+                            () -> {
+                                dummy.verify(Dummy::foo);
+                            })
+                    .isInstanceOf(WantedButNotInvoked.class)
+                    .hasMessageContaining("there were zero interactions with this mock");
+        }
+    }
+
+    @Test
+    public void testStaticMockWithNoInteractions() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            dummy.verifyNoInteractions();
+        }
+    }
+
+    @Test
+    public void testStaticMockWithNoInteractionsFailed() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            assertThatThrownBy(
+                            () -> {
+                                dummy.verifyNoInteractions();
+                            })
+                    .isInstanceOf(NoInteractionsWanted.class)
+                    .hasMessageContaining("No interactions wanted here")
+                    .hasMessageContaining("above is the only interaction with this mock.");
+        }
+    }
+
+    @Test
+    public void testStaticMockWithNoMoreInteractions() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo);
+            dummy.verifyNoMoreInteractions();
+        }
+    }
+
+    @Test
+    public void testStaticMockWithNoMoreInteractionsFailed() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            assertThatThrownBy(
+                            () -> {
+                                dummy.verifyNoInteractions();
+                            })
+                    .isInstanceOf(NoInteractionsWanted.class)
+                    .hasMessageContaining("No interactions wanted here")
+                    .hasMessageContaining("above is the only interaction with this mock.");
+        }
+    }
+
+    @Test
+    public void testStaticMockWithDefaultAnswer() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class, invocation -> "bar")) {
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo);
+        }
+    }
+
+    @Test
+    public void testStaticMockWithRealMethodCall() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenCallRealMethod();
+            assertEquals("foo", Dummy.foo());
+            dummy.verify(Dummy::foo);
+        }
+    }
+
+    @Test
+    public void testStaticMockReset() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            dummy.reset();
+            assertNull(Dummy.foo());
+        }
+    }
+
+    @Test
+    public void testStaticMockClear() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.clearInvocations();
+            dummy.verifyNoInteractions();
+        }
+    }
+
+    @Test
+    public void testStaticMockDoesNotAffectDifferentThread() throws InterruptedException {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo);
+            AtomicReference<String> reference = new AtomicReference<>();
+            Thread thread = new Thread(() -> reference.set(Dummy.foo()));
+            thread.start();
+            thread.join();
+            assertEquals("foo", reference.get());
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo, times(2));
+        }
+    }
+
+    @Test
+    public void testStaticMockCanCoexistWithMockInDifferentThread() throws InterruptedException {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo);
+            AtomicReference<String> reference = new AtomicReference<>();
+            Thread thread =
+                    new Thread(
+                            () -> {
+                                try (MockedStatic<Dummy> dummy2 = Mockito.mockStatic(Dummy.class)) {
+                                    dummy2.when(Dummy::foo).thenReturn("qux");
+                                    reference.set(Dummy.foo());
+                                }
+                            });
+            thread.start();
+            thread.join();
+            assertEquals("qux", reference.get());
+            dummy.when(Dummy::foo).thenReturn("bar");
+            assertEquals("bar", Dummy.foo());
+            dummy.verify(Dummy::foo, times(2));
+        }
+    }
+
+    @Test
+    public void testStaticMockMustBeExclusiveInScopeWithinThread() {
+        assertThatThrownBy(
+                        () -> {
+                            try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class);
+                                    MockedStatic<Dummy> duplicate =
+                                            Mockito.mockStatic(Dummy.class)) {}
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("static mocking is already registered in the current thread");
+    }
+
+    @Test
+    public void testStaticMockVoid() {
+        try (MockedStatic<Dummy> dummy = Mockito.mockStatic(Dummy.class)) {
+            Dummy.fooVoid("bar");
+            assertNull(Dummy.var1);
+            dummy.verify(() -> Dummy.fooVoid("bar"));
+        }
+        Dummy.fooVoid("bar");
+        assertEquals("bar", Dummy.var1);
+    }
+
+    @Test
+    public void testStaticMockMustUseValidMatchers() {
+        try (MockedStatic<Dummy> mockedClass = Mockito.mockStatic(Dummy.class)) {
+            assertThatThrownBy(
+                            () -> {
+                                mockedClass
+                                        .when(() -> Dummy.fooVoid("foo", any()))
+                                        .thenReturn(null);
+                            })
+                    .hasMessageContaining("Invalid use of argument matchers!");
+
+            Dummy.fooVoid("foo", "bar");
+        }
+    }
+
+    @Test
+    public void testStaticMockVarargs() {
+        assertEquals("foobar", Dummy.fooVarargs("foo", "bar"));
+        try (MockedStatic<Dummy> ignored = Mockito.mockStatic(Dummy.class)) {
+            assertNull(Dummy.fooVarargs("foo", "bar"));
+        }
+        assertEquals("foobar", Dummy.fooVarargs("foo", "bar"));
+    }
+
+    static class Dummy {
+
+        static String var1 = null;
+
+        static String foo() {
+            return "foo";
+        }
+
+        static void fooVoid(String var2) {
+            var1 = var2;
+        }
+
+        static void fooVoid(String var2, String var3) {
+            var1 = var2;
+        }
+
+        static String fooVarargs(String... args) {
+            StringBuilder sb = new StringBuilder();
+            for (String arg : args) {
+                sb.append(arg);
+            }
+            return sb.toString();
+        }
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticRuleTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticRuleTest.java
new file mode 100644
index 0000000000..02c3ae73f1
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticRuleTest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import java.util.UUID;
+
+import static junit.framework.TestCase.assertEquals;
+
+public final class StaticRuleTest {
+
+    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock private MockedStatic<UUID> mock;
+
+    @Test
+    public void runs() {
+        mock.when(UUID::randomUUID).thenReturn(new UUID(123, 456));
+        assertEquals(UUID.randomUUID(), new UUID(123, 456));
+    }
+}
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticRunnerTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticRunnerTest.java
new file mode 100644
index 0000000000..57ecf352a1
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StaticRunnerTest.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.UUID;
+
+import static junit.framework.TestCase.assertEquals;
+
+@RunWith(MockitoJUnitRunner.class)
+public final class StaticRunnerTest {
+
+    @Mock private MockedStatic<UUID> mock;
+
+    @Test
+    public void runs() {
+        mock.when(UUID::randomUUID).thenReturn(new UUID(123, 456));
+        assertEquals(UUID.randomUUID(), new UUID(123, 456));
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/StressTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StressTest.java
similarity index 92%
rename from subprojects/inline/src/test/java/org/mockitoinline/StressTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StressTest.java
index c6a55064d4..f9bfbf31dd 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/StressTest.java
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StressTest.java
@@ -20,7 +20,7 @@ public String getStuff() {
 
     @Test
     public void call_a_lot_of_mocks() {
-        //This requires smaller heap set for the test process, see "inline.gradle"
+        // This requires smaller heap set for the test process, see "inline.gradle"
         for (int i = 0; i < 40000; i++) {
             TestClass mock = mock(TestClass.class);
             when(mock.getStuff()).thenReturn("B");
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/StubbingLocationTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StubbingLocationTest.java
similarity index 90%
rename from subprojects/inline/src/test/java/org/mockitoinline/StubbingLocationTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StubbingLocationTest.java
index 8476006425..c0665a0958 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/StubbingLocationTest.java
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/StubbingLocationTest.java
@@ -20,8 +20,10 @@ public class StubbingLocationTest {
     public void stubbing_location_should_be_the_correct_point() {
         ConcreteClass mock = mock(ConcreteClass.class);
         String frame;
-        // Initializing 'frame' at the method parameter point is to gain the exact line number of the stubbing point.
-        when(mock.concreteMethod(frame = Thread.currentThread().getStackTrace()[1].toString())).thenReturn("");
+        // Initializing 'frame' at the method parameter point is to gain the exact line number of
+        // the stubbing point.
+        when(mock.concreteMethod(frame = Thread.currentThread().getStackTrace()[1].toString()))
+                .thenReturn("");
         mock.concreteMethod(frame);
         Set<Stubbing> stubbings = AllInvocationsFinder.findStubbings(Collections.singleton(mock));
         assertEquals(1, stubbings.size());
@@ -34,5 +36,4 @@ String concreteMethod(String s) {
             throw new RuntimeException(s);
         }
     }
-
 }
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SubconstructorMockTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SubconstructorMockTest.java
new file mode 100644
index 0000000000..59a12e95ad
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SubconstructorMockTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline;
+
+import org.junit.Test;
+import org.mockito.MockedConstruction;
+import org.mockito.Mockito;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class SubconstructorMockTest {
+
+    @Test
+    public void does_not_mock_subclass_constructor_for_superclass_mock() {
+        try (MockedConstruction<SubClass> mocked = Mockito.mockConstruction(SubClass.class)) {}
+        try (MockedConstruction<SuperClass> mocked = Mockito.mockConstruction(SuperClass.class)) {
+            SubClass value = new SubClass();
+            assertTrue(value.sup());
+            assertTrue(value.sub());
+        }
+    }
+
+    @Test
+    public void does_mock_superclass_constructor_for_subclass_mock() {
+        try (MockedConstruction<SuperClass> mocked = Mockito.mockConstruction(SuperClass.class)) {}
+        try (MockedConstruction<SubClass> mocked = Mockito.mockConstruction(SubClass.class)) {
+            SubClass value = new SubClass();
+            assertFalse(value.sup());
+            assertFalse(value.sub());
+        }
+    }
+
+    public static class SuperClass {
+        public boolean sup() {
+            return true;
+        }
+    }
+
+    public static class SubClass extends SuperClass {
+        public boolean sub() {
+            return true;
+        }
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/SuperCallTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SuperCallTest.java
similarity index 100%
rename from subprojects/inline/src/test/java/org/mockitoinline/SuperCallTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/SuperCallTest.java
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/bugs/CyclicMockMethodArgumentMemoryLeakTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/CyclicMockMethodArgumentMemoryLeakTest.java
similarity index 93%
rename from subprojects/inline/src/test/java/org/mockitoinline/bugs/CyclicMockMethodArgumentMemoryLeakTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/CyclicMockMethodArgumentMemoryLeakTest.java
index 20efc9daaa..7aecccd863 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/bugs/CyclicMockMethodArgumentMemoryLeakTest.java
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/CyclicMockMethodArgumentMemoryLeakTest.java
@@ -10,7 +10,7 @@
 import static org.mockito.Mockito.mock;
 
 public class CyclicMockMethodArgumentMemoryLeakTest {
-    private static final int ARRAY_LENGTH = 1 << 20;  // 4 MB
+    private static final int ARRAY_LENGTH = 1 << 20; // 4 MB
 
     @Test
     public void no_memory_leak_when_cyclically_calling_method_with_mocks() {
diff --git a/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/OngoingStubShiftTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/OngoingStubShiftTest.java
new file mode 100644
index 0000000000..59e430632b
--- /dev/null
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/OngoingStubShiftTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitoinline.bugs;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+import org.mockito.MockedStatic;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.mockStatic;
+
+public class OngoingStubShiftTest {
+
+    private static class StaticInt {
+        static int getInt() {
+            return 1;
+        }
+    }
+
+    private static class StaticStr {
+        static String getStr() {
+            return Integer.toString(StaticInt.getInt());
+        }
+    }
+
+    @Test
+    public void keep_ongoing_stub_when_spy() {
+        try (MockedStatic<StaticInt> mockInt = mockStatic(StaticInt.class);
+                MockedStatic<StaticStr> mockStr = mockStatic(StaticStr.class, CALLS_REAL_METHODS)) {
+
+            mockStr.when(StaticStr::getStr).thenReturn("1");
+            assertEquals("1", StaticStr.getStr());
+        }
+    }
+
+    private static class StaticWithException {
+        static String getString() {
+            return Integer.toString(getInt());
+        }
+
+        static int getInt() {
+            throw new NullPointerException();
+        }
+    }
+
+    @Test
+    public void keep_ongoing_stub_when_exception() {
+        try (MockedStatic<StaticWithException> mock =
+                mockStatic(StaticWithException.class, CALLS_REAL_METHODS)) {
+            mock.when(StaticWithException::getString).thenReturn("1");
+            assertEquals("1", StaticWithException.getString());
+        }
+    }
+}
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/bugs/SelfSpyReferenceMemoryLeakTest.java b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/SelfSpyReferenceMemoryLeakTest.java
similarity index 93%
rename from subprojects/inline/src/test/java/org/mockitoinline/bugs/SelfSpyReferenceMemoryLeakTest.java
rename to mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/SelfSpyReferenceMemoryLeakTest.java
index 678e43c82f..83e1f41d06 100644
--- a/subprojects/inline/src/test/java/org/mockitoinline/bugs/SelfSpyReferenceMemoryLeakTest.java
+++ b/mockito-integration-tests/inline-mocks-tests/src/test/java/org/mockitoinline/bugs/SelfSpyReferenceMemoryLeakTest.java
@@ -10,7 +10,7 @@
 import static org.mockito.Mockito.spy;
 
 public class SelfSpyReferenceMemoryLeakTest {
-    private static final int ARRAY_LENGTH = 1 << 20;  // 4 MB
+    private static final int ARRAY_LENGTH = 1 << 20; // 4 MB
 
     @Test
     public void no_memory_leak_when_spy_holds_reference_to_self() {
diff --git a/mockito-integration-tests/java-21-tests/build.gradle.kts b/mockito-integration-tests/java-21-tests/build.gradle.kts
new file mode 100644
index 0000000000..1de5026585
--- /dev/null
+++ b/mockito-integration-tests/java-21-tests/build.gradle.kts
@@ -0,0 +1,110 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Test suite for Java 21 Mockito"
+
+val bytebuddyAgent: Configuration by configurations.creating
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+    bytebuddyAgent(libs.bytebuddy.agent) { isTransitive = false }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
+}
+
+tasks {
+    val testWithBytebuddyAgent by registering(Test::class) {
+        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)) {
+            enabled = false
+        } else {
+            jvmArgs(
+                "-javaagent:${bytebuddyAgent.asPath}",
+                // "-Djdk.instrument.traceUsage",
+            )
+        }
+        failIfStdErrWarningOnDynamicallyLoadedAgent(this)
+    }
+
+    val testWithMockitoAgent by registering(Test::class) {
+        dependsOn(":mockito-core:jar")
+        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)) {
+            enabled = false
+        } else {
+            jvmArgumentProviders.add(
+                CommandLineArgumentProvider {
+                    listOf(
+                        "-javaagent:${project(":mockito-core").tasks.jar.get().archiveFile.get()}"
+                        // "-Djdk.instrument.traceUsage",
+                    )
+                }
+            )
+        }
+        failIfStdErrWarningOnDynamicallyLoadedAgent(this)
+    }
+
+    val testWithEnableDynamicAgentLoading by registering(Test::class) {
+        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)) {
+            enabled = false
+        } else {
+            jvmArgs(
+                "-XX:+EnableDynamicAgentLoading",
+                // "-Djdk.instrument.traceUsage",
+            )
+        }
+        failIfStdErrWarningOnDynamicallyLoadedAgent(this)
+    }
+
+    named<Test>("test") {
+        dependsOn(
+            testWithMockitoAgent,
+            testWithBytebuddyAgent,
+            testWithEnableDynamicAgentLoading,
+        )
+        isEnabled = JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)
+
+        expectStdErrWhenDynamicallyLoadedAgent(this)
+    }
+}
+
+private fun failIfStdErrWarningOnDynamicallyLoadedAgent(testTask: Test) {
+    val stderrMessages = mutableListOf<String>()
+    testTask.addTestOutputListener { _, event ->
+        if (event.destination == TestOutputEvent.Destination.StdErr) {
+            stderrMessages.add(event.message)
+        }
+    }
+    testTask.doLast {
+        val stderrText = stderrMessages.joinToString(separator = "\n")
+        if (stderrText.contains("A Java agent has been loaded dynamically")
+            && stderrText.contains("net.bytebuddy/byte-buddy-agent")
+            && stderrText.contains("If a serviceability tool is in use, please run with -XX:+EnableDynamicAgentLoading to hide this warning")
+        ) {
+            throw GradleException("JDK should no emit warning when mockito is set as agent and -XX:+EnableDynamicAgentLoading is not set")
+        }
+    }
+}
+
+private fun expectStdErrWhenDynamicallyLoadedAgent(testTask: Test) {
+    val stderrMessages = mutableListOf<String>()
+    testTask.addTestOutputListener { _, event ->
+        if (event.destination == TestOutputEvent.Destination.StdErr) {
+            stderrMessages.add(event.message)
+        }
+    }
+    testTask.doLast {
+        val stdoutText = stderrMessages.joinToString("\n")
+        if (!stdoutText.contains("Mockito is currently self-attaching to enable the inline-mock-maker.")) {
+            throw GradleException("Mockito should emit a message when self-attaching")
+        }
+    }
+}
diff --git a/mockito-integration-tests/java-21-tests/src/test/java/org/mockito/internal/stubbing/answers/DeepStubReturnsEnumJava21Test.java b/mockito-integration-tests/java-21-tests/src/test/java/org/mockito/internal/stubbing/answers/DeepStubReturnsEnumJava21Test.java
new file mode 100644
index 0000000000..30dd40a798
--- /dev/null
+++ b/mockito-integration-tests/java-21-tests/src/test/java/org/mockito/internal/stubbing/answers/DeepStubReturnsEnumJava21Test.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+
+public class DeepStubReturnsEnumJava21Test {
+
+    @Test
+    public void cant_mock_enum_class_in_Java21_Issue_2984() {
+        assertThatThrownBy(
+                        () -> {
+                            mock(TestEnum.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Sealed abstract enums can't be mocked.")
+                .hasCauseInstanceOf(MockitoException.class);
+    }
+
+    @Test
+    public void cant_mock_enum_class_as_deep_stub_in_Java21_Issue_2984() {
+        assertThatThrownBy(
+                        () -> {
+                            mock(TestEnum.class, RETURNS_DEEP_STUBS);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Sealed abstract enums can't be mocked.")
+                .hasCauseInstanceOf(MockitoException.class);
+    }
+
+    @Test
+    public void deep_stub_cant_mock_enum_with_abstract_method_in_Java21_Issue_2984() {
+        final var mock = mock(TestClass.class, RETURNS_DEEP_STUBS);
+        assertThatThrownBy(
+                        () -> {
+                            mock.getTestEnum();
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContaining("Sealed abstract enums can't be mocked.")
+                .hasCauseInstanceOf(MockitoException.class);
+    }
+
+    @Test
+    public void deep_stub_can_override_mock_enum_with_abstract_method_in_Java21_Issue_2984() {
+        final var mock = mock(TestClass.class, RETURNS_DEEP_STUBS);
+        // We need the doReturn() because when calling when(mock.getTestEnum()) it will already
+        // throw an exception.
+        doReturn(TestEnum.A).when(mock).getTestEnum();
+
+        assertThat(mock.getTestEnum()).isEqualTo(TestEnum.A);
+        assertThat(mock.getTestEnum().getValue()).isEqualTo("A");
+
+        assertThat(mockingDetails(mock.getTestEnum()).isMock()).isFalse();
+    }
+
+    @Test
+    public void deep_stub_can_mock_enum_without_method_in_Java21_Issue_2984() {
+        final var mock = mock(TestClass.class, RETURNS_DEEP_STUBS);
+        assertThat(mock.getTestNonAbstractEnum()).isNotNull();
+
+        assertThat(mockingDetails(mock.getTestNonAbstractEnum()).isMock()).isTrue();
+        when(mock.getTestNonAbstractEnum()).thenReturn(TestNonAbstractEnum.B);
+        assertThat(mock.getTestNonAbstractEnum()).isEqualTo(TestNonAbstractEnum.B);
+    }
+
+    @Test
+    public void deep_stub_can_mock_enum_without_abstract_method_in_Java21_Issue_2984() {
+        final var mock = mock(TestClass.class, RETURNS_DEEP_STUBS);
+        assertThat(mock.getTestNonAbstractEnumWithMethod()).isNotNull();
+        assertThat(mock.getTestNonAbstractEnumWithMethod().getValue()).isNull();
+        assertThat(mockingDetails(mock.getTestNonAbstractEnumWithMethod()).isMock()).isTrue();
+
+        when(mock.getTestNonAbstractEnumWithMethod().getValue()).thenReturn("Mock");
+        assertThat(mock.getTestNonAbstractEnumWithMethod().getValue()).isEqualTo("Mock");
+
+        when(mock.getTestNonAbstractEnumWithMethod()).thenReturn(TestNonAbstractEnumWithMethod.B);
+        assertThat(mock.getTestNonAbstractEnumWithMethod())
+                .isEqualTo(TestNonAbstractEnumWithMethod.B);
+    }
+
+    @Test
+    public void mock_mocking_enum_getter_Issue_2984() {
+        final var mock = mock(TestClass.class);
+        when(mock.getTestEnum()).thenReturn(TestEnum.B);
+        assertThat(mock.getTestEnum()).isEqualTo(TestEnum.B);
+        assertThat(mock.getTestEnum().getValue()).isEqualTo("B");
+    }
+
+    static class TestClass {
+        TestEnum getTestEnum() {
+            return TestEnum.A;
+        }
+
+        TestNonAbstractEnumWithMethod getTestNonAbstractEnumWithMethod() {
+            return TestNonAbstractEnumWithMethod.A;
+        }
+
+        TestNonAbstractEnum getTestNonAbstractEnum() {
+            return TestNonAbstractEnum.A;
+        }
+    }
+
+    enum TestEnum {
+        A {
+            @Override
+            String getValue() {
+                return this.name();
+            }
+        },
+        B {
+            @Override
+            String getValue() {
+                return this.name();
+            }
+        },
+        ;
+
+        abstract String getValue();
+    }
+
+    enum TestNonAbstractEnum {
+        A,
+        B
+    }
+
+    enum TestNonAbstractEnumWithMethod {
+        A,
+        B;
+
+        String getValue() {
+            return "RealValue";
+        }
+    }
+}
diff --git a/mockito-integration-tests/java-21-tests/src/test/java/org/mockito/java21/RecordTest.java b/mockito-integration-tests/java-21-tests/src/test/java/org/mockito/java21/RecordTest.java
new file mode 100644
index 0000000000..4c6a2a225b
--- /dev/null
+++ b/mockito-integration-tests/java-21-tests/src/test/java/org/mockito/java21/RecordTest.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.java21;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.spy;
+
+import java.util.List;
+
+import org.junit.Test;
+
+public class RecordTest {
+
+    @Test
+    public void
+            given_list_is_already_spied__when_spying_record__then_record_fields_are_correctly_populated() {
+        var ignored = spy(List.of());
+
+        record MyRecord(String name) {}
+        MyRecord spiedRecord = spy(new MyRecord("something"));
+
+        assertThat(spiedRecord.name()).isEqualTo("something");
+    }
+}
diff --git a/mockito-integration-tests/junit-jupiter-extension-tests/build.gradle.kts b/mockito-integration-tests/junit-jupiter-extension-tests/build.gradle.kts
new file mode 100644
index 0000000000..1a2dede0ac
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-extension-tests/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "End-to-end tests for automatic registration of MockitoExtension."
+
+dependencies {
+    testImplementation(project(":mockito-extensions:mockito-junit-jupiter"))
+    testImplementation(libs.assertj)
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.junit.platform.launcher)
+}
+
+tasks {
+    test {
+        useJUnitPlatform()
+    }
+}
diff --git a/mockito-integration-tests/junit-jupiter-extension-tests/src/test/java/org/mockitousage/NoExtendsTest.java b/mockito-integration-tests/junit-jupiter-extension-tests/src/test/java/org/mockitousage/NoExtendsTest.java
new file mode 100644
index 0000000000..d1ef90a379
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-extension-tests/src/test/java/org/mockitousage/NoExtendsTest.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+class NoExtendsTest {
+
+    @Mock private List<String> mock;
+
+    @Test
+    void runs() {
+        when(mock.get(0)).thenReturn("foo");
+        assertThat(mock.get(0)).isEqualTo("foo");
+    }
+}
diff --git a/subprojects/junitJupiterExtensionTest/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension b/mockito-integration-tests/junit-jupiter-extension-tests/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
similarity index 100%
rename from subprojects/junitJupiterExtensionTest/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
rename to mockito-integration-tests/junit-jupiter-extension-tests/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
diff --git a/subprojects/junitJupiterExtensionTest/src/test/resources/junit-platform.properties b/mockito-integration-tests/junit-jupiter-extension-tests/src/test/resources/junit-platform.properties
similarity index 100%
rename from subprojects/junitJupiterExtensionTest/src/test/resources/junit-platform.properties
rename to mockito-integration-tests/junit-jupiter-extension-tests/src/test/resources/junit-platform.properties
diff --git a/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/build.gradle.kts b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/build.gradle.kts
new file mode 100644
index 0000000000..3b2efb435a
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "End-to-end tests for automatic registration of MockitoExtension with the inline mock maker."
+
+dependencies {
+    testImplementation(project(":mockito-extensions:mockito-junit-jupiter"))
+    testImplementation(libs.assertj)
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.junit.platform.launcher)
+}
+
+tasks{
+    test {
+        useJUnitPlatform()
+    }
+}
diff --git a/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/java/org/mockitousage/CloseOnDemandTest.java b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/java/org/mockitousage/CloseOnDemandTest.java
new file mode 100644
index 0000000000..cfb66cf96a
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/java/org/mockitousage/CloseOnDemandTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+/**
+ * Tests to assert that ScopedMock mocks are properly closed on scope exit.
+ */
+@ExtendWith(MockitoExtension.class)
+class CloseOnDemandTest {
+
+    @Test
+    void create_mocked_static_1(@Mock MockedStatic<String> mockedStatic) {
+        assertNotNull(mockedStatic);
+    }
+
+    @Test
+    void create_mocked_static_2(@Mock MockedStatic<String> mockedStatic) {
+        assertNotNull(mockedStatic);
+    }
+
+    @Test
+    void create_mocked_construction_1(@Mock MockedConstruction<String> mockConstruction) {
+        assertNotNull(mockConstruction);
+    }
+
+    @Test
+    void create_mocked_construction_2(@Mock MockedConstruction<String> mockConstruction) {
+        assertNotNull(mockConstruction);
+    }
+}
diff --git a/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/java/org/mockitousage/NoExtendsTest.java b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/java/org/mockitousage/NoExtendsTest.java
new file mode 100644
index 0000000000..6db390d2cd
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/java/org/mockitousage/NoExtendsTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+
+import static org.assertj.core.api.Assertions.*;
+
+class NoExtendsTest {
+
+    @Mock private MockedStatic<Dummy> staticMethod;
+
+    @Mock private MockedConstruction<Dummy> construction;
+
+    @Test
+    void runsStaticMethods() {
+        assertThat(Dummy.foo()).isNull();
+    }
+
+    @Test
+    void runsConstruction() {
+        assertThat(new Dummy().bar()).isNull();
+    }
+
+    static class Dummy {
+
+        static String foo() {
+            return "foo";
+        }
+
+        String bar() {
+            return "foo";
+        }
+    }
+}
diff --git a/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
new file mode 100644
index 0000000000..02593efe36
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
@@ -0,0 +1 @@
+org.mockito.junit.jupiter.MockitoExtension
diff --git a/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/junit-platform.properties b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/junit-platform.properties
new file mode 100644
index 0000000000..25ce5c9844
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/junit-platform.properties
@@ -0,0 +1 @@
+junit.jupiter.extensions.autodetection.enabled = true
diff --git a/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
new file mode 100644
index 0000000000..1f0955d450
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-inline-mock-maker-extension-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
@@ -0,0 +1 @@
+mock-maker-inline
diff --git a/mockito-integration-tests/junit-jupiter-parallel-tests/build.gradle.kts b/mockito-integration-tests/junit-jupiter-parallel-tests/build.gradle.kts
new file mode 100644
index 0000000000..ac0c3a75a1
--- /dev/null
+++ b/mockito-integration-tests/junit-jupiter-parallel-tests/build.gradle.kts
@@ -0,0 +1,19 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Tests that require fine tuned parallel settings for JUnit Jupiter (bug #1630)"
+
+dependencies {
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(project(":mockito-extensions:mockito-junit-jupiter"))
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.junit.platform.launcher)
+}
+
+tasks {
+    test {
+        useJUnitPlatform()
+    }
+}
diff --git a/subprojects/junitJupiterParallelTest/src/test/java/org/mockito/NestedParallelTest.java b/mockito-integration-tests/junit-jupiter-parallel-tests/src/test/java/org/mockito/NestedParallelTest.java
similarity index 90%
rename from subprojects/junitJupiterParallelTest/src/test/java/org/mockito/NestedParallelTest.java
rename to mockito-integration-tests/junit-jupiter-parallel-tests/src/test/java/org/mockito/NestedParallelTest.java
index 29a83467eb..185d99e818 100644
--- a/subprojects/junitJupiterParallelTest/src/test/java/org/mockito/NestedParallelTest.java
+++ b/mockito-integration-tests/junit-jupiter-parallel-tests/src/test/java/org/mockito/NestedParallelTest.java
@@ -12,11 +12,9 @@
 @ExtendWith(MockitoExtension.class)
 class NestedParallelTest {
 
-    @Mock
-    private SomeService someService;
+    @Mock private SomeService someService;
 
-    @InjectMocks
-    private AnotherService anotherService;
+    @InjectMocks private AnotherService anotherService;
 
     @Nested
     class NestedTest {
@@ -79,7 +77,6 @@ void callSomeService() {
 
     static class SomeService {
 
-        void doSomething() {
-        }
+        void doSomething() {}
     }
 }
diff --git a/subprojects/junitJupiterParallelTest/src/test/java/org/mockito/ParallelBugTest.java b/mockito-integration-tests/junit-jupiter-parallel-tests/src/test/java/org/mockito/ParallelBugTest.java
similarity index 89%
rename from subprojects/junitJupiterParallelTest/src/test/java/org/mockito/ParallelBugTest.java
rename to mockito-integration-tests/junit-jupiter-parallel-tests/src/test/java/org/mockito/ParallelBugTest.java
index e3e1f8bb40..028dd1d73b 100644
--- a/subprojects/junitJupiterParallelTest/src/test/java/org/mockito/ParallelBugTest.java
+++ b/mockito-integration-tests/junit-jupiter-parallel-tests/src/test/java/org/mockito/ParallelBugTest.java
@@ -14,11 +14,9 @@
 @ExtendWith(MockitoExtension.class)
 class ParallelBugTest {
 
-    @Mock
-    private SomeService someService;
+    @Mock private SomeService someService;
 
-    @InjectMocks
-    private AnotherService anotherService;
+    @InjectMocks private AnotherService anotherService;
 
     @Test
     void test() {
@@ -77,7 +75,6 @@ void callSomeService() {
 
     static class SomeService {
 
-        void doSomething() {
-        }
+        void doSomething() {}
     }
 }
diff --git a/subprojects/junitJupiterParallelTest/src/test/resources/junit-platform.properties b/mockito-integration-tests/junit-jupiter-parallel-tests/src/test/resources/junit-platform.properties
similarity index 100%
rename from subprojects/junitJupiterParallelTest/src/test/resources/junit-platform.properties
rename to mockito-integration-tests/junit-jupiter-parallel-tests/src/test/resources/junit-platform.properties
diff --git a/mockito-integration-tests/kotlin-release-coroutines-tests/build.gradle.kts b/mockito-integration-tests/kotlin-release-coroutines-tests/build.gradle.kts
new file mode 100644
index 0000000000..e3a5d841eb
--- /dev/null
+++ b/mockito-integration-tests/kotlin-release-coroutines-tests/build.gradle.kts
@@ -0,0 +1,25 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id("org.jetbrains.kotlin.jvm")
+    id("mockito.test-conventions")
+}
+
+description = "Kotlin tests for Mockito."
+
+dependencies {
+    testImplementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+
+    testImplementation(libs.kotlin.stdlib)
+    testImplementation(libs.kotlin.coroutines)
+}
+
+tasks {
+    withType<KotlinCompile> {
+        compilerOptions {
+            jvmTarget = JvmTarget.JVM_11
+        }
+    }
+}
diff --git a/mockito-integration-tests/kotlin-release-coroutines-tests/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt b/mockito-integration-tests/kotlin-release-coroutines-tests/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
new file mode 100644
index 0000000000..d42a0c0006
--- /dev/null
+++ b/mockito-integration-tests/kotlin-release-coroutines-tests/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.kotlin
+
+import kotlinx.coroutines.runBlocking
+import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.core.IsEqual
+import org.junit.Test
+import org.mockito.Mockito.*
+
+/**
+ * Test for mocking and verifying Kotlin suspending functions.
+ */
+class SuspendTest {
+    interface SuspendableInterface {
+        suspend fun suspendFunction(x: Int): Int
+        suspend fun suspendFunctionWithDefault(x: Int = 1): Int
+    }
+
+    open class SuspendableClass : SuspendableInterface {
+        suspend override fun suspendFunction(x: Int): Int = error("not implemented")
+        suspend override fun suspendFunctionWithDefault(x: Int): Int = error("not implemented")
+        suspend open fun suspendClassFunctionWithDefault(x: Int = 1): Int = error("not implemented")
+    }
+
+    class FinalSuspendableClass {
+        suspend fun fetch(): Int {
+            fetchConcrete()
+            return 2
+        }
+
+        suspend fun fetchConcrete() = 1
+    }
+
+    open class CallsSuspendable(private val suspendable: SuspendableInterface) {
+        fun callSuspendable(x: Int) = runBlocking {
+            suspendable.suspendFunction(x)
+        }
+
+        fun suspendFunctionWithDefault() = runBlocking {
+            suspendable.suspendFunctionWithDefault()
+        }
+
+        fun suspendFunctionWithDefault(x: Int) = runBlocking {
+            suspendable.suspendFunctionWithDefault(x)
+        }
+    }
+
+    class CallsSuspendableClass(private val suspendable: SuspendableClass) : CallsSuspendable(suspendable) {
+        fun suspendClassFunctionWithDefault() = runBlocking {
+            suspendable.suspendClassFunctionWithDefault()
+        }
+
+        fun suspendClassFunctionWithDefault(x: Int) = runBlocking {
+            suspendable.suspendClassFunctionWithDefault(x)
+        }
+    }
+
+    @Test
+    fun shouldMockSuspendInterfaceFunction() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
+        val callsSuspendable = CallsSuspendable(mockSuspendable)
+
+        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
+        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
+        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendFunction(1)
+        verify(mockSuspendable).suspendFunction(2)
+    }
+
+    @Test
+    fun shouldMockSuspendInterfaceFunctionWithDefault() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
+        val callsSuspendable = CallsSuspendable(mockSuspendable)
+
+        `when`(mockSuspendable.suspendFunctionWithDefault()).thenReturn(2)
+        `when`(mockSuspendable.suspendFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.suspendFunctionWithDefault(), IsEqual(2))
+        assertThat(callsSuspendable.suspendFunctionWithDefault(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendFunctionWithDefault()
+        verify(mockSuspendable).suspendFunctionWithDefault(2)
+    }
+
+    @Test
+    fun shouldMockSuspendClassFunction() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
+        val callsSuspendable = CallsSuspendable(mockSuspendable)
+
+        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
+        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
+        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendFunction(1)
+        verify(mockSuspendable).suspendFunction(2)
+    }
+
+    @Test
+    fun shouldMockSuspendClassFunctionWithDefault() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
+        val callsSuspendable = CallsSuspendableClass(mockSuspendable)
+
+        `when`(mockSuspendable.suspendClassFunctionWithDefault()).thenReturn(2)
+        `when`(mockSuspendable.suspendClassFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.suspendClassFunctionWithDefault(), IsEqual(2))
+        assertThat(callsSuspendable.suspendClassFunctionWithDefault(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendClassFunctionWithDefault()
+        verify(mockSuspendable).suspendClassFunctionWithDefault(2)
+    }
+
+    @Test
+    fun shouldMockFinalSuspendableClass() = runBlocking<Unit> {
+        val mockClass = mock(FinalSuspendableClass::class.java)
+        `when`(mockClass.fetch()).thenReturn(10)
+        assertThat(mockClass.fetch(), IsEqual(10))
+        verify(mockClass).fetch()
+    }
+}
diff --git a/subprojects/inline/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-integration-tests/kotlin-release-coroutines-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
similarity index 100%
rename from subprojects/inline/src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker
rename to mockito-integration-tests/kotlin-release-coroutines-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
diff --git a/mockito-integration-tests/kotlin-tests/build.gradle.kts b/mockito-integration-tests/kotlin-tests/build.gradle.kts
new file mode 100644
index 0000000000..daee6010aa
--- /dev/null
+++ b/mockito-integration-tests/kotlin-tests/build.gradle.kts
@@ -0,0 +1,26 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id("org.jetbrains.kotlin.jvm")
+    id("mockito.test-conventions")
+}
+
+description = "Kotlin tests for Mockito."
+
+dependencies {
+    testImplementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+
+    testImplementation(libs.kotlin.stdlib)
+    testImplementation(libs.kotlin.coroutines)
+}
+
+tasks {
+    withType<KotlinCompile> {
+        compilerOptions {
+            jvmTarget = JvmTarget.JVM_11
+        }
+    }
+}
+
diff --git a/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/CircularityTest.kt b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/CircularityTest.kt
new file mode 100644
index 0000000000..cd499897be
--- /dev/null
+++ b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/CircularityTest.kt
@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.kotlin
+
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito
+
+class MyClass
+
+class MyTest {
+
+    private lateinit var myClassMock: MyClass
+
+    @Before
+    fun `before each`() {
+        myClassMock = Mockito.mock(MyClass::class.java)
+    }
+
+    @Test
+    fun `some test`() { }
+}
diff --git a/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/FunctionTest.kt b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/FunctionTest.kt
similarity index 100%
rename from subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/FunctionTest.kt
rename to mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/FunctionTest.kt
diff --git a/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/InlineClassTest.kt b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/InlineClassTest.kt
new file mode 100644
index 0000000000..8100b1282d
--- /dev/null
+++ b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/InlineClassTest.kt
@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.kotlin
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.mockito.Mockito.*
+
+@JvmInline
+value class IC(val i: Int)
+@JvmInline
+value class ICN(val i: Int?)
+@JvmInline
+value class SC(val s: String)
+@JvmInline
+value class SCN(val s: String?)
+
+class InlineClassTest {
+    interface I {
+        fun acceptsIC(ic: IC): Int
+        fun returnsIC(i: Int): IC
+
+        fun acceptsIC_N(ic: IC?): Int
+        fun returnsIC_N(i: Int): IC?
+
+        fun acceptsICN(ic: ICN): Int
+        fun returnsICN(i: Int): ICN
+
+        fun acceptsICN_N(ic: ICN?): Int
+        fun returnsICN_N(i: Int): ICN?
+
+        fun acceptsSC(ic: SC): Int
+        fun returnsSC(i: Int): SC
+
+        fun acceptsSC_N(ic: SC?): Int
+        fun returnsSC_N(i: Int): SC?
+
+        fun acceptsSCN(ic: SCN): Int
+        fun returnsSCN(i: Int): SCN
+
+        fun acceptsSCN_N(ic: SCN?): Int
+        fun returnsSCN_N(i: Int): SCN?
+    }
+
+    class Caller(val i: I) {
+        fun callAcceptsIC(ic: IC): Int = i.acceptsIC(ic)
+        fun callReturnsIC(int: Int): IC = i.returnsIC(int)
+
+        fun callAcceptsIC_N(ic: IC?): Int = i.acceptsIC_N(ic)
+        fun callReturnsIC_N(int: Int): IC? = i.returnsIC_N(int)
+
+        fun callAcceptsICN(ic: ICN): Int = i.acceptsICN(ic)
+        fun callReturnsICN(int: Int): ICN = i.returnsICN(int)
+
+        fun callAcceptsICN_N(ic: ICN?): Int = i.acceptsICN_N(ic)
+        fun callReturnsICN_N(int: Int): ICN? = i.returnsICN_N(int)
+
+        fun callAcceptsSC(ic: SC): Int = i.acceptsSC(ic)
+        fun callReturnsSC(int: Int): SC = i.returnsSC(int)
+
+        fun callAcceptsSC_N(ic: SC?): Int = i.acceptsSC_N(ic)
+        fun callReturnsSC_N(int: Int): SC? = i.returnsSC_N(int)
+
+        fun callAcceptsSCN(ic: SCN): Int = i.acceptsSCN(ic)
+        fun callReturnsSCN(int: Int): SCN = i.returnsSCN(int)
+
+        fun callAcceptsSCN_N(ic: SCN?): Int = i.acceptsSCN_N(ic)
+        fun callReturnsSCN_N(int: Int): SCN? = i.returnsSCN_N(int)
+    }
+
+    @Test
+    fun testAcceptsIC() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsIC(IC(1))).thenReturn(1)
+        `when`(mock.acceptsIC(IC(2))).thenReturn(2)
+
+        assertEquals(1, caller.callAcceptsIC(IC(1)))
+        assertEquals(2, caller.callAcceptsIC(IC(2)))
+
+        verify(mock).acceptsIC(IC(1))
+        verify(mock).acceptsIC(IC(2))
+    }
+
+    @Test
+    fun testReturnsIC() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsIC(1)).thenReturn(IC(1))
+        `when`(mock.returnsIC(2)).thenReturn(IC(2))
+
+        assertEquals(IC(1), caller.callReturnsIC(1))
+        assertEquals(IC(2), caller.callReturnsIC(2))
+
+        verify(mock).returnsIC(1)
+        verify(mock).returnsIC(2)
+    }
+
+    @Test
+    fun testAcceptsIC_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsIC_N(IC(1))).thenReturn(1)
+        `when`(mock.acceptsIC_N(null)).thenReturn(0)
+
+        assertEquals(1, caller.callAcceptsIC_N(IC(1)))
+        assertEquals(0, caller.callAcceptsIC_N(null))
+
+        verify(mock).acceptsIC_N(IC(1))
+        verify(mock).acceptsIC_N(null)
+    }
+
+    @Test
+    fun testReturnsIC_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsIC_N(1)).thenReturn(IC(1))
+        `when`(mock.returnsIC_N(0)).thenReturn(null)
+
+        assertEquals(IC(1), caller.callReturnsIC_N(1))
+        assertEquals(null, caller.callReturnsIC_N(0))
+
+        verify(mock).returnsIC_N(1)
+        verify(mock).returnsIC_N(0)
+    }
+
+    @Test
+    fun testAcceptsICN() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsICN(ICN(1))).thenReturn(1)
+        `when`(mock.acceptsICN(ICN(null))).thenReturn(0)
+
+        assertEquals(1, caller.callAcceptsICN(ICN(1)))
+        assertEquals(0, caller.callAcceptsICN(ICN(null)))
+
+        verify(mock).acceptsICN(ICN(1))
+        verify(mock).acceptsICN(ICN(null))
+    }
+
+    @Test
+    fun testReturnsICN() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsICN(1)).thenReturn(ICN(1))
+        `when`(mock.returnsICN(0)).thenReturn(ICN(null))
+
+        assertEquals(ICN(1), caller.callReturnsICN(1))
+        assertEquals(ICN(null), caller.callReturnsICN(0))
+
+        verify(mock).returnsICN(1)
+        verify(mock).returnsICN(0)
+    }
+
+    @Test
+    fun testAcceptsICN_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsICN_N(ICN(1))).thenReturn(1)
+        `when`(mock.acceptsICN_N(null)).thenReturn(0)
+        `when`(mock.acceptsICN_N(ICN(null))).thenReturn(-1)
+
+        assertEquals(1, caller.callAcceptsICN_N(ICN(1)))
+        assertEquals(0, caller.callAcceptsICN_N(null))
+        assertEquals(-1, caller.callAcceptsICN_N(ICN(null)))
+
+        verify(mock).acceptsICN_N(ICN(1))
+        verify(mock).acceptsICN_N(null)
+        verify(mock).acceptsICN_N(ICN(null))
+    }
+
+    @Test
+    fun testReturnsICN_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsICN_N(1)).thenReturn(ICN(1))
+        `when`(mock.returnsICN_N(0)).thenReturn(null)
+        `when`(mock.returnsICN_N(-1)).thenReturn(ICN(null))
+
+        assertEquals(ICN(1), caller.callReturnsICN_N(1))
+        assertEquals(null, caller.callReturnsICN_N(0))
+        assertEquals(ICN(null), caller.callReturnsICN_N(-1))
+
+        verify(mock).returnsICN_N(1)
+        verify(mock).returnsICN_N(0)
+        verify(mock).returnsICN_N(-1)
+    }
+
+    @Test
+    fun testAcceptsSC() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsSC(SC("1"))).thenReturn(1)
+        `when`(mock.acceptsSC(SC("2"))).thenReturn(2)
+
+        assertEquals(1, caller.callAcceptsSC(SC("1")))
+        assertEquals(2, caller.callAcceptsSC(SC("2")))
+
+        verify(mock).acceptsSC(SC("1"))
+        verify(mock).acceptsSC(SC("2"))
+    }
+
+    @Test
+    fun testReturnsSC() {
+        val mock = mock(I::class.java, withSettings().name("").defaultAnswer(RETURNS_MOCKS))
+        val caller = Caller(mock)
+
+        `when`(mock.returnsSC(1)).thenReturn(SC("1"))
+        `when`(mock.returnsSC(2)).thenReturn(SC("2"))
+
+        assertEquals(SC("1"), caller.callReturnsSC(1))
+        assertEquals(SC("2"), caller.callReturnsSC(2))
+
+        verify(mock).returnsSC(1)
+        verify(mock).returnsSC(2)
+    }
+
+    @Test
+    fun testAcceptsSC_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsSC_N(SC("1"))).thenReturn(1)
+        `when`(mock.acceptsSC_N(null)).thenReturn(0)
+
+        assertEquals(1, caller.callAcceptsSC_N(SC("1")))
+        assertEquals(0, caller.callAcceptsSC_N(null))
+
+        verify(mock).acceptsSC_N(SC("1"))
+        verify(mock).acceptsSC_N(null)
+    }
+
+    @Test
+    fun testReturnsSC_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsSC_N(1)).thenReturn(SC("1"))
+        `when`(mock.returnsSC_N(0)).thenReturn(null)
+
+        assertEquals(SC("1"), caller.callReturnsSC_N(1))
+        assertEquals(null, caller.callReturnsSC_N(0))
+
+        verify(mock).returnsSC_N(1)
+        verify(mock).returnsSC_N(0)
+    }
+
+    @Test
+    fun testAcceptsSCN() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsSCN(SCN("1"))).thenReturn(1)
+        `when`(mock.acceptsSCN(SCN(null))).thenReturn(0)
+
+        assertEquals(1, caller.callAcceptsSCN(SCN("1")))
+        assertEquals(0, caller.callAcceptsSCN(SCN(null)))
+
+        verify(mock).acceptsSCN(SCN("1"))
+        verify(mock).acceptsSCN(SCN(null))
+    }
+
+    @Test
+    fun testReturnsSCN() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsSCN(1)).thenReturn(SCN("1"))
+        `when`(mock.returnsSCN(0)).thenReturn(SCN(null))
+
+        assertEquals(SCN("1"), caller.callReturnsSCN(1))
+        assertEquals(SCN(null), caller.callReturnsSCN(0))
+
+        verify(mock).returnsSCN(1)
+        verify(mock).returnsSCN(0)
+    }
+
+    @Test
+    fun testAcceptsSCN_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.acceptsSCN_N(SCN("1"))).thenReturn(1)
+        `when`(mock.acceptsSCN_N(null)).thenReturn(0)
+        `when`(mock.acceptsSCN_N(SCN(null))).thenReturn(-1)
+
+        assertEquals(1, caller.callAcceptsSCN_N(SCN("1")))
+        assertEquals(0, caller.callAcceptsSCN_N(null))
+        assertEquals(-1, caller.callAcceptsSCN_N(SCN(null)))
+
+        verify(mock).acceptsSCN_N(SCN("1"))
+        verify(mock).acceptsSCN_N(null)
+        verify(mock).acceptsSCN_N(SCN(null))
+    }
+
+    @Test
+    fun testReturnsSCN_N() {
+        val mock = mock(I::class.java)
+        val caller = Caller(mock)
+
+        `when`(mock.returnsSCN_N(1)).thenReturn(SCN("1"))
+        `when`(mock.returnsSCN_N(0)).thenReturn(null)
+        `when`(mock.returnsSCN_N(-1)).thenReturn(SCN(null))
+
+        assertEquals(SCN("1"), caller.callReturnsSCN_N(1))
+        assertEquals(null, caller.callReturnsSCN_N(0))
+        assertEquals(SCN(null), caller.callReturnsSCN_N(-1))
+
+        verify(mock).returnsSCN_N(1)
+        verify(mock).returnsSCN_N(0)
+        verify(mock).returnsSCN_N(-1)
+    }
+
+    @Suppress("RESULT_CLASS_IN_RETURN_TYPE")
+    interface WithResult {
+        fun returnsResult(): Result<String>
+    }
+
+    @Suppress("RESULT_CLASS_IN_RETURN_TYPE")
+    class WithResultCaller(val i: WithResult) {
+        fun callReturnsResult(): Result<String> = i.returnsResult()
+    }
+
+    @Test
+    fun testResult() {
+        val mock = mock(WithResult::class.java)
+        val caller = WithResultCaller(mock)
+
+        `when`(mock.returnsResult()).thenReturn(Result.success("OK"))
+
+        assertEquals(Result.success("OK"), caller.callReturnsResult())
+
+        verify(mock).returnsResult()
+    }
+
+    @Test
+    @SuppressWarnings("DoNotMock", "DoNotMockAutoValue")
+    fun automaticallyDetectsClassToMock() {
+        val mock: WithResult = mock()
+
+        `when`(mock.returnsResult()).thenReturn(Result.success("OK"))
+
+        assertEquals("OK", mock.returnsResult().getOrNull())
+    }
+}
diff --git a/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
new file mode 100644
index 0000000000..d42a0c0006
--- /dev/null
+++ b/mockito-integration-tests/kotlin-tests/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.kotlin
+
+import kotlinx.coroutines.runBlocking
+import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.core.IsEqual
+import org.junit.Test
+import org.mockito.Mockito.*
+
+/**
+ * Test for mocking and verifying Kotlin suspending functions.
+ */
+class SuspendTest {
+    interface SuspendableInterface {
+        suspend fun suspendFunction(x: Int): Int
+        suspend fun suspendFunctionWithDefault(x: Int = 1): Int
+    }
+
+    open class SuspendableClass : SuspendableInterface {
+        suspend override fun suspendFunction(x: Int): Int = error("not implemented")
+        suspend override fun suspendFunctionWithDefault(x: Int): Int = error("not implemented")
+        suspend open fun suspendClassFunctionWithDefault(x: Int = 1): Int = error("not implemented")
+    }
+
+    class FinalSuspendableClass {
+        suspend fun fetch(): Int {
+            fetchConcrete()
+            return 2
+        }
+
+        suspend fun fetchConcrete() = 1
+    }
+
+    open class CallsSuspendable(private val suspendable: SuspendableInterface) {
+        fun callSuspendable(x: Int) = runBlocking {
+            suspendable.suspendFunction(x)
+        }
+
+        fun suspendFunctionWithDefault() = runBlocking {
+            suspendable.suspendFunctionWithDefault()
+        }
+
+        fun suspendFunctionWithDefault(x: Int) = runBlocking {
+            suspendable.suspendFunctionWithDefault(x)
+        }
+    }
+
+    class CallsSuspendableClass(private val suspendable: SuspendableClass) : CallsSuspendable(suspendable) {
+        fun suspendClassFunctionWithDefault() = runBlocking {
+            suspendable.suspendClassFunctionWithDefault()
+        }
+
+        fun suspendClassFunctionWithDefault(x: Int) = runBlocking {
+            suspendable.suspendClassFunctionWithDefault(x)
+        }
+    }
+
+    @Test
+    fun shouldMockSuspendInterfaceFunction() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
+        val callsSuspendable = CallsSuspendable(mockSuspendable)
+
+        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
+        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
+        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendFunction(1)
+        verify(mockSuspendable).suspendFunction(2)
+    }
+
+    @Test
+    fun shouldMockSuspendInterfaceFunctionWithDefault() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
+        val callsSuspendable = CallsSuspendable(mockSuspendable)
+
+        `when`(mockSuspendable.suspendFunctionWithDefault()).thenReturn(2)
+        `when`(mockSuspendable.suspendFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.suspendFunctionWithDefault(), IsEqual(2))
+        assertThat(callsSuspendable.suspendFunctionWithDefault(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendFunctionWithDefault()
+        verify(mockSuspendable).suspendFunctionWithDefault(2)
+    }
+
+    @Test
+    fun shouldMockSuspendClassFunction() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
+        val callsSuspendable = CallsSuspendable(mockSuspendable)
+
+        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
+        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
+        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendFunction(1)
+        verify(mockSuspendable).suspendFunction(2)
+    }
+
+    @Test
+    fun shouldMockSuspendClassFunctionWithDefault() = runBlocking<Unit> {
+        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
+        val callsSuspendable = CallsSuspendableClass(mockSuspendable)
+
+        `when`(mockSuspendable.suspendClassFunctionWithDefault()).thenReturn(2)
+        `when`(mockSuspendable.suspendClassFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
+
+        assertThat(callsSuspendable.suspendClassFunctionWithDefault(), IsEqual(2))
+        assertThat(callsSuspendable.suspendClassFunctionWithDefault(2), IsEqual(4))
+
+        verify(mockSuspendable).suspendClassFunctionWithDefault()
+        verify(mockSuspendable).suspendClassFunctionWithDefault(2)
+    }
+
+    @Test
+    fun shouldMockFinalSuspendableClass() = runBlocking<Unit> {
+        val mockClass = mock(FinalSuspendableClass::class.java)
+        `when`(mockClass.fetch()).thenReturn(10)
+        assertThat(mockClass.fetch(), IsEqual(10))
+        verify(mockClass).fetch()
+    }
+}
diff --git a/subprojects/kotlinReleaseCoroutinesTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/mockito-integration-tests/kotlin-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
similarity index 100%
rename from subprojects/kotlinReleaseCoroutinesTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
rename to mockito-integration-tests/kotlin-tests/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
diff --git a/mockito-integration-tests/memory-tests/build.gradle.kts b/mockito-integration-tests/memory-tests/build.gradle.kts
new file mode 100644
index 0000000000..fa4c6dfecc
--- /dev/null
+++ b/mockito-integration-tests/memory-tests/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Test suite memory usage of Mockito"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
+
+tasks {
+    test {
+        maxHeapSize = "128m"
+    }
+}
diff --git a/mockito-integration-tests/memory-tests/src/test/java/org/mockito/memorytest/LocationFactoryAllocationRateTest.java b/mockito-integration-tests/memory-tests/src/test/java/org/mockito/memorytest/LocationFactoryAllocationRateTest.java
new file mode 100644
index 0000000000..c270c192c1
--- /dev/null
+++ b/mockito-integration-tests/memory-tests/src/test/java/org/mockito/memorytest/LocationFactoryAllocationRateTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.memorytest;
+
+import com.sun.management.ThreadMXBean;
+import org.junit.Test;
+import org.mockito.internal.debugging.LocationFactory;
+
+import java.lang.management.ManagementFactory;
+import java.util.stream.IntStream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LocationFactoryAllocationRateTest {
+    private static final int REPEAT = 1000;
+    private static final int RECURSION_LIMIT = 1000;
+    private static final double EXPECTED_IMPROVEMENT = expectedImprovement();
+
+    private static final ThreadMXBean memoryBean =
+            (ThreadMXBean) ManagementFactory.getThreadMXBean();
+
+    @Test
+    public void shouldAllocateMuchLessMemoryThanThrowable() {
+        // On Java 8, this will use the internal approach. On Java 9, the StackWalker approach will
+        // be used.
+        new Throwable().fillInStackTrace();
+        LocationFactory.create();
+        long baseline =
+                countMemoryAllocations(
+                        () ->
+                                recurseAndThen(
+                                        RECURSION_LIMIT,
+                                        repeat(() -> new Throwable().fillInStackTrace())));
+        long actual =
+                countMemoryAllocations(
+                        () ->
+                                recurseAndThen(
+                                        RECURSION_LIMIT,
+                                        repeat(() -> LocationFactory.create(false))));
+        assertThat(actual * EXPECTED_IMPROVEMENT)
+                .as(
+                        "stack walker approach (%d) expected to be at least %fx better than exception approach (%d)",
+                        actual, EXPECTED_IMPROVEMENT, baseline)
+                .isLessThan(baseline);
+    }
+
+    private static long countMemoryAllocations(Runnable someTask) {
+        long threadId = Thread.currentThread().getId();
+        long atStart = memoryBean.getThreadAllocatedBytes(threadId);
+        someTask.run();
+        return memoryBean.getThreadAllocatedBytes(threadId) - atStart;
+    }
+
+    private static void recurseAndThen(int count, Runnable runnable) {
+        if (count <= 0) {
+            runnable.run();
+        } else {
+            recurseAndThen(count - 1, runnable);
+        }
+    }
+
+    private static Runnable repeat(Runnable task) {
+        return () -> IntStream.range(0, REPEAT).forEach(index -> task.run());
+    }
+
+    private static double expectedImprovement() {
+        try {
+            Class.forName("java.lang.StackWalker");
+            return 20;
+        } catch (ClassNotFoundException e) {
+            return 1.5;
+        }
+    }
+}
diff --git a/subprojects/memory-test/src/test/java/org/mockito/memorytest/ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest.java b/mockito-integration-tests/memory-tests/src/test/java/org/mockito/memorytest/ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest.java
similarity index 84%
rename from subprojects/memory-test/src/test/java/org/mockito/memorytest/ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest.java
rename to mockito-integration-tests/memory-tests/src/test/java/org/mockito/memorytest/ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest.java
index d0adca39b3..5c8bac2630 100644
--- a/subprojects/memory-test/src/test/java/org/mockito/memorytest/ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest.java
+++ b/mockito-integration-tests/memory-tests/src/test/java/org/mockito/memorytest/ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest.java
@@ -21,12 +21,7 @@ public class ShouldNotStarveMemoryOnLargeStackTraceInvocationsTest {
 
     static {
         try {
-            Class.forName("sun.misc.SharedSecrets")
-                .getMethod("getJavaLangAccess")
-                .invoke(null);
-            Class.forName("sun.misc.JavaLangAccess")
-                .getMethod("getStackTraceElement", Throwable.class, int.class);
-
+            Class.forName("java.lang.StackWalker");
             supported = true;
         } catch (Exception ignored) {
         }
diff --git a/mockito-integration-tests/module-named-tests/build.gradle.kts b/mockito-integration-tests/module-named-tests/build.gradle.kts
new file mode 100644
index 0000000000..68fc906460
--- /dev/null
+++ b/mockito-integration-tests/module-named-tests/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Test suite for Java 9 modules using a named declaration with Mockito"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
diff --git a/mockito-integration-tests/module-named-tests/src/test/java/module-info.java b/mockito-integration-tests/module-named-tests/src/test/java/module-info.java
new file mode 100644
index 0000000000..5f74e6c85a
--- /dev/null
+++ b/mockito-integration-tests/module-named-tests/src/test/java/module-info.java
@@ -0,0 +1,8 @@
+module org.mockito.test {
+    requires junit;
+    requires org.mockito;
+    requires org.assertj.core;
+
+    exports org.mockito.modulenamedtest to
+            junit;
+}
diff --git a/mockito-integration-tests/module-named-tests/src/test/java/org/mockito/modulenamedtest/ModuleUseTest.java b/mockito-integration-tests/module-named-tests/src/test/java/org/mockito/modulenamedtest/ModuleUseTest.java
new file mode 100644
index 0000000000..87d4ae6256
--- /dev/null
+++ b/mockito-integration-tests/module-named-tests/src/test/java/org/mockito/modulenamedtest/ModuleUseTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.modulenamedtest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import org.junit.Test;
+
+public class ModuleUseTest {
+
+    @Test
+    public void can_mock_with_named_module_inline() {
+        Foo foo = mock(Foo.class);
+        when(foo.value()).thenReturn("foo");
+        assertThat(foo.value()).isEqualTo("foo");
+    }
+
+    @Test
+    public void can_mock_with_named_module_subclass() {
+        Bar bar = mock(Bar.class);
+        when(bar.value()).thenReturn("bar");
+        assertThat(bar.value()).isEqualTo("bar");
+    }
+
+    @Test
+    public void can_mock_with_named_module_subclass_with_interface() {
+        Qux qux = mock(Qux.class, withSettings().extraInterfaces(Runnable.class));
+        when(qux.value()).thenReturn("qux");
+        assertThat(qux.value()).isEqualTo("qux");
+    }
+
+    @Test
+    public void can_mock_with_named_module_subclass_with_serialization() {
+        Baz baz = mock(Baz.class, withSettings().serializable());
+        when(baz.value()).thenReturn("baz");
+        assertThat(baz.value()).isEqualTo("baz");
+    }
+
+    public static class Foo {
+
+        public String value() {
+            return null;
+        }
+    }
+
+    public abstract static class Bar {
+
+        public String value() {
+            return null;
+        }
+    }
+
+    public static class Qux {
+
+        public String value() {
+            return null;
+        }
+    }
+
+    public static class Baz {
+
+        public String value() {
+            return null;
+        }
+    }
+}
diff --git a/mockito-integration-tests/module-tests/build.gradle.kts b/mockito-integration-tests/module-tests/build.gradle.kts
new file mode 100644
index 0000000000..c8435d23f3
--- /dev/null
+++ b/mockito-integration-tests/module-tests/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Test suite for Java 9 modules with Mockito"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
diff --git a/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleAccessTest.java b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleAccessTest.java
new file mode 100644
index 0000000000..ff10b1ac29
--- /dev/null
+++ b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleAccessTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.moduletest;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.reflection.ModuleMemberAccessor;
+import org.mockito.internal.util.reflection.ReflectionMemberAccessor;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.file.Path;
+import java.util.concurrent.Callable;
+
+import static junit.framework.TestCase.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.mockito.moduletest.ModuleUtil.layer;
+import static org.mockito.moduletest.ModuleUtil.modularJar;
+
+public class ModuleAccessTest {
+
+    @Test
+    public void can_access_non_opened_module_with_module_member_accessor() throws Exception {
+        Path jar = modularJar(false, false, false);
+        ModuleLayer layer = layer(jar, false, true);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> moduleMemberAccessor = loader.loadClass(ModuleMemberAccessor.class.getName());
+            Object instance = moduleMemberAccessor.getConstructor().newInstance();
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>)
+                            moduleMemberAccessor
+                                    .getMethod("newInstance", Constructor.class, Object[].class)
+                                    .invoke(instance, type.getConstructor(), new Object[0]);
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void cannot_access_non_opened_module_with_reflection_member_accessor() throws Exception {
+        Path jar = modularJar(false, false, false);
+        ModuleLayer layer = layer(jar, false, true);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> moduleMemberAccessor =
+                    loader.loadClass(ReflectionMemberAccessor.class.getName());
+            try {
+                Object instance = moduleMemberAccessor.getConstructor().newInstance();
+                moduleMemberAccessor
+                        .getMethod("newInstance", Constructor.class, Object[].class)
+                        .invoke(instance, type.getConstructor(), new Object[0]);
+                fail();
+            } catch (InvocationTargetException e) {
+                assertThat(e.getCause()).isInstanceOf(IllegalAccessException.class);
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void cannot_read_unopened_private_field_but_exception_includes_cause() throws Exception {
+        Assume.assumeThat(Plugins.getMemberAccessor(), not(instanceOf(ModuleMemberAccessor.class)));
+
+        Path jar = modularJar(true, true, false, true);
+        ModuleLayer layer = layer(jar, true, true);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        @SuppressWarnings("unchecked")
+        Callable<String> testInstance =
+                (Callable<String>) type.getDeclaredConstructor().newInstance();
+        try {
+            Mockito.mockitoSession().initMocks(testInstance).startMocking();
+            fail("Expected MockitoException caused by IllegalAccessException");
+        } catch (MockitoException ex) {
+            assertThat(ex.getCause()).isInstanceOf(IllegalAccessException.class);
+        }
+    }
+
+    @Test
+    public void can_read_unopened_private_field_but_exception_includes_cause() throws Exception {
+        Assume.assumeThat(Plugins.getMemberAccessor(), instanceOf(ModuleMemberAccessor.class));
+
+        Path jar = modularJar(true, true, false, true);
+        ModuleLayer layer = layer(jar, true, true);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        @SuppressWarnings("unchecked")
+        Callable<String> testInstance =
+                (Callable<String>) type.getDeclaredConstructor().newInstance();
+
+        Mockito.mockitoSession().initMocks(testInstance).startMocking();
+    }
+}
diff --git a/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java
new file mode 100644
index 0000000000..853cdc8a35
--- /dev/null
+++ b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.moduletest;
+
+import net.bytebuddy.dynamic.loading.ClassInjector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.internal.creation.bytebuddy.codegen.InjectionBase;
+import org.mockito.stubbing.OngoingStubbing;
+
+import java.lang.reflect.InvocationTargetException;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+import java.util.concurrent.locks.Lock;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assume.assumeThat;
+import static org.mockito.moduletest.ModuleUtil.layer;
+import static org.mockito.moduletest.ModuleUtil.modularJar;
+
+@RunWith(Parameterized.class)
+public class ModuleHandlingTest {
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][] {{true}, {false}});
+    }
+
+    private final boolean namedModules;
+
+    public ModuleHandlingTest(boolean namedModules) {
+        this.namedModules = namedModules;
+    }
+
+    @Test
+    public void can_define_class_in_open_reading_module() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+
+        Path jar = modularJar(true, true, true);
+        ModuleLayer layer = layer(jar, true, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenCallRealMethod")
+                    .invoke(stubbing);
+
+            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void can_define_class_in_open_java_util_module() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+
+        Path jar = modularJar(true, true, true);
+        ModuleLayer layer = layer(jar, true, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("java.util.concurrent.locks.Lock");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Lock mock = (Lock) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.tryLock());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenReturn", Object.class)
+                    .invoke(stubbing, true);
+
+            boolean relocated =
+                    !Boolean.getBoolean("org.mockito.internal.noUnsafeInjection")
+                            && ClassInjector.UsingReflection.isAvailable();
+            String prefix =
+                    relocated
+                            ? InjectionBase.class.getPackageName() + ".Lock$MockitoMock$"
+                            : "java.util.concurrent.locks.Lock$MockitoMock$";
+            assertThat(mock.getClass().getName()).startsWith(prefix);
+            assertThat(mock.tryLock()).isEqualTo(true);
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void inline_mock_maker_can_mock_closed_modules() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(true));
+
+        Path jar = modularJar(false, false, false);
+        ModuleLayer layer = layer(jar, false, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        Class<?> mockito = loader.loadClass(Mockito.class.getName());
+        @SuppressWarnings("unchecked")
+        Callable<String> mock =
+                (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+        Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+        loader.loadClass(OngoingStubbing.class.getName())
+                .getMethod("thenCallRealMethod")
+                .invoke(stubbing);
+
+        assertThat(mock.getClass().getName()).isEqualTo("sample.MyCallable");
+        assertThat(mock.call()).isEqualTo("foo");
+    }
+
+    @Test
+    public void can_define_class_in_open_reading_private_module() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+
+        Path jar = modularJar(false, true, true);
+        ModuleLayer layer = layer(jar, true, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenCallRealMethod")
+                    .invoke(stubbing);
+
+            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void can_define_class_in_open_non_reading_module() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+
+        Path jar = modularJar(true, true, true);
+        ModuleLayer layer = layer(jar, false, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenCallRealMethod")
+                    .invoke(stubbing);
+
+            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void can_define_class_in_open_non_reading_non_exporting_module() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+
+        Path jar = modularJar(true, false, true);
+        ModuleLayer layer = layer(jar, false, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenCallRealMethod")
+                    .invoke(stubbing);
+
+            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void can_define_class_in_closed_module() throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+
+        Path jar = modularJar(true, true, false);
+        ModuleLayer layer = layer(jar, false, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenCallRealMethod")
+                    .invoke(stubbing);
+
+            boolean relocated =
+                    !Boolean.getBoolean("org.mockito.internal.noUnsafeInjection")
+                            && ClassInjector.UsingReflection.isAvailable();
+            String prefix =
+                    relocated
+                            ? "sample.MyCallable$MockitoMock$"
+                            : "org.mockito.codegen.MyCallable$MockitoMock$";
+            assertThat(mock.getClass().getName()).startsWith(prefix);
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void cannot_define_class_in_non_opened_non_exported_module_if_lookup_injection()
+            throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+        assumeThat(
+                !Boolean.getBoolean("org.mockito.internal.noUnsafeInjection")
+                        && ClassInjector.UsingReflection.isAvailable(),
+                is(true));
+
+        Path jar = modularJar(false, false, false);
+        ModuleLayer layer = layer(jar, false, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            @SuppressWarnings("unchecked")
+            Callable<String> mock =
+                    (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
+            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
+            loader.loadClass(OngoingStubbing.class.getName())
+                    .getMethod("thenCallRealMethod")
+                    .invoke(stubbing);
+
+            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
+            assertThat(mock.call()).isEqualTo("foo");
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+
+    @Test
+    public void can_define_class_in_non_opened_non_exported_module_if_unsafe_injection()
+            throws Exception {
+        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
+        assumeThat(
+                !Boolean.getBoolean("org.mockito.internal.noUnsafeInjection")
+                        && ClassInjector.UsingReflection.isAvailable(),
+                is(false));
+
+        Path jar = modularJar(false, false, false);
+        ModuleLayer layer = layer(jar, false, namedModules);
+
+        ClassLoader loader = layer.findLoader("mockito.test");
+        Class<?> type = loader.loadClass("sample.MyCallable");
+
+        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(loader);
+        try {
+            Class<?> mockito = loader.loadClass(Mockito.class.getName());
+            try {
+                mockito.getMethod("mock", Class.class).invoke(null, type);
+                fail("Expected mocking to fail");
+            } catch (InvocationTargetException e) {
+                assertThat(e.getTargetException())
+                        .isInstanceOf(loader.loadClass(MockitoException.class.getName()));
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+        }
+    }
+}
diff --git a/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleUtil.java b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleUtil.java
new file mode 100644
index 0000000000..0f4d3db6e6
--- /dev/null
+++ b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ModuleUtil.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.moduletest;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.implementation.FixedValue;
+import net.bytebuddy.jar.asm.ClassWriter;
+import net.bytebuddy.jar.asm.ModuleVisitor;
+import net.bytebuddy.jar.asm.Opcodes;
+import net.bytebuddy.utility.OpenedClassReader;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.lang.module.*;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.stream.Stream;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+public class ModuleUtil {
+
+    public static Path modularJar(boolean isPublic, boolean isExported, boolean isOpened)
+            throws IOException {
+        return modularJar(isPublic, isExported, isOpened, false);
+    }
+
+    public static Path modularJar(
+            boolean isPublic, boolean isExported, boolean isOpened, boolean addField)
+            throws IOException {
+        Path jar = Files.createTempFile("sample-module", ".jar");
+        try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(jar))) {
+            out.putNextEntry(new JarEntry("module-info.class"));
+            out.write(moduleInfo(isExported, isOpened));
+            out.closeEntry();
+            out.putNextEntry(new JarEntry("sample/MyCallable.class"));
+            out.write(type(isPublic, addField));
+            out.closeEntry();
+        }
+        return jar;
+    }
+
+    private static byte[] type(boolean isPublic, boolean addField) {
+        DynamicType.Builder<?> typeBuilder =
+                new ByteBuddy()
+                        .subclass(Callable.class)
+                        .name("sample.MyCallable")
+                        .merge(isPublic ? Visibility.PUBLIC : Visibility.PACKAGE_PRIVATE);
+        if (addField) {
+            typeBuilder =
+                    typeBuilder.defineField(
+                            "runnable", Runnable.class, Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL);
+        }
+        return typeBuilder
+                .method(named("call"))
+                .intercept(FixedValue.value("foo"))
+                .make()
+                .getBytes();
+    }
+
+    private static byte[] moduleInfo(boolean isExported, boolean isOpened) {
+        ClassWriter classWriter = new ClassWriter(OpenedClassReader.ASM_API);
+        classWriter.visit(Opcodes.V9, Opcodes.ACC_MODULE, "module-info", null, null, null);
+        ModuleVisitor mv = classWriter.visitModule("mockito.test", 0, null);
+        mv.visitRequire("java.base", Opcodes.ACC_MANDATED, null);
+        mv.visitPackage("sample");
+        if (isExported) {
+            mv.visitExport("sample", 0);
+        }
+        if (isOpened) {
+            mv.visitOpen("sample", 0);
+        }
+        mv.visitEnd();
+        classWriter.visitEnd();
+        return classWriter.toByteArray();
+    }
+
+    public static ModuleLayer layer(Path jar, boolean canRead, boolean namedModules)
+            throws MalformedURLException {
+        Set<String> modules = new HashSet<>();
+        modules.add("mockito.test");
+        ModuleFinder moduleFinder = ModuleFinder.of(jar);
+        if (namedModules) {
+            modules.add("org.mockito");
+            modules.add("net.bytebuddy");
+            modules.add("net.bytebuddy.agent");
+            // We do not list all packages but only roots and packages that interact with the mock
+            // where
+            // we attempt to validate an interaction of two modules. This is of course a bit hacky
+            // as those
+            // libraries would normally be entirely encapsulated in an automatic module with all
+            // their classes
+            // but it is sufficient for the test and saves us a significant amount of code.
+            moduleFinder =
+                    ModuleFinder.compose(
+                            moduleFinder,
+                            automaticModule(
+                                    "org.mockito",
+                                    "org.mockito",
+                                    "org.mockito.internal.creation.bytebuddy"),
+                            automaticModule("net.bytebuddy", "net.bytebuddy"),
+                            automaticModule("net.bytebuddy.agent", "net.bytebuddy.agent"));
+        }
+        Configuration configuration =
+                Configuration.resolve(
+                        moduleFinder,
+                        Collections.singletonList(ModuleLayer.boot().configuration()),
+                        ModuleFinder.of(),
+                        modules);
+        ClassLoader classLoader = new ReplicatingClassLoader(jar);
+        ModuleLayer.Controller controller =
+                ModuleLayer.defineModules(
+                        configuration,
+                        Collections.singletonList(ModuleLayer.boot()),
+                        module -> classLoader);
+        if (canRead) {
+            controller.addReads(
+                    controller
+                            .layer()
+                            .findModule("mockito.test")
+                            .orElseThrow(IllegalStateException::new),
+                    Mockito.class.getModule());
+        }
+        return controller.layer();
+    }
+
+    private static ModuleFinder automaticModule(String moduleName, String... packages) {
+        ModuleDescriptor descriptor =
+                ModuleDescriptor.newAutomaticModule(moduleName)
+                        .packages(new HashSet<>(Arrays.asList(packages)))
+                        .build();
+        ModuleReference reference =
+                new ModuleReference(descriptor, null) {
+                    @Override
+                    public ModuleReader open() {
+                        return new ModuleReader() {
+                            @Override
+                            public Optional<URI> find(String name) {
+                                return Optional.empty();
+                            }
+
+                            @Override
+                            public Stream<String> list() {
+                                return Stream.empty();
+                            }
+
+                            @Override
+                            public void close() {}
+                        };
+                    }
+                };
+        return new ModuleFinder() {
+            @Override
+            public Optional<ModuleReference> find(String name) {
+                return name.equals(moduleName) ? Optional.of(reference) : Optional.empty();
+            }
+
+            @Override
+            public Set<ModuleReference> findAll() {
+                return Collections.singleton(reference);
+            }
+        };
+    }
+}
diff --git a/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java
new file mode 100644
index 0000000000..88e87e0c2d
--- /dev/null
+++ b/mockito-integration-tests/module-tests/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.moduletest;
+
+import org.mockito.Mockito;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Path;
+
+public class ReplicatingClassLoader extends URLClassLoader {
+
+    public ReplicatingClassLoader(Path path) throws MalformedURLException {
+        super(new URL[] {path.toUri().toURL()}, null);
+    }
+
+    @Override
+    public Class<?> loadClass(String name) throws ClassNotFoundException {
+        try {
+            return super.loadClass(name);
+        } catch (ClassNotFoundException e) {
+            InputStream in =
+                    Mockito.class
+                            .getClassLoader()
+                            .getResourceAsStream(name.replace('.', '/') + ".class");
+            if (in == null) {
+                throw e;
+            } else {
+                try {
+                    try {
+                        ByteArrayOutputStream out = new ByteArrayOutputStream();
+                        byte[] buffer = new byte[1024];
+                        int length;
+                        while ((length = (in.read(buffer))) != -1) {
+                            out.write(buffer, 0, length);
+                        }
+                        byte[] b = out.toByteArray();
+                        return defineClass(name, b, 0, b.length);
+                    } finally {
+                        in.close();
+                    }
+                } catch (IOException e1) {
+                    throw new RuntimeException(e1);
+                }
+            }
+        }
+    }
+
+    @Override
+    protected URL findResource(String moduleName, String name) {
+        return Mockito.class.getResource("/" + name);
+    }
+
+    @Override
+    public InputStream getResourceAsStream(String name) {
+        return Mockito.class.getResourceAsStream("/" + name);
+    }
+}
diff --git a/mockito-integration-tests/osgi-tests/build.gradle.kts b/mockito-integration-tests/osgi-tests/build.gradle.kts
new file mode 100644
index 0000000000..d53aa47a10
--- /dev/null
+++ b/mockito-integration-tests/osgi-tests/build.gradle.kts
@@ -0,0 +1,90 @@
+import aQute.bnd.gradle.Bundle
+
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+    id("mockito.osgi-conventions")
+}
+
+description = "Test suite for OSGi framework with Mockito"
+
+dependencies {
+    testImplementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.osgi)
+
+    testRuntimeOnly(libs.equinox)
+}
+
+val testRuntimeBundles: Configuration by configurations.creating
+
+val (otherBundle, otherBundleTask) = configureOsgiBundle(project, "otherBundle")
+val (testBundle, testBundleTask) = configureOsgiBundle(project, "testBundle") {
+    add("testBundleImplementation", project(":mockito-core"))
+    add("testBundleImplementation", project.libs.junit4)
+    add("testBundleImplementation", otherBundle.output)
+}
+
+dependencies {
+    testRuntimeBundles(project(":mockito-core"))
+    testRuntimeBundles(libs.bytebuddy)
+    testRuntimeBundles(libs.objenesis)
+
+    testRuntimeBundles(testBundleTask.map { it.outputs.files })
+    testRuntimeBundles(otherBundleTask.map { it.outputs.files })
+}
+
+tasks {
+    test {
+        jvmArgumentProviders.add(RuntimeBundlesProvider(testRuntimeBundles.asFileTree))
+        dependsOn(testRuntimeBundles)
+
+        inputs.files(testBundle.allSource)
+            .withPathSensitivity(PathSensitivity.RELATIVE)
+            .withPropertyName("testBundleSources")
+
+        inputs.files(otherBundle.allSource)
+            .withPathSensitivity(PathSensitivity.RELATIVE)
+            .withPropertyName("otherBundleSources")
+        useJUnit()
+    }
+}
+
+/**
+ * A helper class to pass classpath elements as relative paths. This allows the build
+ * to be checked out in different locations on the file system and still hit the cache.
+ */
+class RuntimeBundlesProvider(
+    @InputFiles
+    @PathSensitive(PathSensitivity.RELATIVE)
+    val files: FileTree
+) : CommandLineArgumentProvider {
+    override fun asArguments(): Iterable<String> {
+        val absolutePaths = files.files.map { it.absolutePath }
+        return listOf("-DtestRuntimeBundles=${absolutePaths.joinToString(separator = File.pathSeparator)}")
+    }
+}
+
+fun configureOsgiBundle(project: Project, bundleName: String, dependencyConfig: DependencyHandler.() -> Unit = {}): Pair<SourceSet, TaskProvider<Bundle>> {
+    val bundle = project.sourceSets.create(bundleName)
+
+    project.dependencies {
+        dependencyConfig()
+    }
+
+    val bundleTask = project.tasks.register(bundleName, Bundle::class) {
+        archiveAppendix = name
+        bundle { // this: BundleTaskExtension
+            bnd(
+                """
+                    Bundle-SymbolicName: $name
+                    -exportcontents: *
+                    """.trimIndent()
+            )
+        }
+        from(bundle.output)
+    }
+
+    return bundle to bundleTask
+}
+
diff --git a/subprojects/osgi-test/src/otherBundle/java/org/mockito/osgitest/otherbundle/Methods.java b/mockito-integration-tests/osgi-tests/src/otherBundle/java/org/mockito/osgitest/otherbundle/Methods.java
similarity index 100%
rename from subprojects/osgi-test/src/otherBundle/java/org/mockito/osgitest/otherbundle/Methods.java
rename to mockito-integration-tests/osgi-tests/src/otherBundle/java/org/mockito/osgitest/otherbundle/Methods.java
diff --git a/mockito-integration-tests/osgi-tests/src/test/java/org/mockito/osgitest/OsgiTest.java b/mockito-integration-tests/osgi-tests/src/test/java/org/mockito/osgitest/OsgiTest.java
new file mode 100644
index 0000000000..5f96b4a3d9
--- /dev/null
+++ b/mockito-integration-tests/osgi-tests/src/test/java/org/mockito/osgitest/OsgiTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.osgitest;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.model.RunnerBuilder;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.BundleException;
+import org.osgi.framework.Constants;
+import org.osgi.framework.launch.Framework;
+import org.osgi.framework.launch.FrameworkFactory;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.InlineMockMaker;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.AfterClass;
+
+import static org.junit.Assert.fail;
+
+@RunWith(OsgiTest.class)
+public class OsgiTest extends Suite {
+
+    private static final FrameworkFactory frameworkFactory =
+            ServiceLoader.load(FrameworkFactory.class).iterator().next();
+    private static final String STORAGE_TEMPDIR_NAME = "osgi-test-storage";
+    private static final List<String> EXTRA_SYSTEMPACKAGES =
+            Arrays.asList("org.junit", "sun.misc", "sun.reflect");
+
+    private static final List<Path> TEST_RUNTIME_BUNDLES =
+            splitPaths(System.getProperty("testRuntimeBundles"));
+    private static final String TEST_BUNDLE_SYMBOLIC_NAME = "testBundle";
+
+    private static final long STOP_TIMEOUT_MS = 10000;
+
+    private static Path frameworkStorage;
+    private static Framework framework;
+    private static Bundle testBundle;
+
+    public OsgiTest(Class<?> osgiTestClass, RunnerBuilder builder) throws Exception {
+        super(builder, osgiTestClass, setUpClasses());
+    }
+
+    private static Class<?>[] setUpClasses() throws Exception {
+        frameworkStorage = Files.createTempDirectory(STORAGE_TEMPDIR_NAME);
+        Map<String, String> configuration = new HashMap<>();
+        configuration.put(Constants.FRAMEWORK_STORAGE, frameworkStorage.toString());
+        configuration.put(
+                Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, String.join(",", EXTRA_SYSTEMPACKAGES));
+        // When inline mock macker is used, the new 'mockitoboot.jar' is created on the fly
+        // and added to boot classloader (by instrumentation). As such, the following
+        // packages have to be explicitly delegated to boot classloader.
+        configuration.put(
+                Constants.FRAMEWORK_BOOTDELEGATION,
+                "org.mockito.internal.creation.bytebuddy.inject");
+        framework = frameworkFactory.newFramework(configuration);
+        framework.init();
+        BundleContext bundleContext = framework.getBundleContext();
+        for (Path dependencyPath : TEST_RUNTIME_BUNDLES) {
+            Bundle installedBundle;
+            try {
+                installedBundle = bundleContext.installBundle(dependencyPath.toUri().toString());
+            } catch (BundleException e) {
+                throw new IllegalStateException(
+                        "Failed to install bundle: " + dependencyPath.getFileName(), e);
+            }
+            if (TEST_BUNDLE_SYMBOLIC_NAME.equals(installedBundle.getSymbolicName())) {
+                testBundle = installedBundle;
+            }
+        }
+        if (testBundle == null) {
+            fail("Test bundle not found.");
+        }
+        framework.start();
+        try {
+            // Manual start to get a better exception if the bundle cannot be resolved
+            testBundle.start();
+        } catch (BundleException e) {
+            throw new IllegalStateException("Failed to start test bundle.", e);
+        }
+        return getTestClasses();
+    }
+
+    private static Class<?>[] getTestClasses() throws Exception {
+        // The tests could not use 'Plugins' since 'org.mockito.internal' package is not exported.
+        // Making the decision which tests to run depending on mock maker instance.
+        if (Plugins.getMockMaker() instanceof InlineMockMaker) {
+            return new Class<?>[] {
+                loadTestClass("SimpleMockTest"),
+                loadTestClass("MockNonPublicClassTest"),
+                loadTestClass("MockClassInOtherBundleTest")
+            };
+        } else {
+            return new Class<?>[] {
+                loadTestClass("SimpleMockTest"),
+                loadTestClass("MockNonPublicClassFailsTest"),
+                loadTestClass("MockClassInOtherBundleTest")
+            };
+        }
+    }
+
+    @AfterClass
+    public static void tearDown() throws Exception {
+        try {
+            if (framework != null) {
+                framework.stop();
+                framework.waitForStop(STOP_TIMEOUT_MS);
+            }
+        } finally {
+            if (frameworkStorage != null) {
+                deleteRecursively(frameworkStorage);
+            }
+        }
+    }
+
+    private static Class<?> loadTestClass(String className) throws Exception {
+        return testBundle.loadClass("org.mockito.osgitest.testbundle." + className);
+    }
+
+    private static List<Path> splitPaths(String paths) {
+        return Stream.of(paths.split(Pattern.quote(File.pathSeparator)))
+                .map(p -> Paths.get(p))
+                .collect(Collectors.toList());
+    }
+
+    private static void deleteRecursively(Path pathToDelete) throws IOException {
+        Files.walkFileTree(
+                pathToDelete,
+                new SimpleFileVisitor<Path>() {
+                    @Override
+                    public FileVisitResult postVisitDirectory(Path dir, IOException exc)
+                            throws IOException {
+                        Files.delete(dir);
+                        return FileVisitResult.CONTINUE;
+                    }
+
+                    @Override
+                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+                            throws IOException {
+                        Files.delete(file);
+                        return FileVisitResult.CONTINUE;
+                    }
+                });
+    }
+}
diff --git a/subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/MockClassInOtherBundleTest.java b/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockClassInOtherBundleTest.java
similarity index 100%
rename from subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/MockClassInOtherBundleTest.java
rename to mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockClassInOtherBundleTest.java
diff --git a/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassFailsTest.java b/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassFailsTest.java
new file mode 100644
index 0000000000..406defaf97
--- /dev/null
+++ b/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassFailsTest.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.osgitest.testbundle;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+
+import static org.mockito.Mockito.mock;
+
+public class MockNonPublicClassFailsTest {
+
+    static class NonPublicClass {}
+
+    @Test(expected = MockitoException.class)
+    public void test() {
+        // Expected: The type is not public and its mock class is loaded by a different class
+        // loader.
+        NonPublicClass nonPublicClass = mock(NonPublicClass.class);
+    }
+}
diff --git a/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassTest.java b/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassTest.java
new file mode 100644
index 0000000000..fedd45dab1
--- /dev/null
+++ b/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassTest.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.osgitest.testbundle;
+
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+
+public class MockNonPublicClassTest {
+
+    static class NonPublicClass {}
+
+    @Test
+    public void test_non_public_class() {
+        NonPublicClass nonPublicClass = mock(NonPublicClass.class);
+    }
+}
diff --git a/subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/SimpleMockTest.java b/mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/SimpleMockTest.java
similarity index 100%
rename from subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/SimpleMockTest.java
rename to mockito-integration-tests/osgi-tests/src/testBundle/java/org/mockito/osgitest/testbundle/SimpleMockTest.java
diff --git a/mockito-integration-tests/programmatic-tests/build.gradle.kts b/mockito-integration-tests/programmatic-tests/build.gradle.kts
new file mode 100644
index 0000000000..e17312551b
--- /dev/null
+++ b/mockito-integration-tests/programmatic-tests/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Test suite for exercising programmatic mock maker in Mockito"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
+
+tasks {
+    test {
+        forkEvery = 1
+    }
+}
diff --git a/mockito-integration-tests/programmatic-tests/src/test/java/org/mockito/ProgrammaticMockMakerTest.java b/mockito-integration-tests/programmatic-tests/src/test/java/org/mockito/ProgrammaticMockMakerTest.java
new file mode 100644
index 0000000000..f03555d0e5
--- /dev/null
+++ b/mockito-integration-tests/programmatic-tests/src/test/java/org/mockito/ProgrammaticMockMakerTest.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.withSettings;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.SmartNullPointerException;
+import org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+
+public final class ProgrammaticMockMakerTest {
+    @Test
+    public void test_normal_mock_uses_given_mock_maker() {
+        ClassWithFinalMethod inlineMock =
+                Mockito.mock(
+                        ClassWithFinalMethod.class, withSettings().mockMaker(MockMakers.INLINE));
+        ClassWithFinalMethod subclassMock =
+                Mockito.mock(
+                        ClassWithFinalMethod.class, withSettings().mockMaker(MockMakers.SUBCLASS));
+
+        Mockito.when(inlineMock.finalMethodCallingNonFinal()).thenReturn("MOCKED");
+        Mockito.when(subclassMock.finalMethodCallingNonFinal()).thenReturn("MOCKED");
+
+        assertEquals("MOCKED", inlineMock.finalMethodCallingNonFinal());
+        assertEquals("ORIGINAL", subclassMock.finalMethodCallingNonFinal());
+        assertEquals("MOCKED", subclassMock.nonFinal());
+    }
+
+    @Test
+    public void test_mockability_check_uses_given_mock_maker() {
+        assertNotNull(Mockito.mock(FinalClass.class, withSettings().mockMaker(MockMakers.INLINE)));
+        assertThrows(
+                MockitoException.class,
+                () ->
+                        Mockito.mock(
+                                FinalClass.class, withSettings().mockMaker(MockMakers.SUBCLASS)));
+    }
+
+    @Test
+    public void test_deep_stups_inherit_mock_maker() {
+        Container inlineMock =
+                Mockito.mock(
+                        Container.class,
+                        withSettings()
+                                .mockMaker(MockMakers.INLINE)
+                                .defaultAnswer(Answers.RETURNS_DEEP_STUBS));
+        Container subclassMock =
+                Mockito.mock(
+                        Container.class,
+                        withSettings()
+                                .mockMaker(MockMakers.SUBCLASS)
+                                .defaultAnswer(Answers.RETURNS_DEEP_STUBS));
+
+        assertNotNull(inlineMock.finalClass());
+        assertNotNull(inlineMock.subContainer().finalClass());
+        assertNull(inlineMock.finalClass().someMethod());
+        assertNull(inlineMock.subContainer().finalClass().someMethod());
+        assertNull(inlineMock.classWithFinalMethod().finalMethod());
+        assertNull(inlineMock.subContainer().classWithFinalMethod().finalMethod());
+
+        assertNull(subclassMock.finalClass());
+        assertNull(subclassMock.subContainer().finalClass());
+        assertEquals("ORIGINAL", subclassMock.classWithFinalMethod().finalMethod());
+        assertEquals("ORIGINAL", subclassMock.subContainer().classWithFinalMethod().finalMethod());
+    }
+
+    @Test
+    public void test_returned_mocks_inherit_mock_maker() {
+        Container inlineMock =
+                Mockito.mock(
+                        Container.class,
+                        withSettings()
+                                .mockMaker(MockMakers.INLINE)
+                                .defaultAnswer(Answers.RETURNS_MOCKS));
+        Container subclassMock =
+                Mockito.mock(
+                        Container.class,
+                        withSettings()
+                                .mockMaker(MockMakers.SUBCLASS)
+                                .defaultAnswer(Answers.RETURNS_MOCKS));
+
+        assertNotNull(inlineMock.finalClass());
+        assertNotNull(inlineMock.subContainer().finalClass());
+        assertEquals("", inlineMock.finalClass().someMethod());
+        assertEquals("", inlineMock.subContainer().finalClass().someMethod());
+        assertEquals("", inlineMock.classWithFinalMethod().finalMethod());
+        assertEquals("", inlineMock.subContainer().classWithFinalMethod().finalMethod());
+
+        assertNull(subclassMock.finalClass());
+        assertNull(subclassMock.subContainer().finalClass());
+        assertEquals("ORIGINAL", subclassMock.classWithFinalMethod().finalMethod());
+        assertEquals("ORIGINAL", subclassMock.subContainer().classWithFinalMethod().finalMethod());
+    }
+
+    @Test
+    public void test_smart_nulls_inherit_mock_maker() {
+        Container inlineMock =
+                Mockito.mock(
+                        Container.class,
+                        withSettings()
+                                .mockMaker(MockMakers.INLINE)
+                                .defaultAnswer(Answers.RETURNS_SMART_NULLS));
+        Container subclassMock =
+                Mockito.mock(
+                        Container.class,
+                        withSettings()
+                                .mockMaker(MockMakers.SUBCLASS)
+                                .defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+        assertNotNull(inlineMock.finalClass());
+        assertNotNull(inlineMock.classWithFinalMethod());
+        assertThrows(SmartNullPointerException.class, () -> inlineMock.finalClass().someMethod());
+        assertThrows(
+                SmartNullPointerException.class,
+                () -> inlineMock.classWithFinalMethod().finalMethod());
+
+        assertNull(subclassMock.finalClass());
+        assertNotNull(subclassMock.classWithFinalMethod());
+        assertEquals("ORIGINAL", subclassMock.classWithFinalMethod().finalMethod());
+    }
+
+    @Test
+    public void test_custom_mock_maker() {
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mock(
+                                    Container.class,
+                                    withSettings().mockMaker(CustomMockMaker.class.getName()));
+                        })
+                .hasMessage("CUSTOM MOCK MAKER");
+    }
+
+    @Test
+    public void test_exception_when_mock_maker_cannot_be_instantiated() {
+        class InvalidMockMaker extends SubclassByteBuddyMockMaker {
+            // Local classes have an implicit constructor parameter,
+            // which makes them an invalid mock maker.
+        }
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mock(
+                                    Container.class,
+                                    withSettings().mockMaker(InvalidMockMaker.class.getName()));
+                        })
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessageContaining("Failed to construct MockMaker")
+                .hasMessageContaining(InvalidMockMaker.class.getName());
+    }
+
+    private static final class FinalClass {
+        String someMethod() {
+            return "ORIGINAL";
+        }
+    }
+
+    private static class ClassWithFinalMethod {
+        final String finalMethod() {
+            return "ORIGINAL";
+        }
+
+        final String finalMethodCallingNonFinal() {
+            nonFinal();
+            return "ORIGINAL";
+        }
+
+        String nonFinal() {
+            return "ORIGINAL";
+        }
+    }
+
+    private static class Container {
+        FinalClass finalClass() {
+            return new FinalClass();
+        }
+
+        ClassWithFinalMethod classWithFinalMethod() {
+            return new ClassWithFinalMethod();
+        }
+
+        Container subContainer() {
+            return new Container();
+        }
+    }
+
+    public static class CustomMockMaker extends SubclassByteBuddyMockMaker {
+        @Override
+        public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+            throw new RuntimeException("CUSTOM MOCK MAKER");
+        }
+    }
+}
diff --git a/mockito-integration-tests/programmatic-tests/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java b/mockito-integration-tests/programmatic-tests/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java
new file mode 100644
index 0000000000..2d495bed00
--- /dev/null
+++ b/mockito-integration-tests/programmatic-tests/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2022 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.annotation;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockMakers;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+public class ProgrammaticMockMakerAnnotationTest {
+    @Mock(mockMaker = MockMakers.INLINE)
+    ClassWithFinalMethod inlineMock;
+
+    @Mock(mockMaker = MockMakers.SUBCLASS)
+    ClassWithFinalMethod subclassMock;
+
+    @Before
+    public void init() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    public void test_mock_uses_given_mock_maker() {
+        Mockito.when(inlineMock.finalMethodCallingNonFinal()).thenReturn("MOCKED");
+        Mockito.when(subclassMock.finalMethodCallingNonFinal()).thenReturn("MOCKED");
+
+        assertEquals("MOCKED", inlineMock.finalMethodCallingNonFinal());
+        assertEquals("ORIGINAL", subclassMock.finalMethodCallingNonFinal());
+        assertEquals("MOCKED", subclassMock.nonFinal());
+    }
+
+    private static class ClassWithFinalMethod {
+        final String finalMethodCallingNonFinal() {
+            nonFinal();
+            return "ORIGINAL";
+        }
+
+        String nonFinal() {
+            return "ORIGINAL";
+        }
+    }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index fdd9f374fb..62ab590cf3 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,41 +1,72 @@
-include("deprecatedPluginsTest",
-    "inline",
-    "extTest",
-    "kotlinTest",
-    "kotlinReleaseCoroutinesTest",
-    "android",
-    "junit-jupiter",
-    "junitJupiterExtensionTest",
-    "module-test",
-    "memory-test",
-    "errorprone",
-    "junitJupiterParallelTest",
-    "osgi-test")
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        google()
+    }
+}
 
-rootProject.name = "mockito"
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
 
-val koltinBuildScriptProject = hashSetOf("junitJupiterExtensionTest")
+plugins {
+    id("com.gradle.develocity") version "3.19.1"
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.9.0"
+}
 
-fun buildFileExtensionFor(projectName: String) =
-    if (projectName in koltinBuildScriptProject) ".gradle.kts" else ".gradle"
+include("mockito-core")
+// BOM project
+include("mockito-bom")
+// extensions
+include(
+    "mockito-extensions:mockito-android",
+    "mockito-extensions:mockito-errorprone",
+    "mockito-extensions:mockito-junit-jupiter",
+    "mockito-extensions:mockito-proxy",
+    "mockito-extensions:mockito-subclass",
+)
+// integration tests
+include(
+    "mockito-integration-tests:inline-mocks-tests",
+    "mockito-integration-tests:extensions-tests",
+    "mockito-integration-tests:groovy-tests",
+    "mockito-integration-tests:groovy-inline-tests",
+    "mockito-integration-tests:kotlin-tests",
+    "mockito-integration-tests:kotlin-release-coroutines-tests",
+    "mockito-integration-tests:junit-jupiter-extension-tests",
+    "mockito-integration-tests:junit-jupiter-inline-mock-maker-extension-tests",
+    "mockito-integration-tests:module-tests",
+    "mockito-integration-tests:module-named-tests",
+    "mockito-integration-tests:memory-tests",
+    "mockito-integration-tests:junit-jupiter-parallel-tests",
+    "mockito-integration-tests:osgi-tests",
+    "mockito-integration-tests:programmatic-tests",
+    "mockito-integration-tests:java-21-tests",
+)
 
-fun buildFileFor(projectName: String) =
-    "$projectName${buildFileExtensionFor(projectName)}"
+// https://developer.android.com/studio/command-line/variables#envar
+// https://developer.android.com/studio/build#properties-files
+if (providers.environmentVariable("ANDROID_HOME").isPresent || File("local.properties").exists()) {
+    include("mockito-integration-tests:android-tests")
+} else {
+    logger.info("Not including android test project due to missing SDK configuration")
+}
 
-rootProject.children.forEach { project ->
-    val projectDirName = "subprojects/${project.name}"
-    project.projectDir = File(settingsDir, projectDirName)
-    project.buildFileName = buildFileFor(project.name)
-    require(project.projectDir.isDirectory) {
-        "Project directory ${project.projectDir} for project ${project.name} does not exist."
-    }
-    require(project.buildFile.isFile) {
-        "Build file ${project.buildFile} for project ${project.name} does not exist."
+rootProject.name = "mockito"
+
+//Posting Build scans to https://scans.gradle.com
+develocity {
+    buildScan {
+        termsOfUseUrl = "https://gradle.com/terms-of-service"
+        termsOfUseAgree = "yes"
     }
 }
 
 buildCache {
     local {
-        isEnabled = !System.getenv().containsKey("CI")
+        isEnabled = !providers.environmentVariable("CI").isPresent
     }
 }
diff --git a/src/javadoc/js/highlight-8.6-java/CHANGES.md b/src/javadoc/js/highlight-8.6-java/CHANGES.md
deleted file mode 100644
index 4c8b442ee1..0000000000
--- a/src/javadoc/js/highlight-8.6-java/CHANGES.md
+++ /dev/null
@@ -1,1128 +0,0 @@
-## Version 8.6
-
-New languages:
-
-- *C/AL* by [Kenneth Fuglsang][]
-- *DNS zone file* by [Tim Schumacher][]
-- *Ceylon* by [Lucas Werkmeister][]
-- *OpenSCAD* by [Dan Panzarella][]
-- *Inform7* by [Bruno Dias][]
-- *armasm* by [Dan Panzarella][]
-- *TP* by [Jay Strybis][]
-
-New Styles:
-
-- *Atelier Cave*, *Atelier Estuary*,
-  *Atelier Plateau* and *Atelier Savanna* by [Bram de Haan][]
-- *Github Gist* by [Louis Barranqueiro][]
-
-Notable fixes and improvements to existing languages:
-
-- Multi-line raw strings from C++11 are now supported
-- Fix class names with dashes in HAML
-- The `async` keyword from ES6/7 is now supported
-- TypeScript functions handle type and parameter complexity better
-- We unified phpdoc/javadoc/yardoc etc modes across all languages
-- CSS .class selectors relevance was dropped to prevent wrong language detection
-- Images is now included to CDN build
-- Release process is now automated
-
-[Bram de Haan]: https://github.com/atelierbram
-[Kenneth Fuglsang]: https://github.com/kfuglsang
-[Louis Barranqueiro]: https://github.com/LouisBarranqueiro
-[Tim Schumacher]: https://github.com/enko
-[Lucas Werkmeister]: https://github.com/lucaswerkmeister
-[Dan Panzarella]: https://github.com/pzl
-[Bruno Dias]: https://github.com/sequitur
-[Jay Strybis]: https://github.com/unreal
-
-## Version 8.5
-
-New languages:
-
-- *pf.conf* by [Peter Piwowarski][]
-- *Julia* by [Kenta Sato][]
-- *Prolog* by [Raivo Laanemets][]
-- *Docker* by [Alexis Hénaut][]
-- *Fortran* by [Anthony Scemama][] and [Thomas Applencourt][]
-- *Kotlin* by [Sergey Mashkov][]
-
-New Styles:
-
-- *Agate* by [Taufik Nurrohman][]
-- *Darkula* by [Jet Brains][]
-- *Atelier Sulphurpool* by [Bram de Haan][]
-- *Android Studio* by [Pedro Oliveira][]
-
-Notable fixes and improvements to existing languages:
-
-- ES6 features in JavaScript are better supported now by [Gu Yiling][].
-- Swift now recognizes body-less method definitions.
-- Single expression functions `def foo, do: ... ` now work in Elixir.
-- More uniform detection of built-in classes in Objective C.
-- Fixes for number literals and processor directives in Rust.
-- HTML `<script>` tag now allows any language, not just JavaScript.
-- Multi-line comments are supported now in MatLab.
-
-[Taufik Nurrohman]: https://github.com/tovic
-[Jet Brains]: https://www.jetbrains.com/
-[Peter Piwowarski]: https://github.com/oldlaptop
-[Kenta Sato]: https://github.com/bicycle1885
-[Bram de Haan]: https://github.com/atelierbram
-[Raivo Laanemets]: https://github.com/rla
-[Alexis Hénaut]: https://github.com/AlexisNo
-[Anthony Scemama]: https://github.com/scemama
-[Pedro Oliveira]: https://github.com/kanytu
-[Gu Yiling]: https://github.com/Justineo
-[Sergey Mashkov]: https://github.com/cy6erGn0m
-[Thomas Applencourt]: https://github.com/TApplencourt
-
-## Version 8.4
-
-We've got the new [demo page][]! The obvious new feature is the new look, but
-apart from that it's got smarter: by presenting languages in groups it avoids
-running 10000 highlighting attempts after first load which was slowing it down
-and giving bad overall impression. It is now also being generated from test
-code snippets so the authors of new languages don't have to update both tests
-and the demo page with the same thing.
-
-Other notable changes:
-
-- The `template_comment` class is gone in favor of the more general `comment`.
-- Number parsing unified and improved across languages.
-- C++, Java and C# now use unified grammar to highlight titles in
-  function/method definitions.
-- The browser build is now usable as an AMD module, there's no separate build
-  target for that anymore.
-- OCaml has got a [comprehensive overhaul][ocaml] by [Mickaël Delahaye][].
-- Clojure's data structures and literals are now highlighted outside of lists
-  and we can now highlight Clojure's REPL sessions.
-
-New languages:
-
-- *AspectJ* by [Hakan Özler][]
-- *STEP Part 21* by [Adam Joseph Cook][]
-- *SML* derived by [Edwin Dalorzo][] from OCaml definition
-- *Mercury* by [mucaho][]
-- *Smali* by [Dennis Titze][]
-- *Verilog* by [Jon Evans][]
-- *Stata* by [Brian Quistorff][]
-
-[Hakan Özler]: https://github.com/ozlerhakan
-[Adam Joseph Cook]: https://github.com/adamjcook
-[demo page]: https://highlightjs.org/static/demo/
-[Ivan Sagalaev]: https://github.com/isagalaev
-[Edwin Dalorzo]: https://github.com/edalorzo
-[mucaho]: https://github.com/mucaho
-[Dennis Titze]: https://github.com/titze
-[Jon Evans]: https://github.com/craftyjon
-[Brian Quistorff]: https://github.com/bquistorff
-[ocaml]: https://github.com/isagalaev/highlight.js/pull/608#issue-46190207
-[Mickaël Delahaye]: https://github.com/polazarus
-
-
-## Version 8.3
-
-We streamlined our tool chain, it is now based entirely on node.js instead of
-being a mix of node.js, Python and Java. The build script options and arguments
-remained the same, and we've noted all the changes in the [documentation][b].
-Apart from reducing complexity, the new build script is also faster from not
-having to start Java machine repeatedly. The credits for the work go to [Jeremy
-Hull][].
-
-Some notable fixes:
-
-- PHP and JavaScript mixed in HTML now live happily with each other.
-- JavaScript regexes now understand ES6 flags "u" and "y".
-- `throw` keyword is no longer detected as a method name in Java.
-- Fixed parsing of numbers and symbols in Clojure thanks to [input from Ivan
-  Kleshnin][ik].
-
-New languages in this release:
-
-- *Less* by [Max Mikhailov][]
-- *Stylus* by [Bryant Williams][]
-- *Tcl* by [Radek Liska][]
-- *Puppet* by [Jose Molina Colmenero][]
-- *Processing* by [Erik Paluka][]
-- *Twig* templates by [Luke Holder][]
-- *PowerShell* by [David Mohundro][], based on [the work of Nicholas Blumhardt][ps]
-- *XL* by [Christophe de Dinechin][]
-- *LiveScript* by [Taneli Vatanen][] and [Jen Evers-Corvina][]
-- *ERB* (Ruby in HTML) by [Lucas Mazza][]
-- *Roboconf* by [Vincent Zurczak][]
-
-[b]: http://highlightjs.readthedocs.org/en/latest/building-testing.html
-[Jeremy Hull]: https://github.com/sourrust
-[ik]: https://twitter.com/IvanKleshnin/status/514041599484231680
-[Max Mikhailov]: https://github.com/seven-phases-max
-[Bryant Williams]: https://github.com/scien
-[Radek Liska]: https://github.com/Nindaleth
-[Jose Molina Colmenero]: https://github.com/Moliholy
-[Erik Paluka]: https://github.com/paluka
-[Luke Holder]: https://github.com/lukeholder
-[David Mohundro]: https://github.com/drmohundro
-[ps]: https://github.com/OctopusDeploy/Library/blob/master/app/shared/presentation/highlighting/powershell.js
-[Christophe de Dinechin]: https://github.com/c3d
-[Taneli Vatanen]: https://github.com/Daiz-
-[Jen Evers-Corvina]: https://github.com/sevvie
-[Lucas Mazza]: https://github.com/lucasmazza
-[Vincent Zurczak]: https://github.com/vincent-zurczak
-
-
-## Version 8.2
-
-We've finally got [real tests][test] and [continuous testing on Travis][ci]
-thanks to [Jeremy Hull][] and [Chris Eidhof][]. The tests designed to cover
-everything: language detection, correct parsing of individual language features
-and various special cases. This is a very important change that gives us
-confidence in extending language definitions and refactoring library core.
-
-We're going to redesign the old [demo/test suite][demo] into an interactive
-demo web app. If you're confident front-end developer or designer and want to
-help us with it, drop a comment into [the issue][#542] on GitHub.
-
-[test]: https://github.com/isagalaev/highlight.js/tree/master/test
-[demo]: https://highlightjs.org/static/test.html
-[#542]: https://github.com/isagalaev/highlight.js/issues/542
-[ci]: https://travis-ci.org/isagalaev/highlight.js
-[Jeremy Hull]: https://github.com/sourrust
-[Chris Eidhof]: https://github.com/chriseidhof
-
-As usually there's a handful of new languages in this release:
-
-- *Groovy* by [Guillaume Laforge][]
-- *Dart* by [Maxim Dikun][]
-- *Dust* by [Michael Allen][]
-- *Scheme* by [JP Verkamp][]
-- *G-Code* by [Adam Joseph Cook][]
-- *Q* from Kx Systems by [Sergey Vidyuk][]
-
-[Guillaume Laforge]: https://github.com/glaforge
-[Maxim Dikun]: https://github.com/dikmax
-[Michael Allen]: https://github.com/bfui
-[JP Verkamp]: https://github.com/jpverkamp
-[Adam Joseph Cook]: https://github.com/adamjcook
-[Sergey Vidyuk]: https://github.com/sv
-
-Other improvements:
-
-- [Erik Osheim][] heavily reworked Scala definitions making it richer.
-- [Lucas Mazza][] fixed Ruby hashes highlighting
-- Lisp variants (Lisp, Clojure and Scheme) are unified in regard to naming
-  the first symbol in parentheses: it's "keyword" in general case and also
-  "built_in" for built-in functions in Clojure and Scheme.
-
-[Erik Osheim]: https://github.com/non
-[Lucas Mazza]: https://github.com/lucasmazza
-
-## Version 8.1
-
-New languages:
-
-- *Gherkin* by [Sam Pikesley][]
-- *Elixir* by [Josh Adams][]
-- *NSIS* by [Jan T. Sott][]
-- *VIM script* by [Jun Yang][]
-- *Protocol Buffers* by [Dan Tao][]
-- *Nix* by [Domen Kožar][]
-- *x86asm* by [innocenat][]
-- *Cap’n Proto* and *Thrift* by [Oleg Efimov][]
-- *Monkey* by [Arthur Bikmullin][]
-- *TypeScript* by [Panu Horsmalahti][]
-- *Nimrod* by [Flaviu Tamas][]
-- *Gradle* by [Damian Mee][]
-- *Haxe* by [Christopher Kaster][]
-- *Swift* by [Chris Eidhof][] and [Nate Cook][]
-
-New styles:
-
-- *Kimbie*, light and dark variants by [Jan T. Sott][]
-- *Color brewer* by [Fabrício Tavares de Oliveira][]
-- *Codepen.io embed* by [Justin Perry][]
-- *Hybrid* by [Nic West][]
-
-[Sam Pikesley]: https://github.com/pikesley
-[Sindre Sorhus]: https://github.com/sindresorhus
-[Josh Adams]: https://github.com/knewter
-[Jan T. Sott]: https://github.com/idleberg
-[Jun Yang]: https://github.com/harttle
-[Dan Tao]: https://github.com/dtao
-[Domen Kožar]: https://github.com/iElectric
-[innocenat]: https://github.com/innocenat
-[Oleg Efimov]: https://github.com/Sannis
-[Arthur Bikmullin]: https://github.com/devolonter
-[Panu Horsmalahti]: https://github.com/panuhorsmalahti
-[Flaviu Tamas]: https://github.com/flaviut
-[Damian Mee]: https://github.com/chester1000
-[Christopher Kaster]: http://christopher.kaster.ws
-[Fabrício Tavares de Oliveira]: https://github.com/fabriciotav
-[Justin Perry]: https://github.com/ourmaninamsterdam
-[Nic West]: https://github.com/nicwest
-[Chris Eidhof]: https://github.com/chriseidhof
-[Nate Cook]: https://github.com/natecook1000
-
-Other improvements:
-
-- The README is heavily reworked and brought up to date by [Jeremy Hull][].
-- Added [`listLanguages()`][ll] method in the API.
-- Improved C/C++/C# detection.
-- Added a bunch of new language aliases, documented the existing ones. Thanks to
-  [Sindre Sorhus][] for background research.
-- Added phrasal English words to boost relevance in comments.
-- Many improvements to SQL definition made by [Heiko August][],
-  [Nikolay Lisienko][] and [Travis Odom][].
-- The shorter `lang-` prefix for language names in HTML classes supported
-  alongside `language-`. Thanks to [Jeff Escalante][].
-- Ruby's got support for interactive console sessions. Thanks to
-  [Pascal Hurni][].
-- Added built-in functions for R language. Thanks to [Artem A. Klevtsov][].
-- Rust's got definition for lifetime parameters and improved string syntax.
-  Thanks to [Roman Shmatov][].
-- Various improvements to Objective-C definition by [Matt Diephouse][].
-- Fixed highlighting of generics in Java.
-
-[ll]: http://highlightjs.readthedocs.org/en/latest/api.html#listlanguages
-[Sindre Sorhus]: https://github.com/sindresorhus
-[Heiko August]: https://github.com/auge8472
-[Nikolay Lisienko]: https://github.com/neor-ru
-[Travis Odom]: https://github.com/Burstaholic
-[Jeff Escalante]: https://github.com/jenius
-[Pascal Hurni]: https://github.com/phurni
-[Jiyin Yiyong]: https://github.com/jiyinyiyong
-[Artem A. Klevtsov]: https://github.com/unikum
-[Roman Shmatov]: https://github.com/shmatov
-[Jeremy Hull]: https://github.com/sourrust
-[Matt Diephouse]: https://github.com/mdiep
-
-
-## Version 8.0
-
-This new major release is quite a big overhaul bringing both new features and
-some backwards incompatible changes. However, chances are that the majority of
-users won't be affected by the latter: the basic scenario described in the
-README is left intact.
-
-Here's what did change in an incompatible way:
-
-- We're now prefixing all classes located in [CSS classes reference][cr] with
-  `hljs-`, by default, because some class names would collide with other
-  people's stylesheets. If you were using an older version, you might still want
-  the previous behavior, but still want to upgrade. To suppress this new
-  behavior, you would initialize like so:
-
-  ```html
-  <script type="text/javascript">
-    hljs.configure({classPrefix: ''});
-    hljs.initHighlightingOnLoad();
-  </script>
-  ```
-
-- `tabReplace` and `useBR` that were used in different places are also unified
-  into the global options object and are to be set using `configure(options)`.
-  This function is documented in our [API docs][]. Also note that these
-  parameters are gone from `highlightBlock` and `fixMarkup` which are now also
-  rely on `configure`.
-
-- We removed public-facing (though undocumented) object `hljs.LANGUAGES` which
-  was used to register languages with the library in favor of two new methods:
-  `registerLanguage` and `getLanguage`. Both are documented in our [API docs][].
-
-- Result returned from `highlight` and `highlightAuto` no longer contains two
-  separate attributes contributing to relevance score, `relevance` and
-  `keyword_count`. They are now unified in `relevance`.
-
-Another technically compatible change that nonetheless might need attention:
-
-- The structure of the NPM package was refactored, so if you had installed it
-  locally, you'll have to update your paths. The usual `require('highlight.js')`
-  works as before. This is contributed by [Dmitry Smolin][].
-
-New features:
-
-- Languages now can be recognized by multiple names like "js" for JavaScript or
-  "html" for, well, HTML (which earlier insisted on calling it "xml"). These
-  aliases can be specified in the class attribute of the code container in your
-  HTML as well as in various API calls. For now there are only a few very common
-  aliases but we'll expand it in the future. All of them are listed in the
-  [class reference][cr].
-
-- Language detection can now be restricted to a subset of languages relevant in
-  a given context — a web page or even a single highlighting call. This is
-  especially useful for node.js build that includes all the known languages.
-  Another example is a StackOverflow-style site where users specify languages
-  as tags rather than in the markdown-formatted code snippets. This is
-  documented in the [API reference][] (see methods `highlightAuto` and
-  `configure`).
-
-- Language definition syntax streamlined with [variants][] and
-  [beginKeywords][].
-
-New languages and styles:
-
-- *Oxygene* by [Carlo Kok][]
-- *Mathematica* by [Daniel Kvasnička][]
-- *Autohotkey* by [Seongwon Lee][]
-- *Atelier* family of styles in 10 variants by [Bram de Haan][]
-- *Paraíso* styles by [Jan T. Sott][]
-
-Miscellaneous improvements:
-
-- Highlighting `=>` prompts in Clojure.
-- [Jeremy Hull][] fixed a lot of styles for consistency.
-- Finally, highlighting PHP and HTML [mixed in peculiar ways][php-html].
-- Objective C and C# now properly highlight titles in method definition.
-- Big overhaul of relevance counting for a number of languages. Please do report
-  bugs about mis-detection of non-trivial code snippets!
-
-[API reference]: http://highlightjs.readthedocs.org/en/latest/api.html
-
-[cr]: http://highlightjs.readthedocs.org/en/latest/css-classes-reference.html
-[api docs]: http://highlightjs.readthedocs.org/en/latest/api.html
-[variants]: https://groups.google.com/d/topic/highlightjs/VoGC9-1p5vk/discussion
-[beginKeywords]: https://github.com/isagalaev/highlight.js/commit/6c7fdea002eb3949577a85b3f7930137c7c3038d
-[php-html]: https://twitter.com/highlightjs/status/408890903017689088
-
-[Carlo Kok]: https://github.com/carlokok
-[Bram de Haan]: https://github.com/atelierbram
-[Daniel Kvasnička]: https://github.com/dkvasnicka
-[Dmitry Smolin]: https://github.com/dimsmol
-[Jeremy Hull]: https://github.com/sourrust
-[Seongwon Lee]: https://github.com/dlimpid
-[Jan T. Sott]: https://github.com/idleberg
-
-
-## Version 7.5
-
-A catch-up release dealing with some of the accumulated contributions. This one
-is probably will be the last before the 8.0 which will be slightly backwards
-incompatible regarding some advanced use-cases.
-
-One outstanding change in this version is the addition of 6 languages to the
-[hosted script][d]: Markdown, ObjectiveC, CoffeeScript, Apache, Nginx and
-Makefile. It now weighs about 6K more but we're going to keep it under 30K.
-
-New languages:
-
-- OCaml by [Mehdi Dogguy][mehdid] and [Nicolas Braud-Santoni][nbraud]
-- [LiveCode Server][lcs] by [Ralf Bitter][revig]
-- Scilab by [Sylvestre Ledru][sylvestre]
-- basic support for Makefile by [Ivan Sagalaev][isagalaev]
-
-Improvements:
-
-- Ruby's got support for characters like `?A`, `?1`, `?\012` etc. and `%r{..}`
-  regexps.
-- Clojure now allows a function call in the beginning of s-expressions
-  `(($filter "myCount") (arr 1 2 3 4 5))`.
-- Haskell's got new keywords and now recognizes more things like pragmas,
-  preprocessors, modules, containers, FFIs etc. Thanks to [Zena Treep][treep]
-  for the implementation and to [Jeremy Hull][sourrust] for guiding it.
-- Miscellaneous fixes in PHP, Brainfuck, SCSS, Asciidoc, CMake, Python and F#.
-
-[mehdid]: https://github.com/mehdid
-[nbraud]: https://github.com/nbraud
-[revig]: https://github.com/revig
-[lcs]: http://livecode.com/developers/guides/server/
-[sylvestre]: https://github.com/sylvestre
-[isagalaev]: https://github.com/isagalaev
-[treep]: https://github.com/treep
-[sourrust]: https://github.com/sourrust
-[d]: http://highlightjs.org/download/
-
-
-## New core developers
-
-The latest long period of almost complete inactivity in the project coincided
-with growing interest to it led to a decision that now seems completely obvious:
-we need more core developers.
-
-So without further ado let me welcome to the core team two long-time
-contributors: [Jeremy Hull][] and [Oleg
-Efimov][].
-
-Hope now we'll be able to work through stuff faster!
-
-P.S. The historical commit is [here][1] for the record.
-
-[Jeremy Hull]: https://github.com/sourrust
-[Oleg Efimov]: https://github.com/sannis
-[1]: https://github.com/isagalaev/highlight.js/commit/f3056941bda56d2b72276b97bc0dd5f230f2473f
-
-
-## Version 7.4
-
-This long overdue version is a snapshot of the current source tree with all the
-changes that happened during the past year. Sorry for taking so long!
-
-Along with the changes in code highlight.js has finally got its new home at
-<http://highlightjs.org/>, moving from its cradle on Software Maniacs which it
-outgrew a long time ago. Be sure to report any bugs about the site to
-<mailto:info@highlightjs.org>.
-
-On to what's new…
-
-New languages:
-
-- Handlebars templates by [Robin Ward][]
-- Oracle Rules Language by [Jason Jacobson][]
-- F# by [Joans Follesø][]
-- AsciiDoc and Haml by [Dan Allen][]
-- Lasso by [Eric Knibbe][]
-- SCSS by [Kurt Emch][]
-- VB.NET by [Poren Chiang][]
-- Mizar by [Kelley van Evert][]
-
-[Robin Ward]: https://github.com/eviltrout
-[Jason Jacobson]: https://github.com/jayce7
-[Joans Follesø]: https://github.com/follesoe
-[Dan Allen]: https://github.com/mojavelinux
-[Eric Knibbe]: https://github.com/EricFromCanada
-[Kurt Emch]: https://github.com/kemch
-[Poren Chiang]: https://github.com/rschiang
-[Kelley van Evert]: https://github.com/kelleyvanevert
-
-New style themes:
-
-- Monokai Sublime by [noformnocontent][]
-- Railscasts by [Damien White][]
-- Obsidian by [Alexander Marenin][]
-- Docco by [Simon Madine][]
-- Mono Blue by [Ivan Sagalaev][] (uses a single color hue for everything)
-- Foundation by [Dan Allen][]
-
-[noformnocontent]: http://nn.mit-license.org/
-[Damien White]: https://github.com/visoft
-[Alexander Marenin]: https://github.com/ioncreature
-[Simon Madine]: https://github.com/thingsinjars
-[Ivan Sagalaev]: https://github.com/isagalaev
-
-Other notable changes:
-
-- Corrected many corner cases in CSS.
-- Dropped Python 2 version of the build tool.
-- Implemented building for the AMD format.
-- Updated Rust keywords (thanks to [Dmitry Medvinsky][]).
-- Literal regexes can now be used in language definitions.
-- CoffeeScript highlighting is now significantly more robust and rich due to
-  input from [Cédric Néhémie][].
-
-[Dmitry Medvinsky]: https://github.com/dmedvinsky
-[Cédric Néhémie]: https://github.com/abe33
-
-
-## Version 7.3
-
-- Since this version highlight.js no longer works in IE version 8 and older.
-  It's made it possible to reduce the library size and dramatically improve code
-  readability and made it easier to maintain. Time to go forward!
-
-- New languages: AppleScript (by [Nathan Grigg][ng] and [Dr. Drang][dd]) and
-  Brainfuck (by [Evgeny Stepanischev][bolk]).
-
-- Improvements to existing languages:
-
-    - interpreter prompt in Python (`>>>` and `...`)
-    - @-properties and classes in CoffeeScript
-    - E4X in JavaScript (by [Oleg Efimov][oe])
-    - new keywords in Perl (by [Kirk Kimmel][kk])
-    - big Ruby syntax update (by [Vasily Polovnyov][vast])
-    - small fixes in Bash
-
-- Also Oleg Efimov did a great job of moving all the docs for language and style
-  developers and contributors from the old wiki under the source code in the
-  "docs" directory. Now these docs are nicely presented at
-  <http://highlightjs.readthedocs.org/>.
-
-[ng]: https://github.com/nathan11g
-[dd]: https://github.com/drdrang
-[bolk]: https://github.com/bolknote
-[oe]: https://github.com/Sannis
-[kk]: https://github.com/kimmel
-[vast]: https://github.com/vast
-
-
-## Version 7.2
-
-A regular bug-fix release without any significant new features. Enjoy!
-
-
-## Version 7.1
-
-A Summer crop:
-
-- [Marc Fornos][mf] made the definition for Clojure along with the matching
-  style Rainbow (which, of course, works for other languages too).
-- CoffeeScript support continues to improve getting support for regular
-  expressions.
-- Yoshihide Jimbo ported to highlight.js [five Tomorrow styles][tm] from the
-  [project by Chris Kempson][tm0].
-- Thanks to [Casey Duncun][cd] the library can now be built in the popular
-  [AMD format][amd].
-- And last but not least, we've got a fair number of correctness and consistency
-  fixes, including a pretty significant refactoring of Ruby.
-
-[mf]: https://github.com/mfornos
-[tm]: http://jmblog.github.com/color-themes-for-highlightjs/
-[tm0]: https://github.com/ChrisKempson/Tomorrow-Theme
-[cd]: https://github.com/caseman
-[amd]: http://requirejs.org/docs/whyamd.html
-
-
-## Version 7.0
-
-The reason for the new major version update is a global change of keyword syntax
-which resulted in the library getting smaller once again. For example, the
-hosted build is 2K less than at the previous version while supporting two new
-languages.
-
-Notable changes:
-
-- The library now works not only in a browser but also with [node.js][]. It is
-  installable with `npm install highlight.js`. [API][] docs are available on our
-  wiki.
-
-- The new unique feature (apparently) among syntax highlighters is highlighting
-  *HTTP* headers and an arbitrary language in the request body. The most useful
-  languages here are *XML* and *JSON* both of which highlight.js does support.
-  Here's [the detailed post][p] about the feature.
-
-- Two new style themes: a dark "south" *[Pojoaque][]* by Jason Tate and an
-  emulation of*XCode* IDE by [Angel Olloqui][ao].
-
-- Three new languages: *D* by [Aleksandar Ružičić][ar], *R* by [Joe Cheng][jc]
-  and *GLSL* by [Sergey Tikhomirov][st].
-
-- *Nginx* syntax has become a million times smaller and more universal thanks to
-  remaking it in a more generic manner that doesn't require listing all the
-  directives in the known universe.
-
-- Function titles are now highlighted in *PHP*.
-
-- *Haskell* and *VHDL* were significantly reworked to be more rich and correct
-  by their respective maintainers [Jeremy Hull][sr] and [Igor Kalnitsky][ik].
-
-And last but not least, many bugs have been fixed around correctness and
-language detection.
-
-Overall highlight.js currently supports 51 languages and 20 style themes.
-
-[node.js]: http://nodejs.org/
-[api]: http://softwaremaniacs.org/wiki/doku.php/highlight.js:api
-[p]: http://softwaremaniacs.org/blog/2012/05/10/http-and-json-in-highlight-js/en/
-[pojoaque]: http://web-cms-designs.com/ftopict-10-pojoaque-style-for-highlight-js-code-highlighter.html
-[ao]: https://github.com/angelolloqui
-[ar]: https://github.com/raleksandar
-[jc]: https://github.com/jcheng5
-[st]: https://github.com/tikhomirov
-[sr]: https://github.com/sourrust
-[ik]: https://github.com/ikalnitsky
-
-
-## Version 6.2
-
-A lot of things happened in highlight.js since the last version! We've got nine
-new contributors, the discussion group came alive, and the main branch on GitHub
-now counts more than 350 followers. Here are most significant results coming
-from all this activity:
-
-- 5 (five!) new languages: Rust, ActionScript, CoffeeScript, MatLab and
-  experimental support for markdown. Thanks go to [Andrey Vlasovskikh][av],
-  [Alexander Myadzel][am], [Dmytrii Nagirniak][dn], [Oleg Efimov][oe], [Denis
-  Bardadym][db] and [John Crepezzi][jc].
-
-- 2 new style themes: Monokai by [Luigi Maselli][lm] and stylistic imitation of
-  another well-known highlighter Google Code Prettify by [Aahan Krish][ak].
-
-- A vast number of [correctness fixes and code refactorings][log], mostly made
-  by [Oleg Efimov][oe] and [Evgeny Stepanischev][es].
-
-[av]: https://github.com/vlasovskikh
-[am]: https://github.com/myadzel
-[dn]: https://github.com/dnagir
-[oe]: https://github.com/Sannis
-[db]: https://github.com/btd
-[jc]: https://github.com/seejohnrun
-[lm]: http://grigio.org/
-[ak]: https://github.com/geekpanth3r
-[es]: https://github.com/bolknote
-[log]: https://github.com/isagalaev/highlight.js/commits/
-
-
-## Version 6.1 — Solarized
-
-[Jeremy Hull][jh] has implemented my dream feature — a port of [Solarized][]
-style theme famous for being based on the intricate color theory to achieve
-correct contrast and color perception. It is now available for highlight.js in
-both variants — light and dark.
-
-This version also adds a new original style Arta. Its author pumbur maintains a
-[heavily modified fork of highlight.js][pb] on GitHub.
-
-[jh]: https://github.com/sourrust
-[solarized]: http://ethanschoonover.com/solarized
-[pb]: https://github.com/pumbur/highlight.js
-
-
-## Version 6.0
-
-New major version of the highlighter has been built on a significantly
-refactored syntax. Due to this it's even smaller than the previous one while
-supporting more languages!
-
-New languages are:
-
-- Haskell by [Jeremy Hull][sourrust]
-- Erlang in two varieties — module and REPL — made collectively by [Nikolay
-  Zakharov][desh], [Dmitry Kovega][arhibot] and [Sergey Ignatov][ignatov]
-- Objective C by [Valerii Hiora][vhbit]
-- Vala by [Antono Vasiljev][antono]
-- Go by [Stephan Kountso][steplg]
-
-[sourrust]: https://github.com/sourrust
-[desh]: http://desh.su/
-[arhibot]: https://github.com/arhibot
-[ignatov]: https://github.com/ignatov
-[vhbit]: https://github.com/vhbit
-[antono]: https://github.com/antono
-[steplg]: https://github.com/steplg
-
-Also this version is marginally faster and fixes a number of small long-standing
-bugs.
-
-Developer overview of the new language syntax is available in a [blog post about
-recent beta release][beta].
-
-[beta]: http://softwaremaniacs.org/blog/2011/04/25/highlight-js-60-beta/en/
-
-P.S. New version is not yet available on a Yandex CDN, so for now you have to
-download [your own copy][d].
-
-[d]: /soft/highlight/en/download/
-
-
-## Version 5.14
-
-Fixed bugs in HTML/XML detection and relevance introduced in previous
-refactoring.
-
-Also test.html now shows the second best result of language detection by
-relevance.
-
-
-## Version 5.13
-
-Past weekend began with a couple of simple additions for existing languages but
-ended up in a big code refactoring bringing along nice improvements for language
-developers.
-
-### For users
-
-- Description of C++ has got new keywords from the upcoming [C++ 0x][] standard.
-- Description of HTML has got new tags from [HTML 5][].
-- CSS-styles have been unified to use consistent padding and also have lost
-  pop-outs with names of detected languages.
-- [Igor Kalnitsky][ik] has sent two new language descriptions: CMake & VHDL.
-
-This makes total number of languages supported by highlight.js to reach 35.
-
-Bug fixes:
-
-- Custom classes on `<pre>` tags are not being overridden anymore
-- More correct highlighting of code blocks inside non-`<pre>` containers:
-  highlighter now doesn't insist on replacing them with its own container and
-  just replaces the contents.
-- Small fixes in browser compatibility and heuristics.
-
-[c++ 0x]: http://ru.wikipedia.org/wiki/C%2B%2B0x
-[html 5]: http://en.wikipedia.org/wiki/HTML5
-[ik]: http://kalnitsky.org.ua/
-
-### For developers
-
-The most significant change is the ability to include language submodes right
-under `contains` instead of defining explicit named submodes in the main array:
-
-    contains: [
-      'string',
-      'number',
-      {begin: '\\n', end: hljs.IMMEDIATE_RE}
-    ]
-
-This is useful for auxiliary modes needed only in one place to define parsing.
-Note that such modes often don't have `className` and hence won't generate a
-separate `<span>` in the resulting markup. This is similar in effect to
-`noMarkup: true`. All existing languages have been refactored accordingly.
-
-Test file test.html has at last become a real test. Now it not only puts the
-detected language name under the code snippet but also tests if it matches the
-expected one. Test summary is displayed right above all language snippets.
-
-
-## CDN
-
-Fine people at [Yandex][] agreed to host highlight.js on their big fast servers.
-[Link up][l]!
-
-[yandex]: http://yandex.com/
-[l]: http://softwaremaniacs.org/soft/highlight/en/download/
-
-
-## Version 5.10 — "Paris".
-
-Though I'm on a vacation in Paris, I decided to release a new version with a
-couple of small fixes:
-
-- Tomas Vitvar discovered that TAB replacement doesn't always work when used
-  with custom markup in code
-- SQL parsing is even more rigid now and doesn't step over SmallTalk in tests
-
-
-## Version 5.9
-
-A long-awaited version is finally released.
-
-New languages:
-
-- Andrew Fedorov made a definition for Lua
-- a long-time highlight.js contributor [Peter Leonov][pl] made a definition for
-  Nginx config
-- [Vladimir Moskva][vm] made a definition for TeX
-
-[pl]: http://kung-fu-tzu.ru/
-[vm]: http://fulc.ru/
-
-Fixes for existing languages:
-
-- [Loren Segal][ls] reworked the Ruby definition and added highlighting for
-  [YARD][] inline documentation
-- the definition of SQL has become more solid and now it shouldn't be overly
-  greedy when it comes to language detection
-
-[ls]: http://gnuu.org/
-[yard]: http://yardoc.org/
-
-The highlighter has become more usable as a library allowing to do highlighting
-from initialization code of JS frameworks and in ajax methods (see.
-readme.eng.txt).
-
-Also this version drops support for the [WordPress][wp] plugin. Everyone is
-welcome to [pick up its maintenance][p] if needed.
-
-[wp]: http://wordpress.org/
-[p]: http://bazaar.launchpad.net/~isagalaev/+junk/highlight/annotate/342/src/wp_highlight.js.php
-
-
-## Version 5.8
-
-- Jan Berkel has contributed a definition for Scala. +1 to hotness!
-- All CSS-styles are rewritten to work only inside `<pre>` tags to avoid
-  conflicts with host site styles.
-
-
-## Version 5.7.
-
-Fixed escaping of quotes in VBScript strings.
-
-
-## Version 5.5
-
-This version brings a small change: now .ini-files allow digits, underscores and
-square brackets in key names.
-
-
-## Version 5.4
-
-Fixed small but upsetting bug in the packer which caused incorrect highlighting
-of explicitly specified languages. Thanks to Andrew Fedorov for precise
-diagnostics!
-
-
-## Version 5.3
-
-The version to fulfil old promises.
-
-The most significant change is that highlight.js now preserves custom user
-markup in code along with its own highlighting markup. This means that now it's
-possible to use, say, links in code. Thanks to [Vladimir Dolzhenko][vd] for the
-[initial proposal][1] and for making a proof-of-concept patch.
-
-Also in this version:
-
-- [Vasily Polovnyov][vp] has sent a GitHub-like style and has implemented
-  support for CSS @-rules and Ruby symbols.
-- Yura Zaripov has sent two styles: Brown Paper and School Book.
-- Oleg Volchkov has sent a definition for [Parser 3][p3].
-
-[1]: http://softwaremaniacs.org/forum/highlightjs/6612/
-[p3]: http://www.parser.ru/
-[vp]: http://vasily.polovnyov.ru/
-[vd]: http://dolzhenko.blogspot.com/
-
-
-## Version 5.2
-
-- at last it's possible to replace indentation TABs with something sensible
-  (e.g. 2 or 4 spaces)
-- new keywords and built-ins for 1C by Sergey Baranov
-- a couple of small fixes to Apache highlighting
-
-
-## Version 5.1
-
-This is one of those nice version consisting entirely of new and shiny
-contributions!
-
-- [Vladimir Ermakov][vooon] created highlighting for AVR Assembler
-- [Ruslan Keba][rukeba] created highlighting for Apache config file. Also his
-  original visual style for it is now available for all highlight.js languages
-  under the name "Magula".
-- [Shuen-Huei Guan][drake] (aka Drake) sent new keywords for RenderMan
-  languages. Also thanks go to [Konstantin Evdokimenko][ke] for his advice on
-  the matter.
-
-[vooon]: http://vehq.ru/about/
-[rukeba]: http://rukeba.com/
-[drake]: http://drakeguan.org/
-[ke]: http://k-evdokimenko.moikrug.ru/
-
-
-## Version 5.0
-
-The main change in the new major version of highlight.js is a mechanism for
-packing several languages along with the library itself into a single compressed
-file. Now sites using several languages will load considerably faster because
-the library won't dynamically include additional files while loading.
-
-Also this version fixes a long-standing bug with Javascript highlighting that
-couldn't distinguish between regular expressions and division operations.
-
-And as usually there were a couple of minor correctness fixes.
-
-Great thanks to all contributors! Keep using highlight.js.
-
-
-## Version 4.3
-
-This version comes with two contributions from [Jason Diamond][jd]:
-
-- language definition for C# (yes! it was a long-missed thing!)
-- Visual Studio-like highlighting style
-
-Plus there are a couple of minor bug fixes for parsing HTML and XML attributes.
-
-[jd]: http://jason.diamond.name/weblog/
-
-
-## Version 4.2
-
-The biggest news is highlighting for Lisp, courtesy of Vasily Polovnyov. It's
-somewhat experimental meaning that for highlighting "keywords" it doesn't use
-any pre-defined set of a Lisp dialect. Instead it tries to highlight first word
-in parentheses wherever it makes sense. I'd like to ask people programming in
-Lisp to confirm if it's a good idea and send feedback to [the forum][f].
-
-Other changes:
-
-- Smalltalk was excluded from DEFAULT_LANGUAGES to save traffic
-- [Vladimir Epifanov][voldmar] has implemented javascript style switcher for
-  test.html
-- comments now allowed inside Ruby function definition
-- [MEL][] language from [Shuen-Huei Guan][drake]
-- whitespace now allowed between `<pre>` and `<code>`
-- better auto-detection of C++ and PHP
-- HTML allows embedded VBScript (`<% .. %>`)
-
-[f]: http://softwaremaniacs.org/forum/highlightjs/
-[voldmar]: http://voldmar.ya.ru/
-[mel]: http://en.wikipedia.org/wiki/Maya_Embedded_Language
-[drake]: http://drakeguan.org/
-
-
-## Version 4.1
-
-Languages:
-
-- Bash from Vah
-- DOS bat-files from Alexander Makarov (Sam)
-- Diff files from Vasily Polovnyov
-- Ini files from myself though initial idea was from Sam
-
-Styles:
-
-- Zenburn from Vladimir Epifanov, this is an imitation of a
-  [well-known theme for Vim][zenburn].
-- Ascetic from myself, as a realization of ideals of non-flashy highlighting:
-  just one color in only three gradations :-)
-
-In other news. [One small bug][bug] was fixed, built-in keywords were added for
-Python and C++ which improved auto-detection for the latter (it was shame that
-[my wife's blog][alenacpp] had issues with it from time to time). And lastly
-thanks go to Sam for getting rid of my stylistic comments in code that were
-getting in the way of [JSMin][].
-
-[zenburn]: http://en.wikipedia.org/wiki/Zenburn
-[alenacpp]: http://alenacpp.blogspot.com/
-[bug]: http://softwaremaniacs.org/forum/viewtopic.php?id=1823
-[jsmin]: http://code.google.com/p/jsmin-php/
-
-
-## Version 4.0
-
-New major version is a result of vast refactoring and of many contributions.
-
-Visible new features:
-
-- Highlighting of embedded languages. Currently is implemented highlighting of
-  Javascript and CSS inside HTML.
-- Bundled 5 ready-made style themes!
-
-Invisible new features:
-
-- Highlight.js no longer pollutes global namespace. Only one object and one
-  function for backward compatibility.
-- Performance is further increased by about 15%.
-
-Changing of a major version number caused by a new format of language definition
-files. If you use some third-party language files they should be updated.
-
-
-## Version 3.5
-
-A very nice version in my opinion fixing a number of small bugs and slightly
-increased speed in a couple of corner cases. Thanks to everybody who reports
-bugs in he [forum][f] and by email!
-
-There is also a new language — XML. A custom XML formerly was detected as HTML
-and didn't highlight custom tags. In this version I tried to make custom XML to
-be detected and highlighted by its own rules. Which by the way include such
-things as CDATA sections and processing instructions (`<? ... ?>`).
-
-[f]: http://softwaremaniacs.org/forum/viewforum.php?id=6
-
-
-## Version 3.3
-
-[Vladimir Gubarkov][xonix] has provided an interesting and useful addition.
-File export.html contains a little program that shows and allows to copy and
-paste an HTML code generated by the highlighter for any code snippet. This can
-be useful in situations when one can't use the script itself on a site.
-
-
-[xonix]: http://xonixx.blogspot.com/
-
-
-## Version 3.2 consists completely of contributions:
-
-- Vladimir Gubarkov has described SmallTalk
-- Yuri Ivanov has described 1C
-- Peter Leonov has packaged the highlighter as a Firefox extension
-- Vladimir Ermakov has compiled a mod for phpBB
-
-Many thanks to you all!
-
-
-## Version 3.1
-
-Three new languages are available: Django templates, SQL and Axapta. The latter
-two are sent by [Dmitri Roudakov][1]. However I've almost entirely rewrote an
-SQL definition but I'd never started it be it from the ground up :-)
-
-The engine itself has got a long awaited feature of grouping keywords
-("keyword", "built-in function", "literal"). No more hacks!
-
-[1]: http://roudakov.ru/
-
-
-## Version 3.0
-
-It is major mainly because now highlight.js has grown large and has become
-modular. Now when you pass it a list of languages to highlight it will
-dynamically load into a browser only those languages.
-
-Also:
-
-- Konstantin Evdokimenko of [RibKit][] project has created a highlighting for
-  RenderMan Shading Language and RenderMan Interface Bytestream. Yay for more
-  languages!
-- Heuristics for C++ and HTML got better.
-- I've implemented (at last) a correct handling of backslash escapes in C-like
-  languages.
-
-There is also a small backwards incompatible change in the new version. The
-function initHighlighting that was used to initialize highlighting instead of
-initHighlightingOnLoad a long time ago no longer works. If you by chance still
-use it — replace it with the new one.
-
-[RibKit]: http://ribkit.sourceforge.net/
-
-
-## Version 2.9
-
-Highlight.js is a parser, not just a couple of regular expressions. That said
-I'm glad to announce that in the new version 2.9 has support for:
-
-- in-string substitutions for Ruby -- `#{...}`
-- strings from from numeric symbol codes (like #XX) for Delphi
-
-
-## Version 2.8
-
-A maintenance release with more tuned heuristics. Fully backwards compatible.
-
-
-## Version 2.7
-
-- Nikita Ledyaev presents highlighting for VBScript, yay!
-- A couple of bugs with escaping in strings were fixed thanks to Mickle
-- Ongoing tuning of heuristics
-
-Fixed bugs were rather unpleasant so I encourage everyone to upgrade!
-
-
-## Version 2.4
-
-- Peter Leonov provides another improved highlighting for Perl
-- Javascript gets a new kind of keywords — "literals". These are the words
-  "true", "false" and "null"
-
-Also highlight.js homepage now lists sites that use the library. Feel free to
-add your site by [dropping me a message][mail] until I find the time to build a
-submit form.
-
-[mail]: mailto:Maniac@SoftwareManiacs.Org
-
-
-## Version 2.3
-
-This version fixes IE breakage in previous version. My apologies to all who have
-already downloaded that one!
-
-
-## Version 2.2
-
-- added highlighting for Javascript
-- at last fixed parsing of Delphi's escaped apostrophes in strings
-- in Ruby fixed highlighting of keywords 'def' and 'class', same for 'sub' in
-  Perl
-
-
-## Version 2.0
-
-- Ruby support by [Anton Kovalyov][ak]
-- speed increased by orders of magnitude due to new way of parsing
-- this same way allows now correct highlighting of keywords in some tricky
-  places (like keyword "End" at the end of Delphi classes)
-
-[ak]: http://anton.kovalyov.net/
-
-
-## Version 1.0
-
-Version 1.0 of javascript syntax highlighter is released!
-
-It's the first version available with English description. Feel free to post
-your comments and question to [highlight.js forum][forum]. And don't be afraid
-if you find there some fancy Cyrillic letters -- it's for Russian users too :-)
-
-[forum]: http://softwaremaniacs.org/forum/viewforum.php?id=6
diff --git a/src/javadoc/js/highlight-8.6-java/LICENSE b/src/javadoc/js/highlight-8.6-java/LICENSE
deleted file mode 100644
index 422deb7350..0000000000
--- a/src/javadoc/js/highlight-8.6-java/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-Copyright (c) 2006, Ivan Sagalaev
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of highlight.js nor the names of its contributors 
-      may be used to endorse or promote products derived from this software 
-      without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/javadoc/js/highlight-8.6-java/README.md b/src/javadoc/js/highlight-8.6-java/README.md
deleted file mode 100644
index f29f1b1723..0000000000
--- a/src/javadoc/js/highlight-8.6-java/README.md
+++ /dev/null
@@ -1,101 +0,0 @@
-# Highlight.js
-
-[![Build Status](https://travis-ci.org/isagalaev/highlight.js.svg?branch=master)](https://travis-ci.org/isagalaev/highlight.js)
-
-Highlight.js is a syntax highlighter written in JavaScript. It works in the
-browser as well as on the server. It works with pretty much any markup,
-doesn’t depend on any framework and has automatic language detection.
-
-
-## Getting Started
-
-The bare minimum for using highlight.js on a web page is linking to the library
-along with one of the styles and calling [`initHighlightingOnLoad`][1]:
-
-```html
-<link rel="stylesheet" href="/path/to/styles/default.css">
-<script src="/path/to/highlight.pack.js"></script>
-<script>hljs.initHighlightingOnLoad();</script>
-```
-
-This will find and highlight code inside of `<pre><code>` tags; it tries to detect
-the language automatically. If automatic detection doesn’t work for you, you can
-specify the language in the `class` attribute:
-
-```html
-<pre><code class="html">...</code></pre>
-```
-
-The list of supported language classes is available in the [class reference][8].
-Classes can also be prefixed with either `language-` or `lang-`.
-
-To disable highlighting altogether use the `nohighlight` class:
-
-```html
-<pre><code class="nohighlight">...</code></pre>
-```
-
-## Custom Initialization
-
-When you need a bit more control over the initialization of
-highlight.js, you can use the [`highlightBlock`][2] and [`configure`][3]
-functions. This allows you to control *what* to highlight and *when*.
-
-Here’s an equivalent way to calling [`initHighlightingOnLoad`][1] using jQuery:
-
-```javascript
-$(document).ready(function() {
-  $('pre code').each(function(i, block) {
-    hljs.highlightBlock(block);
-  });
-});
-```
-
-You can use any tags instead of `<pre><code>` to mark up your code. If you don't
-use a container that preserve line breaks you will need to configure
-highlight.js to use the `<br>` tag:
-
-```javascript
-hljs.configure({useBR: true});
-
-$('div.code').each(function(i, block) {
-  hljs.highlightBlock(block);
-});
-```
-
-For other options refer to the documentation for [`configure`][3].
-
-
-## Getting the Library
-
-You can get highlight.js as a hosted or custom-build browser script or as a
-server module. Head over to the [download page][4] for all the options.
-
-**Note:** the library is not supposed to work straight from the source on
-GitHub; it requires building. If none of the pre-packaged options work for you
-refer to the [building documentation][5].
-
-
-## License
-
-Highlight.js is released under the BSD License. See [LICENSE][10] file for
-details.
-
-
-## Links
-
-The official site for the library is at <https://highlightjs.org/>.
-
-Further in-depth documentation for the API and other topics is at
-<http://highlightjs.readthedocs.org/>.
-
-Authors and contributors are listed in the [AUTHORS.en.txt][9] file.
-
-[1]: http://highlightjs.readthedocs.org/en/latest/api.html#inithighlightingonload
-[2]: http://highlightjs.readthedocs.org/en/latest/api.html#highlightblock-block
-[3]: http://highlightjs.readthedocs.org/en/latest/api.html#configure-options
-[4]: https://highlightjs.org/download/
-[5]: http://highlightjs.readthedocs.org/en/latest/building-testing.html
-[8]: http://highlightjs.readthedocs.org/en/latest/css-classes-reference.html
-[9]: https://github.com/isagalaev/highlight.js/blob/master/AUTHORS.en.txt
-[10]: https://github.com/isagalaev/highlight.js/blob/master/LICENSE
diff --git a/src/javadoc/js/highlight-8.6-java/README.ru.md b/src/javadoc/js/highlight-8.6-java/README.ru.md
deleted file mode 100644
index 198c029329..0000000000
--- a/src/javadoc/js/highlight-8.6-java/README.ru.md
+++ /dev/null
@@ -1,101 +0,0 @@
-# Highlight.js
-
-Highlight.js — это подсветчик синтаксиса, написанный на JavaScript. Он работает
-и в браузере, и на сервере. Он работает с практически любой HTML разметкой, не
-зависит от каких-либо фреймворков и умеет автоматически определять язык.
-
-
-## Начало работы
-
-Минимум, что нужно сделать для использования highlight.js на веб-странице — это
-подключить библиотеку, CSS-стили и вызывать [`initHighlightingOnLoad`][1]:
-
-```html
-<link rel="stylesheet" href="/path/to/styles/default.css">
-<script src="/path/to/highlight.pack.js"></script>
-<script>hljs.initHighlightingOnLoad();</script>
-```
-
-Библиотека найдёт и раскрасит код внутри тегов `<pre><code>`, попытавшись
-автоматически определить язык. Когда автоопределение не срабатывает, можно явно
-указать язык в атрибуте class:
-
-```html
-<pre><code class="html">...</code></pre>
-```
-
-Список поддерживаемых классов языков доступен в [справочнике по классам][8].
-Класс также можно предваоить префиксами `language-` или `lang-`.
-
-Чтобы отключить подсветку для какого-то блока, используйте класс `nohighlight`:
-
-```html
-<pre><code class="nohighlight">...</code></pre>
-```
-
-## Инициализация вручную
-
-Чтобы иметь чуть больше контроля за инициализацией подсветки, вы можете
-использовать функции [`highlightBlock`][2] и [`configure`][3]. Таким образом
-можно управлять тем, *что* подсвечивать и *когда*.
-
-Вот пример инициализация, эквивалентной вызову [`initHighlightingOnLoad`][1], но
-с использованием jQuery:
-
-```javascript
-$(document).ready(function() {
-  $('pre code').each(function(i, block) {
-    hljs.highlightBlock(block);
-  });
-});
-```
-
-Вы можете использовать любые теги разметки вместо `<pre><code>`. Если
-используете контейнер, не сохраняющий переводы строк, вам нужно сказать
-highlight.js использовать для них тег `<br>`:
-
-```javascript
-hljs.configure({useBR: true});
-
-$('div.code').each(function(i, block) {
-  hljs.highlightBlock(block);
-});
-```
-
-Другие опции можно найти в документации функции [`configure`][3].
-
-
-## Установка библиотеки
-
-Highlight.js можно использовать в браузере прямо с CDN хостинга или скачать
-индивидуальную сборку, а также установив модуль на сервере. На
-[страница загрузки][4] подробно описаны все варианты.
-
-Обратите внимание, что библиотека не предназначена для использования в виде
-исходного кода на GitHub, а требует отдельной сборки. Если вам не подходит ни
-один из готовых вариантов, читайте [документацию по сборке][5].
-
-
-## Лицензия
-
-Highlight.js распространяется под лицензией BSD. Подробнее читайте файл
-[LICENSE][10].
-
-
-## Ссылки
-
-Официальный сайт билиотеки расположен по адресу <https://highlightjs.org/>.
-
-Более подробная документация по API и другим темам расположена на
-<http://highlightjs.readthedocs.org/>.
-
-Авторы и контрибьютора перечислена в файле [AUTHORS.ru.txt][9] file.
-
-[1]: http://highlightjs.readthedocs.org/en/latest/api.html#inithighlightingonload
-[2]: http://highlightjs.readthedocs.org/en/latest/api.html#highlightblock-block
-[3]: http://highlightjs.readthedocs.org/en/latest/api.html#configure-options
-[4]: https://highlightjs.org/download/
-[5]: http://highlightjs.readthedocs.org/en/latest/building-testing.html
-[8]: http://highlightjs.readthedocs.org/en/latest/css-classes-reference.html
-[9]: https://github.com/isagalaev/highlight.js/blob/master/AUTHORS.ru.txt
-[10]: https://github.com/isagalaev/highlight.js/blob/master/LICENSE
diff --git a/src/javadoc/js/highlight-8.6-java/highlight.pack.js b/src/javadoc/js/highlight-8.6-java/highlight.pack.js
deleted file mode 100644
index 4e7265932b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/highlight.pack.js
+++ /dev/null
@@ -1 +0,0 @@
-!function(e){"undefined"!=typeof exports?e(exports):(window.hljs=e({}),"function"==typeof define&&define.amd&&define("hljs",[],function(){return window.hljs}))}(function(e){function n(e){return e.replace(/&/gm,"&amp;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;")}function t(e){return e.nodeName.toLowerCase()}function r(e,n){var t=e&&e.exec(n);return t&&0==t.index}function a(e){return/no-?highlight|plain|text/.test(e)}function i(e){var n,t,r,i=e.className+" ";if(i+=e.parentNode?e.parentNode.className:"",t=/\blang(?:uage)?-([\w-]+)\b/.exec(i))return E(t[1])?t[1]:"no-highlight";for(i=i.split(/\s+/),n=0,r=i.length;r>n;n++)if(E(i[n])||a(i[n]))return i[n]}function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t];return r}function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i=i.nextSibling)3==i.nodeType?a+=i.nodeValue.length:1==i.nodeType&&(n.push({event:"start",offset:a,node:i}),a=r(i,a),t(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:i}));return a}(e,0),n}function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!=r[0].offset?e[0].offset<r[0].offset?e:r:"start"==r[0].event?e:r:e.length?e:r}function o(e){function r(e){return" "+e.nodeName+'="'+n(e.value)+'"'}f+="<"+t(e)+Array.prototype.map.call(e.attributes,r).join("")+">"}function u(e){f+="</"+t(e)+">"}function c(e){("start"==e.event?o:u)(e.node)}for(var s=0,f="",l=[];e.length||r.length;){var g=i();if(f+=n(a.substr(s,g[0].offset-s)),s=g[0].offset,g==e){l.reverse().forEach(u);do c(g.splice(0,1)[0]),g=i();while(g==e&&g.length&&g[0].offset==s);l.reverse().forEach(o)}else"start"==g[0].event?l.push(g[0].node):l.pop(),c(g.splice(0,1)[0])}return f+n(a.substr(s))}function s(e){function n(e){return e&&e.source||e}function t(t,r){return new RegExp(n(t),"m"+(e.cI?"i":"")+(r?"g":""))}function r(a,i){if(!a.compiled){if(a.compiled=!0,a.k=a.k||a.bK,a.k){var u={},c=function(n,t){e.cI&&(t=t.toLowerCase()),t.split(" ").forEach(function(e){var t=e.split("|");u[t[0]]=[n,t[1]?Number(t[1]):1]})};"string"==typeof a.k?c("keyword",a.k):Object.keys(a.k).forEach(function(e){c(e,a.k[e])}),a.k=u}a.lR=t(a.l||/\b\w+\b/,!0),i&&(a.bK&&(a.b="\\b("+a.bK.split(" ").join("|")+")\\b"),a.b||(a.b=/\B|\b/),a.bR=t(a.b),a.e||a.eW||(a.e=/\B|\b/),a.e&&(a.eR=t(a.e)),a.tE=n(a.e)||"",a.eW&&i.tE&&(a.tE+=(a.e?"|":"")+i.tE)),a.i&&(a.iR=t(a.i)),void 0===a.r&&(a.r=1),a.c||(a.c=[]);var s=[];a.c.forEach(function(e){e.v?e.v.forEach(function(n){s.push(o(e,n))}):s.push("self"==e?a:e)}),a.c=s,a.c.forEach(function(e){r(e,a)}),a.starts&&r(a.starts,i);var f=a.c.map(function(e){return e.bK?"\\.?("+e.b+")\\.?":e.b}).concat([a.tE,a.i]).map(n).filter(Boolean);a.t=f.length?t(f.join("|"),!0):{exec:function(){return null}}}}r(e)}function f(e,t,a,i){function o(e,n){for(var t=0;t<n.c.length;t++)if(r(n.c[t].bR,e))return n.c[t]}function u(e,n){if(r(e.eR,n)){for(;e.endsParent&&e.parent;)e=e.parent;return e}return e.eW?u(e.parent,n):void 0}function c(e,n){return!a&&r(n.iR,e)}function g(e,n){var t=N.cI?n[0].toLowerCase():n[0];return e.k.hasOwnProperty(t)&&e.k[t]}function h(e,n,t,r){var a=r?"":w.classPrefix,i='<span class="'+a,o=t?"":"</span>";return i+=e+'">',i+n+o}function p(){if(!L.k)return n(B);var e="",t=0;L.lR.lastIndex=0;for(var r=L.lR.exec(B);r;){e+=n(B.substr(t,r.index-t));var a=g(L,r);a?(y+=a[1],e+=h(a[0],n(r[0]))):e+=n(r[0]),t=L.lR.lastIndex,r=L.lR.exec(B)}return e+n(B.substr(t))}function d(){if(L.sL&&!x[L.sL])return n(B);var e=L.sL?f(L.sL,B,!0,M[L.sL]):l(B);return L.r>0&&(y+=e.r),"continuous"==L.subLanguageMode&&(M[L.sL]=e.top),h(e.language,e.value,!1,!0)}function b(){return void 0!==L.sL?d():p()}function v(e,t){var r=e.cN?h(e.cN,"",!0):"";e.rB?(k+=r,B=""):e.eB?(k+=n(t)+r,B=""):(k+=r,B=t),L=Object.create(e,{parent:{value:L}})}function m(e,t){if(B+=e,void 0===t)return k+=b(),0;var r=o(t,L);if(r)return k+=b(),v(r,t),r.rB?0:t.length;var a=u(L,t);if(a){var i=L;i.rE||i.eE||(B+=t),k+=b();do L.cN&&(k+="</span>"),y+=L.r,L=L.parent;while(L!=a.parent);return i.eE&&(k+=n(t)),B="",a.starts&&v(a.starts,""),i.rE?0:t.length}if(c(t,L))throw new Error('Illegal lexeme "'+t+'" for mode "'+(L.cN||"<unnamed>")+'"');return B+=t,t.length||1}var N=E(e);if(!N)throw new Error('Unknown language: "'+e+'"');s(N);var R,L=i||N,M={},k="";for(R=L;R!=N;R=R.parent)R.cN&&(k=h(R.cN,"",!0)+k);var B="",y=0;try{for(var C,j,I=0;;){if(L.t.lastIndex=I,C=L.t.exec(t),!C)break;j=m(t.substr(I,C.index-I),C[0]),I=C.index+j}for(m(t.substr(I)),R=L;R.parent;R=R.parent)R.cN&&(k+="</span>");return{r:y,value:k,language:e,top:L}}catch(O){if(-1!=O.message.indexOf("Illegal"))return{r:0,value:n(t)};throw O}}function l(e,t){t=t||w.languages||Object.keys(x);var r={r:0,value:n(e)},a=r;return t.forEach(function(n){if(E(n)){var t=f(n,e,!1);t.language=n,t.r>a.r&&(a=t),t.r>r.r&&(a=r,r=t)}}),a.language&&(r.second_best=a),r}function g(e){return w.tabReplace&&(e=e.replace(/^((<[^>]+>|\t)+)/gm,function(e,n){return n.replace(/\t/g,w.tabReplace)})),w.useBR&&(e=e.replace(/\n/g,"<br>")),e}function h(e,n,t){var r=n?R[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)||a.push("hljs"),-1===e.indexOf(r)&&a.push(r),a.join(" ").trim()}function p(e){var n=i(e);if(!a(n)){var t;w.useBR?(t=document.createElementNS("http://www.w3.org/1999/xhtml","div"),t.innerHTML=e.innerHTML.replace(/\n/g,"").replace(/<br[ \/]*>/g,"\n")):t=e;var r=t.textContent,o=n?f(n,r,!0):l(r),s=u(t);if(s.length){var p=document.createElementNS("http://www.w3.org/1999/xhtml","div");p.innerHTML=o.value,o.value=c(s,u(p),r)}o.value=g(o.value),e.innerHTML=o.value,e.className=h(e.className,n,o.language),e.result={language:o.language,re:o.r},o.second_best&&(e.second_best={language:o.second_best.language,re:o.second_best.r})}}function d(e){w=o(w,e)}function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("pre code");Array.prototype.forEach.call(e,p)}}function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener("load",b,!1)}function m(n,t){var r=x[n]=t(e);r.aliases&&r.aliases.forEach(function(e){R[e]=n})}function N(){return Object.keys(x)}function E(e){return x[e]||x[R[e]]}var w={classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:void 0},x={},R={};return e.highlight=f,e.highlightAuto=l,e.fixMarkup=g,e.highlightBlock=p,e.configure=d,e.initHighlighting=b,e.initHighlightingOnLoad=v,e.registerLanguage=m,e.listLanguages=N,e.getLanguage=E,e.inherit=o,e.IR="[a-zA-Z]\\w*",e.UIR="[a-zA-Z_]\\w*",e.NR="\\b\\d+(\\.\\d+)?",e.CNR="\\b(0[xX][a-fA-F0-9]+|(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",e.BNR="\\b(0b[01]+)",e.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",e.BE={b:"\\\\[\\s\\S]",r:0},e.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[e.BE]},e.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[e.BE]},e.PWM={b:/\b(a|an|the|are|I|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such)\b/},e.C=function(n,t,r){var a=e.inherit({cN:"comment",b:n,e:t,c:[]},r||{});return a.c.push(e.PWM),a.c.push({cN:"doctag",bK:"TODO FIXME NOTE BUG XXX",r:0}),a},e.CLCM=e.C("//","$"),e.CBCM=e.C("/\\*","\\*/"),e.HCM=e.C("#","$"),e.NM={cN:"number",b:e.NR,r:0},e.CNM={cN:"number",b:e.CNR,r:0},e.BNM={cN:"number",b:e.BNR,r:0},e.CSSNM={cN:"number",b:e.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0},e.RM={cN:"regexp",b:/\//,e:/\/[gimuy]*/,i:/\n/,c:[e.BE,{b:/\[/,e:/\]/,r:0,c:[e.BE]}]},e.TM={cN:"title",b:e.IR,r:0},e.UTM={cN:"title",b:e.UIR,r:0},e});hljs.registerLanguage("java",function(e){var a=e.UIR+"(<"+e.UIR+">)?",t="false synchronized int abstract float private char boolean static null if const for true while long strictfp finally protected import native final void enum else break transient catch instanceof byte super volatile case assert short package default double public try this switch continue throws protected public private",c="\\b(0[bB]([01]+[01_]+[01]+|[01]+)|0[xX]([a-fA-F0-9]+[a-fA-F0-9_]+[a-fA-F0-9]+|[a-fA-F0-9]+)|(([\\d]+[\\d_]+[\\d]+|[\\d]+)(\\.([\\d]+[\\d_]+[\\d]+|[\\d]+))?|\\.([\\d]+[\\d_]+[\\d]+|[\\d]+))([eE][-+]?\\d+)?)[lLfF]?",r={cN:"number",b:c,r:0};return{aliases:["jsp"],k:t,i:/<\//,c:[e.C("/\\*\\*","\\*/",{r:0,c:[{cN:"doctag",b:"@[A-Za-z]+"}]}),e.CLCM,e.CBCM,e.ASM,e.QSM,{cN:"class",bK:"class interface",e:/[{;=]/,eE:!0,k:"class interface",i:/[:"\[\]]/,c:[{bK:"extends implements"},e.UTM]},{bK:"new throw return else",r:0},{cN:"function",b:"("+a+"\\s+)+"+e.UIR+"\\s*\\(",rB:!0,e:/[{;=]/,eE:!0,k:t,c:[{b:e.UIR+"\\s*\\(",rB:!0,r:0,c:[e.UTM]},{cN:"params",b:/\(/,e:/\)/,k:t,r:0,c:[e.ASM,e.QSM,e.CNM,e.CBCM]},e.CLCM,e.CBCM]},r,{cN:"annotation",b:"@[A-Za-z]+"}]}});
\ No newline at end of file
diff --git a/src/javadoc/js/highlight-8.6-java/styles/agate.css b/src/javadoc/js/highlight-8.6-java/styles/agate.css
deleted file mode 100644
index 50f8489de6..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/agate.css
+++ /dev/null
@@ -1,137 +0,0 @@
-/*!
- * Agate by Taufik Nurrohman <https://github.com/tovic>
- * ----------------------------------------------------
- *
- * #ade5fc
- * #a2fca2
- * #c6b4f0
- * #d36363
- * #fcc28c
- * #fc9b9b
- * #ffa
- * #fff
- * #333
- * #62c8f3
- * #888
- *
- */
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: .5em;
-  background: #333;
-  color: white;
-  -webkit-text-size-adjust: none;
-}
-
-.asciidoc .hljs-title,
-.hljs-label,
-.hljs-tag .hljs-title,
-.hljs-prompt,
-.http .hljs-request {
-  font-weight: bold;
-}
-
-.hljs-change,
-.hljs-code {
-  font-style: italic;
-}
-
-.hljs-tag,
-.ini .hljs-title {
-  color: #62c8f3;
-}
-
-.hljs-id,
-.hljs-cbracket,
-.hljs-tag .hljs-value {
-  color: #ade5fc;
-}
-
-.hljs-string,
-.hljs-bullet {
-  color: #a2fca2;
-}
-
-.hljs-type,
-.hljs-variable,
-.hljs-name,
-.actionscript .hljs-title,
-.aspectj .hljs-annotation,
-.aspectj .hljs-title,
-.hljs-attribute,
-.hljs-change,
-.hljs-blockquote,
-.hljs-built_in {
-  color: #ffa;
-}
-
-.hljs-number,
-.hljs-hexcolor,
-.hljs-link_label,
-.hljs-link_reference {
-  color: #d36363;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.hljs-constant,
-.css .hljs-tag,
-.hljs-typename,
-.hljs-winutils {
-  color: #fcc28c;
-}
-
-.hljs-comment,
-.hljs-cdata,
-.hljs-preprocessor,
-.hljs-annotation,
-.hljs-decorator,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.tex .hljs-formula,
-.hljs-header,
-.hljs-horizontal_rule,
-.hljs-code {
-  color: #888;
-}
-
-.hljs-regexp,
-.hljs-attr_selector {
-  color: #c6b4f0;
-}
-
-.hljs-important,
-.hljs-doctype,
-.hljs-pi,
-.hljs-chunk,
-.actionscript .hljs-type,
-.hljs-shebang,
-.hljs-pragma,
-.http .hljs-attribute {
-  color: #fc9b9b;
-}
-
-.hljs-deletion {
-  background-color: #fc9b9b;
-  color: #333;
-}
-
-.hljs-addition {
-  background-color: #a2fca2;
-  color: #333;
-}
-
-.hljs a,
-.hljs-tag .hljs-attribute {
-  color: inherit;
-}
-
-.hljs a:focus,
-.hljs a:hover {
-  color: inherit;
-  text-decoration: underline;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/androidstudio.css b/src/javadoc/js/highlight-8.6-java/styles/androidstudio.css
deleted file mode 100644
index 603ddd954f..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/androidstudio.css
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-Date: 24 Fev 2015
-Author: Pedro Oliveira <kanytu@gmail . com>
-*/
-
-.hljs {
-  color: #a9b7c6;
-  background: #282b2e;
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-number {
-  color: #6897BB;
-}
-
-.hljs-keyword,
-.hljs-deletion {
-  color: #cc7832;
-}
-
-.hljs-comment {
-  color: #808080;
-}
-
-.hljs-annotation {
-  color: #bbb529;
-}
-
-.hljs-string,
-.hljs-addition {
-  color: #6A8759;
-}
-
-.hljs-function .hljs-title,
-.hljs-change {
-  color: #ffc66d;
-}
-
-.hljs-tag .hljs-title,
-.hljs-doctype {
-  color: #e8bf6a;
-}
-
-.hljs-tag .hljs-attribute {
-  color: #bababa;
-}
-
-.hljs-tag .hljs-value {
-  color: #a5c261;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/arta.css b/src/javadoc/js/highlight-8.6-java/styles/arta.css
deleted file mode 100644
index 0a336f6d09..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/arta.css
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-Date: 17.V.2011
-Author: pumbur <pumbur@pumbur.net>
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #222;
-  -webkit-text-size-adjust: none;
-}
-
-.profile .hljs-header *,
-.ini .hljs-title,
-.nginx .hljs-title {
-  color: #fff;
-}
-
-.hljs-comment,
-.hljs-preprocessor,
-.hljs-preprocessor .hljs-title,
-.hljs-pragma,
-.hljs-shebang,
-.profile .hljs-summary,
-.diff,
-.hljs-pi,
-.hljs-doctype,
-.hljs-tag,
-.css .hljs-rule,
-.tex .hljs-special {
-  color: #444;
-}
-
-.hljs-string,
-.hljs-symbol,
-.diff .hljs-change,
-.hljs-regexp,
-.xml .hljs-attribute,
-.smalltalk .hljs-char,
-.xml .hljs-value,
-.ini .hljs-value,
-.clojure .hljs-attribute,
-.coffeescript .hljs-attribute {
-  color: #ffcc33;
-}
-
-.hljs-number,
-.hljs-addition {
-  color: #00cc66;
-}
-
-.hljs-built_in,
-.hljs-literal,
-.hljs-type,
-.hljs-typename,
-.go .hljs-constant,
-.ini .hljs-keyword,
-.lua .hljs-title,
-.perl .hljs-variable,
-.php .hljs-variable,
-.mel .hljs-variable,
-.django .hljs-variable,
-.css .funtion,
-.smalltalk .method,
-.hljs-hexcolor,
-.hljs-important,
-.hljs-flow,
-.hljs-inheritance,
-.hljs-name,
-.parser3 .hljs-variable {
-  color: #32aaee;
-}
-
-.hljs-keyword,
-.hljs-tag .hljs-title,
-.css .hljs-tag,
-.css .hljs-class,
-.css .hljs-id,
-.css .hljs-pseudo,
-.css .hljs-attr_selector,
-.hljs-winutils,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status {
-  color: #6644aa;
-}
-
-.hljs-title,
-.ruby .hljs-constant,
-.vala .hljs-constant,
-.hljs-parent,
-.hljs-deletion,
-.hljs-template_tag,
-.css .hljs-keyword,
-.objectivec .hljs-class .hljs-id,
-.smalltalk .hljs-class,
-.lisp .hljs-keyword,
-.apache .hljs-tag,
-.nginx .hljs-variable,
-.hljs-envvar,
-.bash .hljs-variable,
-.go .hljs-built_in,
-.vbscript .hljs-built_in,
-.lua .hljs-built_in,
-.rsl .hljs-built_in,
-.tail,
-.avrasm .hljs-label,
-.tex .hljs-formula,
-.tex .hljs-formula * {
-  color: #bb1166;
-}
-
-.hljs-doctag,
-.profile .hljs-header,
-.ini .hljs-title,
-.apache .hljs-tag,
-.parser3 .hljs-title {
-  font-weight: bold;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.6;
-}
-
-.hljs,
-.hljs-subst,
-.diff .hljs-chunk,
-.css .hljs-value,
-.css .hljs-attribute {
-  color: #aaa;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/ascetic.css b/src/javadoc/js/highlight-8.6-java/styles/ascetic.css
deleted file mode 100644
index 4f19afe3d1..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/ascetic.css
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-
-Original style from softwaremaniacs.org (c) Ivan Sagalaev <Maniac@SoftwareManiacs.Org>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: white;
-  color: black;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-filter .hljs-argument,
-.hljs-addition,
-.hljs-change,
-.hljs-name,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.nginx .hljs-built_in,
-.tex .hljs-formula {
-  color: #888;
-}
-
-.hljs-comment,
-.hljs-shebang,
-.hljs-doctype,
-.hljs-pi,
-.hljs-deletion,
-.apache .hljs-sqbracket {
-  color: #ccc;
-}
-
-.hljs-keyword,
-.hljs-tag .hljs-title,
-.ini .hljs-title,
-.lisp .hljs-title,
-.http .hljs-title,
-.nginx .hljs-title,
-.css .hljs-tag,
-.hljs-winutils,
-.hljs-flow,
-.apache .hljs-tag,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-cave.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-cave.dark.css
deleted file mode 100644
index f907beec90..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-cave.dark.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Cave Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/cave) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Cave Comment */
-.hljs-comment {
-  color: #7e7887;
-}
-
-/* Atelier-Cave Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #be4678;
-}
-
-/* Atelier-Cave Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #aa573c;
-}
-
-/* Atelier-Cave Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a06e3b;
-}
-
-/* Atelier-Cave Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #2a9292;
-}
-
-/* Atelier-Cave Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #398bc6;
-}
-
-/* Atelier-Cave Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #576ddb;
-}
-
-/* Atelier-Cave Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #955ae7;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #19171c;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #be4678;
-}
-
-.diff .hljs-addition {
-  background-color: #2a9292;
-}
-
-.diff .hljs-change {
-  color: #576ddb;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #19171c;
-  color: #8b8792;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-cave.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-cave.light.css
deleted file mode 100644
index 5df8b4c83b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-cave.light.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Cave Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/cave) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Cave Comment */
-.hljs-comment {
-  color: #655f6d;
-}
-
-/* Atelier-Cave Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #be4678;
-}
-
-/* Atelier-Cave Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #aa573c;
-}
-
-/* Atelier-Cave Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a06e3b;
-}
-
-/* Atelier-Cave Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #2a9292;
-}
-
-/* Atelier-Cave Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #398bc6;
-}
-
-/* Atelier-Cave Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #576ddb;
-}
-
-/* Atelier-Cave Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #955ae7;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #19171c;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #be4678;
-}
-
-.diff .hljs-addition {
-  background-color: #2a9292;
-}
-
-.diff .hljs-change {
-  color: #576ddb;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #efecf4;
-  color: #585260;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-dune.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-dune.dark.css
deleted file mode 100644
index 88ea51a96c..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-dune.dark.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Dune Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Dune Comment */
-.hljs-comment {
-  color: #999580;
-}
-
-/* Atelier-Dune Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #d73737;
-}
-
-/* Atelier-Dune Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #b65611;
-}
-
-/* Atelier-Dune Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #ae9513;
-}
-
-/* Atelier-Dune Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #60ac39;
-}
-
-/* Atelier-Dune Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #1fad83;
-}
-
-/* Atelier-Dune Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #6684e1;
-}
-
-/* Atelier-Dune Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #b854d4;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #20201d;
-  color: #a6a28c;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-dune.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-dune.light.css
deleted file mode 100644
index 87ffd806a6..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-dune.light.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Dune Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Dune Comment */
-.hljs-comment {
-  color: #7d7a68;
-}
-
-/* Atelier-Dune Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #d73737;
-}
-
-/* Atelier-Dune Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #b65611;
-}
-
-/* Atelier-Dune Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #ae9513;
-}
-
-/* Atelier-Dune Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #60ac39;
-}
-
-/* Atelier-Dune Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #1fad83;
-}
-
-/* Atelier-Dune Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #6684e1;
-}
-
-/* Atelier-Dune Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #b854d4;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #fefbec;
-  color: #6e6b5e;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-estuary.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-estuary.dark.css
deleted file mode 100644
index 65d0f7fe2d..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-estuary.dark.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Estuary Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/estuary) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Estuary Comment */
-.hljs-comment {
-  color: #878573;
-}
-
-/* Atelier-Estuary Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ba6236;
-}
-
-/* Atelier-Estuary Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #ae7313;
-}
-
-/* Atelier-Estuary Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a5980d;
-}
-
-/* Atelier-Estuary Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #7d9726;
-}
-
-/* Atelier-Estuary Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #5b9d48;
-}
-
-/* Atelier-Estuary Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #36a166;
-}
-
-/* Atelier-Estuary Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #5f9182;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #22221b;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #ba6236;
-}
-
-.diff .hljs-addition {
-  background-color: #7d9726;
-}
-
-.diff .hljs-change {
-  color: #36a166;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #22221b;
-  color: #929181;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-estuary.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-estuary.light.css
deleted file mode 100644
index d2f70c1d66..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-estuary.light.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Estuary Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/estuary) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Estuary Comment */
-.hljs-comment {
-  color: #6c6b5a;
-}
-
-/* Atelier-Estuary Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ba6236;
-}
-
-/* Atelier-Estuary Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #ae7313;
-}
-
-/* Atelier-Estuary Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a5980d;
-}
-
-/* Atelier-Estuary Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #7d9726;
-}
-
-/* Atelier-Estuary Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #5b9d48;
-}
-
-/* Atelier-Estuary Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #36a166;
-}
-
-/* Atelier-Estuary Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #5f9182;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #22221b;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #ba6236;
-}
-
-.diff .hljs-addition {
-  background-color: #7d9726;
-}
-
-.diff .hljs-change {
-  color: #36a166;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #f4f3ec;
-  color: #5f5e4e;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-forest.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-forest.dark.css
deleted file mode 100644
index 0e4294ba84..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-forest.dark.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Forest Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/forest) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Forest Comment */
-.hljs-comment {
-  color: #9c9491;
-}
-
-/* Atelier-Forest Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #f22c40;
-}
-
-/* Atelier-Forest Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #df5320;
-}
-
-/* Atelier-Forest Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #c38418;
-}
-
-/* Atelier-Forest Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #7b9726;
-}
-
-/* Atelier-Forest Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #3d97b8;
-}
-
-/* Atelier-Forest Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #407ee7;
-}
-
-/* Atelier-Forest Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #6666ea;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #1b1918;
-  color: #a8a19f;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-forest.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-forest.light.css
deleted file mode 100644
index e08e3dc1d7..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-forest.light.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Forest Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/forest) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Forest Comment */
-.hljs-comment {
-  color: #766e6b;
-}
-
-/* Atelier-Forest Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #f22c40;
-}
-
-/* Atelier-Forest Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #df5320;
-}
-
-/* Atelier-Forest Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #c38418;
-}
-
-/* Atelier-Forest Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #7b9726;
-}
-
-/* Atelier-Forest Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #3d97b8;
-}
-
-/* Atelier-Forest Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #407ee7;
-}
-
-/* Atelier-Forest Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #6666ea;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #f1efee;
-  color: #68615e;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-heath.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-heath.dark.css
deleted file mode 100644
index a063feb0c1..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-heath.dark.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Heath Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/heath) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Heath Comment */
-.hljs-comment {
-  color: #9e8f9e;
-}
-
-/* Atelier-Heath Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ca402b;
-}
-
-/* Atelier-Heath Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #a65926;
-}
-
-/* Atelier-Heath Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #bb8a35;
-}
-
-/* Atelier-Heath Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #918b3b;
-}
-
-/* Atelier-Heath Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #159393;
-}
-
-/* Atelier-Heath Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #516aec;
-}
-
-/* Atelier-Heath Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #7b59c0;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #1b181b;
-  color: #ab9bab;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-heath.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-heath.light.css
deleted file mode 100644
index 6c56d0401e..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-heath.light.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Heath Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/heath) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Heath Comment */
-.hljs-comment {
-  color: #776977;
-}
-
-/* Atelier-Heath Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ca402b;
-}
-
-/* Atelier-Heath Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #a65926;
-}
-
-/* Atelier-Heath Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #bb8a35;
-}
-
-/* Atelier-Heath Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #918b3b;
-}
-
-/* Atelier-Heath Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #159393;
-}
-
-/* Atelier-Heath Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #516aec;
-}
-
-/* Atelier-Heath Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #7b59c0;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #f7f3f7;
-  color: #695d69;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-lakeside.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-lakeside.dark.css
deleted file mode 100644
index 852f72e1a8..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-lakeside.dark.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Lakeside Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/lakeside) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Lakeside Comment */
-.hljs-comment {
-  color: #7195a8;
-}
-
-/* Atelier-Lakeside Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #d22d72;
-}
-
-/* Atelier-Lakeside Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #935c25;
-}
-
-/* Atelier-Lakeside Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #8a8a0f;
-}
-
-/* Atelier-Lakeside Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #568c3b;
-}
-
-/* Atelier-Lakeside Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #2d8f6f;
-}
-
-/* Atelier-Lakeside Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #257fad;
-}
-
-/* Atelier-Lakeside Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #6b6bb8;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #161b1d;
-  color: #7ea2b4;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-lakeside.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-lakeside.light.css
deleted file mode 100644
index 06f208cc3a..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-lakeside.light.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Lakeside Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/lakeside) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Lakeside Comment */
-.hljs-comment {
-  color: #5a7b8c;
-}
-
-/* Atelier-Lakeside Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #d22d72;
-}
-
-/* Atelier-Lakeside Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #935c25;
-}
-
-/* Atelier-Lakeside Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #8a8a0f;
-}
-
-/* Atelier-Lakeside Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #568c3b;
-}
-
-/* Atelier-Lakeside Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #2d8f6f;
-}
-
-/* Atelier-Lakeside Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #257fad;
-}
-
-/* Atelier-Lakeside Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #6b6bb8;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #ebf8ff;
-  color: #516d7b;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-plateau.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-plateau.dark.css
deleted file mode 100644
index 10b8f8ea9b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-plateau.dark.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Plateau Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/plateau) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Plateau Comment */
-.hljs-comment {
-  color: #7e7777;
-}
-
-/* Atelier-Plateau Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ca4949;
-}
-
-/* Atelier-Plateau Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #b45a3c;
-}
-
-/* Atelier-Plateau Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a06e3b;
-}
-
-/* Atelier-Plateau Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #4b8b8b;
-}
-
-/* Atelier-Plateau Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #5485b6;
-}
-
-/* Atelier-Plateau Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #7272ca;
-}
-
-/* Atelier-Plateau Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #8464c4;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #1b1818;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #ca4949;
-}
-
-.diff .hljs-addition {
-  background-color: #4b8b8b;
-}
-
-.diff .hljs-change {
-  color: #7272ca;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #1b1818;
-  color: #8a8585;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-plateau.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-plateau.light.css
deleted file mode 100644
index 1c19cf61da..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-plateau.light.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Plateau Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/plateau) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Plateau Comment */
-.hljs-comment {
-  color: #655d5d;
-}
-
-/* Atelier-Plateau Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ca4949;
-}
-
-/* Atelier-Plateau Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #b45a3c;
-}
-
-/* Atelier-Plateau Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a06e3b;
-}
-
-/* Atelier-Plateau Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #4b8b8b;
-}
-
-/* Atelier-Plateau Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #5485b6;
-}
-
-/* Atelier-Plateau Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #7272ca;
-}
-
-/* Atelier-Plateau Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #8464c4;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #1b1818;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #ca4949;
-}
-
-.diff .hljs-addition {
-  background-color: #4b8b8b;
-}
-
-.diff .hljs-change {
-  color: #7272ca;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #f4ecec;
-  color: #585050;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-savanna.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-savanna.dark.css
deleted file mode 100644
index 444e2de864..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-savanna.dark.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Savanna Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/savanna) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Savanna Comment */
-.hljs-comment {
-  color: #78877d;
-}
-
-/* Atelier-Savanna Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #b16139;
-}
-
-/* Atelier-Savanna Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #9f713c;
-}
-
-/* Atelier-Savanna Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a07e3b;
-}
-
-/* Atelier-Savanna Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #489963;
-}
-
-/* Atelier-Savanna Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #1c9aa0;
-}
-
-/* Atelier-Savanna Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #478c90;
-}
-
-/* Atelier-Savanna Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #55859b;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #171c19;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #b16139;
-}
-
-.diff .hljs-addition {
-  background-color: #489963;
-}
-
-.diff .hljs-change {
-  color: #478c90;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #171c19;
-  color: #87928a;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-savanna.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-savanna.light.css
deleted file mode 100644
index 5eeb294989..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-savanna.light.css
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Base16 Atelier Savanna Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/savanna) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Savanna Comment */
-.hljs-comment {
-  color: #5f6d64;
-}
-
-/* Atelier-Savanna Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #b16139;
-}
-
-/* Atelier-Savanna Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #9f713c;
-}
-
-/* Atelier-Savanna Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #a07e3b;
-}
-
-/* Atelier-Savanna Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #489963;
-}
-
-/* Atelier-Savanna Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #1c9aa0;
-}
-
-/* Atelier-Savanna Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #478c90;
-}
-
-/* Atelier-Savanna Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #55859b;
-}
-
-.diff .hljs-deletion,
-.diff .hljs-addition {
-  color: #171c19;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-deletion {
-  background-color: #b16139;
-}
-
-.diff .hljs-addition {
-  background-color: #489963;
-}
-
-.diff .hljs-change {
-  color: #478c90;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #ecf4ee;
-  color: #526057;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-seaside.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-seaside.dark.css
deleted file mode 100644
index 0bcfd1b2ee..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-seaside.dark.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Seaside Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/seaside) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Seaside Comment */
-.hljs-comment {
-  color: #809980;
-}
-
-/* Atelier-Seaside Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #e6193c;
-}
-
-/* Atelier-Seaside Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #87711d;
-}
-
-/* Atelier-Seaside Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #98981b;
-}
-
-/* Atelier-Seaside Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #29a329;
-}
-
-/* Atelier-Seaside Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #1999b3;
-}
-
-/* Atelier-Seaside Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #3d62f5;
-}
-
-/* Atelier-Seaside Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #ad2bee;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #131513;
-  color: #8ca68c;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-seaside.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-seaside.light.css
deleted file mode 100644
index 6023d4beff..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-seaside.light.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Seaside Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/seaside) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Seaside Comment */
-.hljs-comment {
-  color: #687d68;
-}
-
-/* Atelier-Seaside Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #e6193c;
-}
-
-/* Atelier-Seaside Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #87711d;
-}
-
-/* Atelier-Seaside Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #98981b;
-}
-
-/* Atelier-Seaside Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #29a329;
-}
-
-/* Atelier-Seaside Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #1999b3;
-}
-
-/* Atelier-Seaside Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #3d62f5;
-}
-
-/* Atelier-Seaside Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #ad2bee;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #f4fbf4;
-  color: #5e6e5e;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-sulphurpool.dark.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-sulphurpool.dark.css
deleted file mode 100644
index dda8af3c5d..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-sulphurpool.dark.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Sulphurpool Dark - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/sulphurpool) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Sulphurpool Comment */
-.hljs-comment {
-  color: #898ea4;
-}
-
-/* Atelier-Sulphurpool Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #c94922;
-}
-
-/* Atelier-Sulphurpool Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #c76b29;
-}
-
-/* Atelier-Sulphurpool Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #c08b30;
-}
-
-/* Atelier-Sulphurpool Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #ac9739;
-}
-
-/* Atelier-Sulphurpool Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #22a2c9;
-}
-
-/* Atelier-Sulphurpool Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #3d8fd1;
-}
-
-/* Atelier-Sulphurpool Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #6679cc;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #202746;
-  color: #979db4;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/atelier-sulphurpool.light.css b/src/javadoc/js/highlight-8.6-java/styles/atelier-sulphurpool.light.css
deleted file mode 100644
index 2149b4c48b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/atelier-sulphurpool.light.css
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Base16 Atelier Sulphurpool Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/sulphurpool) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
-
-/* Atelier-Sulphurpool Comment */
-.hljs-comment {
-  color: #6b7394;
-}
-
-/* Atelier-Sulphurpool Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #c94922;
-}
-
-/* Atelier-Sulphurpool Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #c76b29;
-}
-
-/* Atelier-Sulphurpool Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #c08b30;
-}
-
-/* Atelier-Sulphurpool Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #ac9739;
-}
-
-/* Atelier-Sulphurpool Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #22a2c9;
-}
-
-/* Atelier-Sulphurpool Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #3d8fd1;
-}
-
-/* Atelier-Sulphurpool Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #6679cc;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #f5f7ff;
-  color: #5e6687;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/brown_paper.css b/src/javadoc/js/highlight-8.6-java/styles/brown_paper.css
deleted file mode 100644
index e06931ac95..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/brown_paper.css
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-
-Brown Paper style from goldblog.com.ua (c) Zaripov Yura <yur4ik7@ukr.net>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background:#b7a68e url(brown_papersq.png);
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.tex .hljs-special,
-.hljs-request,
-.hljs-status {
-  color:#005599;
-  font-weight:bold;
-}
-
-.hljs,
-.hljs-subst,
-.hljs-tag .hljs-keyword {
-  color: #363c69;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-type,
-.hljs-tag .hljs-value,
-.css .hljs-rule .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.ruby .hljs-string,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-number,
-.hljs-name {
-  color: #2c009f;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.hljs-decorator,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in,
-.tex .hljs-formula {
-  color: #802022;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.css .hljs-id,
-.hljs-doctag,
-.hljs-title,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.diff .hljs-header,
-.hljs-chunk,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.tex .hljs-command {
-  font-weight: bold;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.8;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/brown_papersq.png b/src/javadoc/js/highlight-8.6-java/styles/brown_papersq.png
deleted file mode 100644
index 3813903dbf..0000000000
Binary files a/src/javadoc/js/highlight-8.6-java/styles/brown_papersq.png and /dev/null differ
diff --git a/src/javadoc/js/highlight-8.6-java/styles/codepen-embed.css b/src/javadoc/js/highlight-8.6-java/styles/codepen-embed.css
deleted file mode 100644
index 48cb69a633..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/codepen-embed.css
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  codepen.io Embed Theme
-  Author: Justin Perry <http://github.com/ourmaninamsterdam>
-  Original theme - https://github.com/chriskempson/tomorrow-theme
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #222;
-  color: #fff;
-  font-family: Menlo, Monaco, 'Andale Mono', 'Lucida Console', 'Courier New', monospace;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.hljs-title {
-  color: #777;
-}
-
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .constant,
-.xml .tag .title,
-.xml .pi,
-.xml .doctype,
-.html .doctype {
-  color: #ab875d;
-}
-
-.css .value {
-  color: #cd6a51;
-}
-
-.css .value .function,
-.css .value .string {
-  color: #a67f59;
-}
-
-.css .value .number {
-  color: #9b869c;
-}
-
-.css .id,
-.css .class,
-.css-pseudo,
-.css .selector,
-.css .tag {
-  color: #dfc48c;
-}
-
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #ab875d;
-}
-
-.ruby .class .title,
-.css .rules .attribute {
-  color: #9b869b;
-}
-
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .symbol,
-.xml .cdata {
-  color: #8f9c6c;
-}
-
-.css .hexcolor {
-  color: #cd6a51;
-}
-
-.function,
-.python .decorator,
-.python .title,
-.ruby .function .title,
-.ruby .title .keyword,
-.perl .sub,
-.javascript .title,
-.coffeescript .title {
-  color: #fff;
-}
-
-.hljs-keyword,
-.javascript .function {
-  color: #8f9c6c;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/color-brewer.css b/src/javadoc/js/highlight-8.6-java/styles/color-brewer.css
deleted file mode 100644
index 6be4738eae..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/color-brewer.css
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-
-Colorbrewer theme
-Original: https://github.com/mbostock/colorbrewer-theme (c) Mike Bostock <mike@ocks.org>
-Ported by Fabrício Tavares de Oliveira
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #fff;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-subst,
-.hljs-tag .hljs-title,
-.nginx .hljs-title {
-  color: #000;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-constant,
-.hljs-parent,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.haml .hljs-symbol,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.hljs-addition,
-.hljs-flow,
-.hljs-stream,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.tex .hljs-special,
-.erlang_repl .hljs-function_or_atom,
-.asciidoc .hljs-header,
-.markdown .hljs-header,
-.coffeescript .hljs-attribute,
-.hljs-name {
-  color: #756bb1;
-}
-
-.smartquote,
-.hljs-comment,
-.hljs-annotation,
-.diff .hljs-header,
-.hljs-chunk,
-.asciidoc .hljs-blockquote,
-.markdown .hljs-blockquote {
-  color: #636363;
-}
-
-.hljs-number,
-.hljs-date,
-.hljs-regexp,
-.hljs-literal,
-.hljs-hexcolor,
-.smalltalk .hljs-symbol,
-.smalltalk .hljs-char,
-.go .hljs-constant,
-.hljs-change,
-.lasso .hljs-variable,
-.makefile .hljs-variable,
-.asciidoc .hljs-bullet,
-.markdown .hljs-bullet,
-.asciidoc .hljs-link_url,
-.markdown .hljs-link_url {
-  color: #31a354;
-}
-
-.hljs-label,
-.ruby .hljs-string,
-.hljs-decorator,
-.hljs-filter .hljs-argument,
-.hljs-localvars,
-.hljs-array,
-.hljs-attr_selector,
-.hljs-important,
-.hljs-pseudo,
-.hljs-pi,
-.haml .hljs-bullet,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-envvar,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in,
-.hljs-list .hljs-built_in,
-.tex .hljs-formula,
-.erlang_repl .hljs-reserved,
-.hljs-prompt,
-.asciidoc .hljs-link_label,
-.markdown .hljs-link_label,
-.vhdl .hljs-attribute,
-.clojure .hljs-attribute,
-.asciidoc .hljs-attribute,
-.lasso .hljs-attribute,
-.coffeescript .hljs-property,
-.hljs-phony {
-  color: #88f;
-}
-
-
-
-.hljs-keyword,
-.hljs-id,
-.hljs-title,
-.hljs-built_in,
-.css .hljs-tag,
-.hljs-doctag,
-.smalltalk .hljs-class,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.hljs-type,
-.hljs-typename,
-.tex .hljs-command,
-.asciidoc .hljs-strong,
-.markdown .hljs-strong,
-.hljs-request,
-.hljs-status {
-  color: #3182bd;
-}
-
-.asciidoc .hljs-emphasis,
-.markdown .hljs-emphasis {
-  font-style: italic;
-}
-
-.nginx .hljs-built_in {
-  font-weight: normal;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.lasso .markup,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
-
-.css .hljs-attribute,
-.html .hljs-attribute {
-  color: #e6550d;
-}
-
-.css .hljs-class,
-.html .hljs-tag,
-.html .hljs-title {
-  color: #3182bd;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/dark.css b/src/javadoc/js/highlight-8.6-java/styles/dark.css
deleted file mode 100644
index be3c8d7ea7..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/dark.css
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-
-Dark style from softwaremaniacs.org (c) Ivan Sagalaev <Maniac@SoftwareManiacs.Org>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #444;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.tex .hljs-special {
-  color: white;
-}
-
-.hljs,
-.hljs-subst {
-  color: #ddd;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-type,
-.ini .hljs-title,
-.hljs-tag .hljs-value,
-.css .hljs-rule .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.ruby .hljs-string,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.hljs-prompt,
-.coffeescript .hljs-attribute,
-.hljs-name {
-  color: #d88;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.hljs-decorator,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.tex .hljs-formula {
-  color: #777;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.hljs-title,
-.css .hljs-id,
-.hljs-doctag,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.diff .hljs-header,
-.hljs-chunk,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.tex .hljs-special,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/darkula.css b/src/javadoc/js/highlight-8.6-java/styles/darkula.css
deleted file mode 100644
index 1c6853b4e8..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/darkula.css
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-
-Darkula color scheme from the JetBrains family of IDEs
-
-*/
-
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #2b2b2b;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-tag,
-.hljs-title,
-.css .hljs-rule,
-.css .hljs-value,
-.aspectj .hljs-function,
-.css .hljs-function .hljs-preprocessor,
-.hljs-pragma {
-  color: #bababa;
-}
-
-.hljs-strongemphasis,
-.hljs-strong,
-.hljs-emphasis {
-  color: #a8a8a2;
-}
-
-.hljs-bullet,
-.hljs-blockquote,
-.hljs-horizontal_rule,
-.hljs-number,
-.hljs-regexp,
-.alias .hljs-keyword,
-.hljs-literal,
-.hljs-hexcolor {
-  color: #6896ba;
-}
-
-.hljs-tag .hljs-value,
-.hljs-code,
-.css .hljs-class,
-.hljs-class .hljs-title:last-child {
-  color: #a6e22e;
-}
-
-.hljs-link_url {
-  font-size: 80%;
-}
-
-.hljs-emphasis,
-.hljs-strongemphasis,
-.hljs-class .hljs-title:last-child,
-.hljs-typename {
-  font-style: italic;
-}
-
-.hljs-keyword,
-.ruby .hljs-class .hljs-keyword:first-child,
-.ruby .hljs-function .hljs-keyword,
-.hljs-function,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.tex .hljs-special,
-.hljs-header,
-.hljs-attribute,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.hljs-tag .hljs-title,
-.hljs-value,
-.alias .hljs-keyword:first-child,
-.css .hljs-tag,
-.css .unit,
-.css .hljs-important {
-  color: #cb7832;
-}
-
-.hljs-function .hljs-keyword,
-.hljs-class .hljs-keyword:first-child,
-.hljs-aspect .hljs-keyword:first-child,
-.hljs-constant,
-.hljs-typename,
-.css .hljs-attribute {
-  color: #cb7832;
-}
-
-.hljs-variable,
-.hljs-params,
-.hljs-class .hljs-title,
-.hljs-aspect .hljs-title {
-  color: #b9b9b9;
-}
-
-.hljs-string,
-.css .hljs-id,
-.hljs-subst,
-.hljs-type,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.hljs-prompt,
-.hljs-link_label,
-.hljs-link_url,
-.hljs-name {
-  color: #e0c46c;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.tex .hljs-formula {
-  color: #7f7f7f;
-}
-
-.hljs-decorator {
-  color: #bab429;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata,
-.xml .php,
-.php .xml {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/default.css b/src/javadoc/js/highlight-8.6-java/styles/default.css
deleted file mode 100644
index b0ac8b8aac..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/default.css
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
-
-Original style from softwaremaniacs.org (c) Ivan Sagalaev <Maniac@SoftwareManiacs.Org>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #f0f0f0;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-subst,
-.hljs-tag .hljs-title,
-.nginx .hljs-title {
-  color: black;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-constant,
-.hljs-parent,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-name,
-.haml .hljs-symbol,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.hljs-addition,
-.hljs-flow,
-.hljs-stream,
-.bash .hljs-variable,
-.pf .hljs-variable,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.tex .hljs-special,
-.erlang_repl .hljs-function_or_atom,
-.asciidoc .hljs-header,
-.markdown .hljs-header,
-.coffeescript .hljs-attribute,
-.tp .hljs-variable {
-  color: #800;
-}
-
-.smartquote,
-.hljs-comment,
-.hljs-annotation,
-.diff .hljs-header,
-.hljs-chunk,
-.asciidoc .hljs-blockquote,
-.markdown .hljs-blockquote {
-  color: #888;
-}
-
-.hljs-number,
-.hljs-date,
-.hljs-regexp,
-.hljs-literal,
-.hljs-hexcolor,
-.smalltalk .hljs-symbol,
-.smalltalk .hljs-char,
-.go .hljs-constant,
-.hljs-change,
-.lasso .hljs-variable,
-.makefile .hljs-variable,
-.asciidoc .hljs-bullet,
-.markdown .hljs-bullet,
-.asciidoc .hljs-link_url,
-.markdown .hljs-link_url {
-  color: #080;
-}
-
-.hljs-label,
-.ruby .hljs-string,
-.hljs-decorator,
-.hljs-filter .hljs-argument,
-.hljs-localvars,
-.hljs-array,
-.hljs-attr_selector,
-.hljs-important,
-.hljs-pseudo,
-.hljs-pi,
-.haml .hljs-bullet,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-envvar,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in,
-.tex .hljs-formula,
-.erlang_repl .hljs-reserved,
-.hljs-prompt,
-.asciidoc .hljs-link_label,
-.markdown .hljs-link_label,
-.vhdl .hljs-attribute,
-.clojure .hljs-attribute,
-.asciidoc .hljs-attribute,
-.lasso .hljs-attribute,
-.coffeescript .hljs-property,
-.hljs-phony {
-  color: #88f;
-}
-
-.hljs-keyword,
-.hljs-id,
-.hljs-title,
-.hljs-built_in,
-.css .hljs-tag,
-.hljs-doctag,
-.smalltalk .hljs-class,
-.hljs-winutils,
-.bash .hljs-variable,
-.pf .hljs-variable,
-.apache .hljs-tag,
-.hljs-type,
-.hljs-typename,
-.tex .hljs-command,
-.asciidoc .hljs-strong,
-.markdown .hljs-strong,
-.hljs-request,
-.hljs-status,
-.tp .hljs-data,
-.tp .hljs-io {
-  font-weight: bold;
-}
-
-.asciidoc .hljs-emphasis,
-.markdown .hljs-emphasis,
-.tp .hljs-units {
-  font-style: italic;
-}
-
-.nginx .hljs-built_in {
-  font-weight: normal;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.lasso .markup,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/docco.css b/src/javadoc/js/highlight-8.6-java/styles/docco.css
deleted file mode 100644
index 0f11123666..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/docco.css
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
-Docco style used in http://jashkenas.github.com/docco/ converted by Simon Madine (@thingsinjars)
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  color: #000;
-  background: #f8f8ff;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.diff .hljs-header {
-  color: #408080;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.assignment,
-.hljs-literal,
-.css .rule .hljs-keyword,
-.hljs-winutils,
-.javascript .hljs-title,
-.lisp .hljs-title,
-.hljs-subst {
-  color: #954121;
-}
-
-.hljs-number,
-.hljs-hexcolor {
-  color: #40a070;
-}
-
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-doctag,
-.tex .hljs-formula,
-.hljs-name {
-  color: #219161;
-}
-
-.hljs-title,
-.hljs-id {
-  color: #19469d;
-}
-.hljs-params {
-  color: #00f;
-}
-
-.javascript .hljs-title,
-.lisp .hljs-title,
-.hljs-subst {
-  font-weight: normal;
-}
-
-.hljs-class .hljs-title,
-.haskell .hljs-label,
-.tex .hljs-command {
-  color: #458;
-  font-weight: bold;
-}
-
-.hljs-tag,
-.hljs-tag .hljs-title,
-.hljs-rule .hljs-property,
-.django .hljs-tag .hljs-keyword {
-  color: #000080;
-  font-weight: normal;
-}
-
-.hljs-attribute,
-.hljs-variable,
-.instancevar,
-.lisp .hljs-body {
-  color: #008080;
-}
-
-.hljs-regexp {
-  color: #b68;
-}
-
-.hljs-class {
-  color: #458;
-  font-weight: bold;
-}
-
-.hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.ruby .hljs-symbol .hljs-keyword,
-.ruby .hljs-symbol .keymethods,
-.lisp .hljs-keyword,
-.tex .hljs-special,
-.input_number {
-  color: #990073;
-}
-
-.builtin,
-.constructor,
-.hljs-built_in,
-.lisp .hljs-title {
-  color: #0086b3;
-}
-
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-pi,
-.hljs-doctype,
-.hljs-shebang,
-.hljs-cdata {
-  color: #999;
-  font-weight: bold;
-}
-
-.hljs-deletion {
-  background: #fdd;
-}
-
-.hljs-addition {
-  background: #dfd;
-}
-
-.diff .hljs-change {
-  background: #0086b3;
-}
-
-.hljs-chunk {
-  color: #aaa;
-}
-
-.tex .hljs-formula {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/far.css b/src/javadoc/js/highlight-8.6-java/styles/far.css
deleted file mode 100644
index 34ed6f5df0..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/far.css
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-
-FAR Style (c) MajestiC <majestic2k@gmail.com>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #000080;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-subst {
-  color: #0ff;
-}
-
-.hljs-string,
-.ruby .hljs-string,
-.haskell .hljs-type,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.hljs-rule .hljs-value .hljs-number,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.hljs-addition,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.coffeescript .hljs-attribute {
-  color: #ff0;
-}
-
-.hljs-keyword,
-.css .hljs-id,
-.hljs-title,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.xml .hljs-tag .hljs-title,
-.hljs-winutils,
-.hljs-flow,
-.hljs-change,
-.hljs-envvar,
-.bash .hljs-variable,
-.tex .hljs-special,
-.hljs-name {
-  color: #fff;
-}
-
-.hljs-comment,
-.hljs-doctag,
-.hljs-annotation,
-.hljs-deletion,
-.apache .hljs-sqbracket,
-.tex .hljs-formula {
-  color: #888;
-}
-
-.hljs-number,
-.hljs-date,
-.hljs-regexp,
-.hljs-literal,
-.smalltalk .hljs-symbol,
-.smalltalk .hljs-char,
-.clojure .hljs-attribute {
-  color: #0f0;
-}
-
-.hljs-decorator,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.xml .hljs-pi,
-.diff .hljs-header,
-.hljs-chunk,
-.hljs-shebang,
-.nginx .hljs-built_in,
-.hljs-prompt {
-  color: #008080;
-}
-
-.hljs-keyword,
-.css .hljs-id,
-.hljs-title,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.hljs-winutils,
-.hljs-flow,
-.apache .hljs-tag,
-.nginx .hljs-built_in,
-.tex .hljs-command,
-.tex .hljs-special,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/foundation.css b/src/javadoc/js/highlight-8.6-java/styles/foundation.css
deleted file mode 100644
index 09c2ff274a..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/foundation.css
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-Description: Foundation 4 docs style for highlight.js
-Author: Dan Allen <dan.j.allen@gmail.com>
-Website: http://foundation.zurb.com/docs/
-Version: 1.0
-Date: 2013-04-02
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #eee;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-header,
-.hljs-decorator,
-.hljs-annotation {
-  color: #000077;
-}
-
-.hljs-horizontal_rule,
-.hljs-link_url,
-.hljs-emphasis,
-.hljs-attribute {
-  color: #070;
-}
-
-.hljs-emphasis {
-  font-style: italic;
-}
-
-.hljs-link_label,
-.hljs-strong,
-.hljs-value,
-.hljs-string,
-.scss .hljs-value .hljs-string {
-  color: #d14;
-}
-
-.hljs-strong {
-  font-weight: bold;
-}
-
-.hljs-blockquote,
-.hljs-comment {
-  color: #998;
-  font-style: italic;
-}
-
-.asciidoc .hljs-title,
-.hljs-function .hljs-title {
-  color: #900;
-}
-
-.hljs-class {
-  color: #458;
-}
-
-.hljs-id,
-.hljs-pseudo,
-.hljs-constant,
-.hljs-hexcolor {
-  color: teal;
-}
-
-.hljs-variable {
-  color: #336699;
-}
-
-.hljs-bullet {
-  color: #997700;
-}
-
-.hljs-pi,
-.hljs-doctype {
-  color: #3344bb;
-}
-
-.hljs-code,
-.hljs-number {
-  color: #099;
-}
-
-.hljs-important {
-  color: #f00;
-}
-
-.smartquote,
-.hljs-label {
-  color: #970;
-}
-
-.hljs-preprocessor,
-.hljs-pragma {
-  color: #579;
-}
-
-.hljs-reserved,
-.hljs-keyword,
-.scss .hljs-value {
-  color: #000;
-}
-
-.hljs-regexp {
-  background-color: #fff0ff;
-  color: #880088;
-}
-
-.hljs-symbol {
-  color: #990073;
-}
-
-.hljs-symbol .hljs-string {
-  color: #a60;
-}
-
-.hljs-tag {
-  color: #007700;
-}
-
-.hljs-at_rule,
-.hljs-at_rule .hljs-keyword {
-  color: #088;
-}
-
-.hljs-at_rule .hljs-preprocessor {
-  color: #808;
-}
-
-.scss .hljs-tag,
-.scss .hljs-attribute {
-  color: #339;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/github-gist.css b/src/javadoc/js/highlight-8.6-java/styles/github-gist.css
deleted file mode 100644
index 231301a8a8..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/github-gist.css
+++ /dev/null
@@ -1,211 +0,0 @@
-/**
- * GitHub Gist Theme
- * Author : Louis Barranqueiro - https://github.com/LouisBarranqueiro
- */
-
-.hljs {
-  display: block;
-  background:white;
-  padding: 0.5em;
-  color: #333333;
-  overflow-x: auto;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.bash .hljs-shebang,
-.java .hljs-javadoc,
-.javascript .hljs-javadoc {
-  color: #969896;
-}
-
-.hljs-string,
-.apache .hljs-sqbracket,
-.coffeescript .hljs-subst,
-.coffeescript .hljs-regexp,
-.cpp .hljs-preprocessor,
-.c .hljs-preprocessor,
-.javascript .hljs-regexp,
-.json .hljs-attribute,
-.makefile .hljs-variable,
-.markdown .hljs-value,
-.markdown .hljs-link_label,
-.markdown .hljs-strong,
-.markdown .hljs-emphasis,
-.markdown .hljs-blockquote,
-.nginx .hljs-regexp,
-.nginx .hljs-number,
-.objectivec .hljs-preprocessor .hljs-title,
-.perl .hljs-regexp,
-.php .hljs-regexp,
-.xml .hljs-value,
-.less .hljs-built_in,
-.scss .hljs-built_in {
-  color: #df5000;
-}
-
-.hljs-keyword,
-.css .hljs-at_rule,
-.css .hljs-important,
-.http .hljs-request,
-.ini .hljs-setting,
-.java .hljs-javadoctag,
-.javascript .hljs-tag,
-.javascript .hljs-javadoctag,
-.nginx .hljs-title,
-.objectivec .hljs-preprocessor,
-.php .hljs-phpdoc,
-.sql .hljs-built_in,
-.less .hljs-tag,
-.less .hljs-at_rule,
-.scss .hljs-tag,
-.scss .hljs-at_rule,
-.scss .hljs-important,
-.stylus .hljs-at_rule,
-.go .hljs-typename,
-.swift .hljs-preprocessor {
-  color: #a71d5d;
-}
-
-.apache .hljs-common,
-.apache .hljs-cbracket,
-.apache .hljs-keyword,
-.bash .hljs-literal,
-.bash .hljs-built_in,
-.coffeescript .hljs-literal,
-.coffeescript .hljs-built_in,
-.coffeescript .hljs-number,
-.cpp .hljs-number,
-.cpp .hljs-built_in,
-.c .hljs-number,
-.c .hljs-built_in,
-.cs .hljs-number,
-.cs .hljs-built_in,
-.css .hljs-attribute,
-.css .hljs-hexcolor,
-.css .hljs-number,
-.css .hljs-function,
-.http .hljs-literal,
-.http .hljs-attribute,
-.java .hljs-number,
-.javascript .hljs-built_in,
-.javascript .hljs-literal,
-.javascript .hljs-number,
-.json .hljs-number,
-.makefile .hljs-keyword,
-.markdown .hljs-link_reference,
-.nginx .hljs-built_in,
-.objectivec .hljs-literal,
-.objectivec .hljs-number,
-.objectivec .hljs-built_in,
-.php .hljs-literal,
-.php .hljs-number,
-.python .hljs-number,
-.ruby .hljs-prompt,
-.ruby .hljs-constant,
-.ruby .hljs-number,
-.ruby .hljs-subst .hljs-keyword,
-.ruby .hljs-symbol,
-.sql .hljs-number,
-.puppet .hljs-function,
-.less .hljs-number,
-.less .hljs-hexcolor,
-.less .hljs-function,
-.less .hljs-attribute,
-.scss .hljs-preprocessor,
-.scss .hljs-number,
-.scss .hljs-hexcolor,
-.scss .hljs-function,
-.scss .hljs-attribute,
-.stylus .hljs-number,
-.stylus .hljs-hexcolor,
-.stylus .hljs-attribute,
-.stylus .hljs-params,
-.go .hljs-built_in,
-.go .hljs-constant,
-.swift .hljs-built_in,
-.swift .hljs-number {
-  color: #0086b3;
-}
-
-.apache .hljs-tag,
-.cs .hljs-xmlDocTag,
-.css .hljs-tag,
-.xml .hljs-title,
-.stylus .hljs-tag {
-  color: #63a35c;
-}
-
-.bash .hljs-variable,
-.cs .hljs-preprocessor,
-.cs .hljs-preprocessor .hljs-keyword,
-.css .hljs-attr_selector,
-.css .hljs-value,
-.ini .hljs-value,
-.ini .hljs-keyword,
-.javascript .hljs-tag .hljs-title,
-.makefile .hljs-constant,
-.nginx .hljs-variable,
-.xml .hljs-tag,
-.scss .hljs-variable {
-  color: #333333;
-}
-
-.bash .hljs-title,
-.coffeescript .hljs-title,
-.cpp .hljs-title,
-.c .hljs-title,
-.cs .hljs-title,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo,
-.ini .hljs-title,
-.java .hljs-title,
-.javascript .hljs-title,
-.makefile .hljs-title,
-.objectivec .hljs-title,
-.perl .hljs-sub,
-.php .hljs-title,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-parent,
-.ruby .hljs-title,
-.xml .hljs-attribute,
-.puppet .hljs-title,
-.less .hljs-id,
-.less .hljs-pseudo,
-.less .hljs-class,
-.scss .hljs-id,
-.scss .hljs-pseudo,
-.scss .hljs-class,
-.stylus .hljs-class,
-.stylus .hljs-id,
-.stylus .hljs-pseudo,
-.stylus .hljs-title,
-.swift .hljs-title,
-.diff .hljs-chunk {
-  color: #795da3;
-}
-
-.coffeescript .hljs-reserved,
-.coffeescript .hljs-attribute {
-  color: #1d3e81;
-}
-
-.diff .hljs-chunk {
-  font-weight: bold;
-}
-
-.diff .hljs-addition {
-  color: #55a532;
-  background-color: #eaffea;
-}
-
-.diff .hljs-deletion {
-  color: #bd2c00;
-  background-color: #ffecec;
-}
-
-.markdown .hljs-link_url {
-  text-decoration: underline;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/github.css b/src/javadoc/js/highlight-8.6-java/styles/github.css
deleted file mode 100644
index 791537e41d..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/github.css
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-
-github.com style (c) Vasily Polovnyov <vast@whiteants.net>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  color: #333;
-  background: #f8f8f8;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.diff .hljs-header {
-  color: #998;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.css .rule .hljs-keyword,
-.hljs-winutils,
-.nginx .hljs-title,
-.hljs-subst,
-.hljs-request,
-.hljs-status {
-  color: #333;
-  font-weight: bold;
-}
-
-.hljs-number,
-.hljs-hexcolor,
-.ruby .hljs-constant {
-  color: #008080;
-}
-
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-doctag,
-.tex .hljs-formula {
-  color: #d14;
-}
-
-.hljs-title,
-.hljs-id,
-.scss .hljs-preprocessor {
-  color: #900;
-  font-weight: bold;
-}
-
-.hljs-list .hljs-keyword,
-.hljs-subst {
-  font-weight: normal;
-}
-
-.hljs-class .hljs-title,
-.hljs-type,
-.vhdl .hljs-literal,
-.tex .hljs-command {
-  color: #458;
-  font-weight: bold;
-}
-
-.hljs-tag,
-.hljs-tag .hljs-title,
-.hljs-rule .hljs-property,
-.django .hljs-tag .hljs-keyword {
-  color: #000080;
-  font-weight: normal;
-}
-
-.hljs-attribute,
-.hljs-variable,
-.lisp .hljs-body,
-.hljs-name {
-  color: #008080;
-}
-
-.hljs-regexp {
-  color: #009926;
-}
-
-.hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.lisp .hljs-keyword,
-.clojure .hljs-keyword,
-.scheme .hljs-keyword,
-.tex .hljs-special,
-.hljs-prompt {
-  color: #990073;
-}
-
-.hljs-built_in {
-  color: #0086b3;
-}
-
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-pi,
-.hljs-doctype,
-.hljs-shebang,
-.hljs-cdata {
-  color: #999;
-  font-weight: bold;
-}
-
-.hljs-deletion {
-  background: #fdd;
-}
-
-.hljs-addition {
-  background: #dfd;
-}
-
-.diff .hljs-change {
-  background: #0086b3;
-}
-
-.hljs-chunk {
-  color: #aaa;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/googlecode.css b/src/javadoc/js/highlight-8.6-java/styles/googlecode.css
deleted file mode 100644
index dad5bb083b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/googlecode.css
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-
-Google Code style (c) Aahan Krish <geekpanth3r@gmail.com>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: white;
-  color: black;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment {
-  color: #800;
-}
-
-.hljs-keyword,
-.method,
-.hljs-list .hljs-keyword,
-.nginx .hljs-title,
-.hljs-tag .hljs-title,
-.setting .hljs-value,
-.hljs-winutils,
-.tex .hljs-command,
-.http .hljs-title,
-.hljs-request,
-.hljs-status {
-  color: #008;
-}
-
-.hljs-envvar,
-.tex .hljs-special {
-  color: #660;
-}
-
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-cdata,
-.hljs-filter .hljs-argument,
-.hljs-attr_selector,
-.apache .hljs-cbracket,
-.hljs-date,
-.hljs-regexp,
-.coffeescript .hljs-attribute {
-  color: #080;
-}
-
-.hljs-sub .hljs-identifier,
-.hljs-pi,
-.hljs-tag,
-.hljs-tag .hljs-keyword,
-.hljs-decorator,
-.ini .hljs-title,
-.hljs-shebang,
-.hljs-prompt,
-.hljs-hexcolor,
-.hljs-rule .hljs-value,
-.hljs-literal,
-.hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-number,
-.css .hljs-function,
-.clojure .hljs-attribute {
-  color: #066;
-}
-
-.hljs-class .hljs-title,
-.smalltalk .hljs-class,
-.hljs-doctag,
-.hljs-type,
-.hljs-typename,
-.hljs-tag .hljs-attribute,
-.hljs-doctype,
-.hljs-class .hljs-id,
-.hljs-built_in,
-.setting,
-.hljs-params,
-.hljs-variable,
-.hljs-name {
-  color: #606;
-}
-
-.css .hljs-tag,
-.hljs-rule .hljs-property,
-.hljs-pseudo,
-.hljs-subst {
-  color: #000;
-}
-
-.css .hljs-class,
-.css .hljs-id {
-  color: #9b703f;
-}
-
-.hljs-value .hljs-important {
-  color: #ff7700;
-  font-weight: bold;
-}
-
-.hljs-rule .hljs-keyword {
-  color: #c5af75;
-}
-
-.hljs-annotation,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in {
-  color: #9b859d;
-}
-
-.hljs-preprocessor,
-.hljs-preprocessor *,
-.hljs-pragma {
-  color: #444;
-}
-
-.tex .hljs-formula {
-  background-color: #eee;
-  font-style: italic;
-}
-
-.diff .hljs-header,
-.hljs-chunk {
-  color: #808080;
-  font-weight: bold;
-}
-
-.diff .hljs-change {
-  background-color: #bccff9;
-}
-
-.hljs-addition {
-  background-color: #baeeba;
-}
-
-.hljs-deletion {
-  background-color: #ffc8bd;
-}
-
-.hljs-comment .hljs-doctag {
-  font-weight: bold;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/hybrid.css b/src/javadoc/js/highlight-8.6-java/styles/hybrid.css
deleted file mode 100644
index 3019ffe9cf..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/hybrid.css
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-
-vim-hybrid theme by w0ng (https://github.com/w0ng/vim-hybrid)
-
-*/
-
-/*background color*/
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #1d1f21;
-  -webkit-text-size-adjust: none;
-}
-
-/*selection color*/
-.hljs::selection,
-.hljs span::selection {
-  background: #373b41;
-}
-
-.hljs::-moz-selection,
-.hljs span::-moz-selection {
-  background: #373b41;
-}
-
-/*foreground color*/
-.hljs,
-.hljs-setting .hljs-value,
-.hljs-expression .hljs-variable,
-.hljs-expression .hljs-begin-block,
-.hljs-expression .hljs-end-block,
-.hljs-class .hljs-params,
-.hljs-function .hljs-params,
-.hljs-at_rule .hljs-preprocessor {
-  color: #c5c8c6;
-}
-
-/*color: fg_yellow*/
-.hljs-title,
-.hljs-function .hljs-title,
-.hljs-keyword .hljs-common,
-.hljs-class .hljs-title,
-.hljs-decorator,
-.hljs-tag .hljs-title,
-.hljs-header,
-.hljs-sub,
-.hljs-function {
-  color: #f0c674;
-}
-
-/*color: fg_comment*/
-.hljs-comment,
-.hljs-output .hljs-value,
-.hljs-pi,
-.hljs-shebang,
-.hljs-doctype {
-  color: #707880;
-}
-
-/*color: fg_red*/
-.hljs-number,
-.hljs-symbol,
-.hljs-literal,
-.hljs-deletion,
-.hljs-link_url,
-.hljs-symbol .hljs-string,
-.hljs-argument,
-.hljs-hexcolor,
-.hljs-input .hljs-prompt,
-.hljs-char {
- color: #cc6666
-}
-
-/*color: fg_green*/
-.hljs-string,
-.hljs-special,
-.hljs-doctag,
-.hljs-addition,
-.hljs-important,
-.hljs-tag .hljs-value,
-.hljs-at.rule .hljs-keyword,
-.hljs-regexp,
-.hljs-attr_selector {
-  color: #b5bd68;
-}
-
-/*color: fg_purple*/
-.hljs-variable,
-.hljs-property,
-.hljs-envar,
-.hljs-code,
-.hljs-expression,
-.hljs-localvars,
-.hljs-id,
-.hljs-variable .hljs-filter,
-.hljs-variable .hljs-filter .hljs-keyword,
-.hljs-template_tag .hljs-filter .hljs-keyword,
-.hljs-name {
- color: #b294bb;
-}
-
-/*color: fg_blue*/
-.hljs-statement,
-.hljs-label,
-.hljs-keyword,
-.hljs-xmlDocTag,
-.hljs-function .hljs-keyword,
-.hljs-chunk,
-.hljs-cdata,
-.hljs-link_label,
-.hljs-bullet,
-.hljs-class .hljs-keyword,
-.hljs-smartquote,
-.hljs-method,
-.hljs-list .hljs-title,
-.hljs-tag {
- color: #81a2be;
-}
-
-/*color: fg_aqua*/
-.hljs-pseudo,
-.hljs-exception,
-.hljs-annotation,
-.hljs-subst,
-.hljs-change,
-.hljs-cbracket,
-.hljs-operator,
-.hljs-horizontal_rule,
-.hljs-preprocessor .hljs-keyword,
-.hljs-typedef,
-.hljs-template_tag,
-.hljs-variable,
-.hljs-variable .hljs-filter .hljs-argument,
-.hljs-at_rule,
-.hljs-at_rule .hljs-string,
-.hljs-at_rule .hljs-keyword {
-  color: #8abeb7;
-}
-
-/*color: fg_orange*/
-.hljs-type,
-.hljs-typename,
-.hljs-inheritance .hljs-parent,
-.hljs-constant,
-.hljs-built_in,
-.hljs-setting,
-.hljs-structure,
-.hljs-link_reference,
-.hljs-attribute,
-.hljs-blockquote,
-.hljs-quoted,
-.hljs-class,
-.hljs-header {
-  color: #de935f;
-}
-
-.hljs-emphasis {
-  font-style: italic;
-}
-
-.hljs-strong {
-  font-weight: bold;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/idea.css b/src/javadoc/js/highlight-8.6-java/styles/idea.css
deleted file mode 100644
index 3a343ad005..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/idea.css
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-
-Intellij Idea-like styling (c) Vasily Polovnyov <vast@whiteants.net>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  color: #000;
-  background: #fff;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-subst,
-.hljs-title,
-.json .hljs-value {
-  font-weight: normal;
-  color: #000;
-}
-
-.hljs-comment,
-.diff .hljs-header {
-  color: #808080;
-  font-style: italic;
-}
-
-.hljs-annotation,
-.hljs-decorator,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-doctype,
-.hljs-pi,
-.hljs-chunk,
-.hljs-shebang,
-.apache .hljs-cbracket,
-.hljs-prompt,
-.http .hljs-title {
-  color: #808000;
-}
-
-.hljs-tag,
-.hljs-pi {
-  background: #efefef;
-}
-
-.hljs-tag .hljs-title,
-.hljs-id,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-literal,
-.hljs-keyword,
-.hljs-hexcolor,
-.css .hljs-function,
-.ini .hljs-title,
-.css .hljs-class,
-.hljs-list .hljs-keyword,
-.nginx .hljs-title,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-  color: #000080;
-}
-
-.hljs-attribute,
-.hljs-rule .hljs-keyword,
-.hljs-number,
-.hljs-date,
-.hljs-regexp,
-.tex .hljs-special {
-  font-weight: bold;
-  color: #0000ff;
-}
-
-.hljs-number,
-.hljs-regexp {
-  font-weight: normal;
-}
-
-.hljs-string,
-.hljs-value,
-.hljs-filter .hljs-argument,
-.css .hljs-function .hljs-params,
-.apache .hljs-tag {
-  color: #008000;
-  font-weight: bold;
-}
-
-.hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-char,
-.tex .hljs-formula {
-  color: #000;
-  background: #d0eded;
-  font-style: italic;
-}
-
-.hljs-doctag {
-  text-decoration: underline;
-}
-
-.hljs-variable,
-.hljs-envvar,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in,
-.hljs-name {
-  color: #660e7a;
-}
-
-.hljs-addition {
-  background: #baeeba;
-}
-
-.hljs-deletion {
-  background: #ffc8bd;
-}
-
-.diff .hljs-change {
-  background: #bccff9;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/ir_black.css b/src/javadoc/js/highlight-8.6-java/styles/ir_black.css
deleted file mode 100644
index f0d1e45ecd..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/ir_black.css
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  IR_Black style (c) Vasily Mikhailitchenko <vaskas@programica.ru>
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #000;
-  color: #f8f8f8;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-shebang,
-.hljs-comment {
-  color: #7c7c7c;
-}
-
-.hljs-keyword,
-.hljs-tag,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status,
-.clojure .hljs-attribute {
-  color: #96cbfe;
-}
-
-.hljs-sub .hljs-keyword,
-.method,
-.hljs-list .hljs-title,
-.nginx .hljs-title {
-  color: #ffffb6;
-}
-
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-cdata,
-.hljs-filter .hljs-argument,
-.hljs-attr_selector,
-.apache .hljs-cbracket,
-.hljs-date,
-.coffeescript .hljs-attribute {
-  color: #a8ff60;
-}
-
-.hljs-subst {
-  color: #daefa3;
-}
-
-.hljs-regexp {
-  color: #e9c062;
-}
-
-.hljs-title,
-.hljs-sub .hljs-identifier,
-.hljs-pi,
-.hljs-decorator,
-.tex .hljs-special,
-.hljs-type,
-.hljs-constant,
-.smalltalk .hljs-class,
-.hljs-doctag,
-.nginx .hljs-built_in {
-  color: #ffffb6;
-}
-
-.hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-number,
-.hljs-variable,
-.vbscript,
-.hljs-literal,
-.hljs-name {
-  color: #c6c5fe;
-}
-
-.css .hljs-tag {
-  color: #96cbfe;
-}
-
-.css .hljs-rule .hljs-property,
-.css .hljs-id {
-  color: #ffffb6;
-}
-
-.css .hljs-class {
-  color: #fff;
-}
-
-.hljs-hexcolor {
-  color: #c6c5fe;
-}
-
-.hljs-number {
-  color:#ff73fd;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.7;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/kimbie.dark.css b/src/javadoc/js/highlight-8.6-java/styles/kimbie.dark.css
deleted file mode 100644
index f60e47df2d..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/kimbie.dark.css
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-    Name:     Kimbie (dark)
-    Author:   Jan T. Sott
-    License:  Creative Commons Attribution-ShareAlike 4.0 Unported License
-    URL:      https://github.com/idleberg/Kimbie-highlight.js
-*/
-
-/* Kimbie Comment */
-.hljs-comment,
-.hljs-title {
-  color: #d6baad;
-}
-
-/* Kimbie Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #dc3958;
-}
-
-/* Kimbie Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #f79a32;
-}
-
-/* Kimbie Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #f06431;
-}
-
-/* Kimbie Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #889b4a;
-}
-
-/* Kimbie Aqua */
-.css .hljs-hexcolor {
-  color: #088649;
-}
-
-/* Kimbie Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #8ab1b0;
-}
-
-/* Kimbie Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #98676a;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #221a0f;
-  color: #d3af86;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/kimbie.light.css b/src/javadoc/js/highlight-8.6-java/styles/kimbie.light.css
deleted file mode 100644
index 57fc7761f1..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/kimbie.light.css
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-    Name:     Kimbie (light)
-    Author:   Jan T. Sott
-    License:  Creative Commons Attribution-ShareAlike 4.0 Unported License
-    URL:      https://github.com/idleberg/Kimbie-highlight.js
-*/
-
-/* Kimbie Comment */
-.hljs-comment,
-.hljs-title {
-  color: #a57a4c;
-}
-
-/* Kimbie Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #dc3958;
-}
-
-/* Kimbie Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #f79a32;
-}
-
-/* Kimbie Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #f06431;
-}
-
-/* Kimbie Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #889b4a;
-}
-
-/* Kimbie Aqua */
-.css .hljs-hexcolor {
-  color: #088649;
-}
-
-/* Kimbie Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #8ab1b0;
-}
-
-/* Kimbie Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #98676a;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #fbebd4;
-  color: #84613d;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/magula.css b/src/javadoc/js/highlight-8.6-java/styles/magula.css
deleted file mode 100644
index 13d366b6d3..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/magula.css
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-Description: Magula style for highligh.js
-Author: Ruslan Keba <rukeba@gmail.com>
-Website: http://rukeba.com/
-Version: 1.0
-Date: 2009-01-03
-Music: Aphex Twin / Xtal
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background-color: #f4f4f4;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-subst {
-  color: black;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-parent,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.hljs-addition,
-.hljs-flow,
-.hljs-stream,
-.bash .hljs-variable,
-.apache .hljs-cbracket,
-.coffeescript .hljs-attribute {
-  color: #050;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.diff .hljs-header,
-.hljs-chunk {
-  color: #777;
-}
-
-.hljs-number,
-.hljs-date,
-.hljs-regexp,
-.hljs-literal,
-.hljs-name,
-.smalltalk .hljs-symbol,
-.smalltalk .hljs-char,
-.hljs-change,
-.tex .hljs-special {
-  color: #800;
-}
-
-.hljs-label,
-.ruby .hljs-string,
-.hljs-decorator,
-.hljs-filter .hljs-argument,
-.hljs-localvars,
-.hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-envvar,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in,
-.tex .hljs-formula,
-.hljs-prompt,
-.clojure .hljs-attribute {
-  color: #00e;
-}
-
-.hljs-keyword,
-.hljs-id,
-.hljs-doctag,
-.hljs-title,
-.hljs-built_in,
-.smalltalk .hljs-class,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.xml .hljs-tag,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-  color: navy;
-}
-
-.nginx .hljs-built_in {
-  font-weight: normal;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
-
-/* --- */
-.apache .hljs-tag {
-  font-weight: bold;
-  color: blue;
-}
-
diff --git a/src/javadoc/js/highlight-8.6-java/styles/mono-blue.css b/src/javadoc/js/highlight-8.6-java/styles/mono-blue.css
deleted file mode 100644
index 525cccc0f7..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/mono-blue.css
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Five-color theme from a single blue hue.
-*/
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #eaeef3;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-list .hljs-built_in {
-  color: #00193a;
-}
-
-.hljs-keyword,
-.hljs-title,
-.hljs-important,
-.hljs-request,
-.hljs-header,
-.hljs-doctag {
-  font-weight: bold;
-}
-
-.hljs-comment,
-.hljs-chunk {
-  color: #738191;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-parent,
-.hljs-built_in,
-.hljs-literal,
-.hljs-filename,
-.hljs-value,
-.hljs-addition,
-.hljs-tag,
-.hljs-argument,
-.hljs-link_label,
-.hljs-blockquote,
-.hljs-header,
-.hljs-name {
-  color: #0048ab;
-}
-
-.hljs-decorator,
-.hljs-prompt,
-.hljs-subst,
-.hljs-symbol,
-.hljs-doctype,
-.hljs-regexp,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-pi,
-.hljs-attribute,
-.hljs-attr_selector,
-.hljs-xmlDocTag,
-.hljs-deletion,
-.hljs-shebang,
-.hljs-string .hljs-variable,
-.hljs-link_url,
-.hljs-bullet,
-.hljs-sqbracket,
-.hljs-phony {
-  color: #4c81c9;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/monokai.css b/src/javadoc/js/highlight-8.6-java/styles/monokai.css
deleted file mode 100644
index 5f20abf6d1..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/monokai.css
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-Monokai style - ported by Luigi Maselli - http://grigio.org
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #272822;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-tag,
-.hljs-tag .hljs-title,
-.hljs-keyword,
-.hljs-literal,
-.hljs-strong,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.tex .hljs-special {
-  color: #f92672;
-}
-
-.hljs {
-  color: #ddd;
-}
-
-.hljs .hljs-constant,
-.asciidoc .hljs-code,
-.markdown .hljs-code {
-  color: #66d9ef;
-}
-
-.hljs-code,
-.hljs-class .hljs-title,
-.hljs-header {
-  color: white;
-}
-
-.hljs-link_label,
-.hljs-attribute,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.hljs-value,
-.hljs-regexp {
-  color: #bf79db;
-}
-
-.hljs-link_url,
-.hljs-tag .hljs-value,
-.hljs-string,
-.hljs-bullet,
-.hljs-subst,
-.hljs-title,
-.hljs-emphasis,
-.hljs-type,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.hljs-prompt,
-.hljs-name {
-  color: #a6e22e;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.smartquote,
-.hljs-blockquote,
-.hljs-horizontal_rule,
-.hljs-decorator,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.tex .hljs-formula {
-  color: #75715e;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.css .hljs-id,
-.hljs-doctag,
-.hljs-title,
-.hljs-header,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.diff .hljs-header,
-.hljs-chunk,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.tex .hljs-special,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/monokai_sublime.css b/src/javadoc/js/highlight-8.6-java/styles/monokai_sublime.css
deleted file mode 100644
index 4ae4aebdda..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/monokai_sublime.css
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
-
-Monokai Sublime style. Derived from Monokai by noformnocontent http://nn.mit-license.org/
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #23241f;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs,
-.hljs-tag,
-.css .hljs-rule,
-.css .hljs-value,
-.aspectj .hljs-function,
-.css .hljs-function
-.hljs-preprocessor,
-.hljs-pragma {
-  color: #f8f8f2;
-}
-
-.hljs-strongemphasis,
-.hljs-strong,
-.hljs-emphasis {
-  color: #a8a8a2;
-}
-
-.hljs-bullet,
-.hljs-blockquote,
-.hljs-horizontal_rule,
-.hljs-number,
-.hljs-regexp,
-.alias .hljs-keyword,
-.hljs-literal,
-.hljs-hexcolor {
-  color: #ae81ff;
-}
-
-.hljs-tag .hljs-value,
-.hljs-code,
-.hljs-title,
-.css .hljs-class,
-.hljs-class .hljs-title:last-child {
-  color: #a6e22e;
-}
-
-.hljs-link_url {
-  font-size: 80%;
-}
-
-.hljs-strong,
-.hljs-strongemphasis {
-  font-weight: bold;
-}
-
-.hljs-emphasis,
-.hljs-strongemphasis,
-.hljs-class .hljs-title:last-child,
-.hljs-typename {
-  font-style: italic;
-}
-
-.hljs-keyword,
-.ruby .hljs-class .hljs-keyword:first-child,
-.ruby .hljs-function .hljs-keyword,
-.hljs-function,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.tex .hljs-special,
-.hljs-header,
-.hljs-attribute,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.hljs-tag .hljs-title,
-.hljs-value,
-.alias .hljs-keyword:first-child,
-.css .hljs-tag,
-.css .unit,
-.css .hljs-important {
-  color: #f92672;
-}
-
-.hljs-function .hljs-keyword,
-.hljs-class .hljs-keyword:first-child,
-.hljs-aspect .hljs-keyword:first-child,
-.hljs-constant,
-.hljs-typename,
-.hljs-name,
-.css .hljs-attribute {
-  color: #66d9ef;
-}
-
-.hljs-variable,
-.hljs-params,
-.hljs-class .hljs-title,
-.hljs-aspect .hljs-title {
-  color: #f8f8f2;
-}
-
-.hljs-string,
-.css .hljs-id,
-.hljs-subst,
-.hljs-type,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.hljs-prompt,
-.hljs-link_label,
-.hljs-link_url {
-  color: #e6db74;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.hljs-decorator,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.tex .hljs-formula {
-  color: #75715e;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata,
-.xml .php,
-.php .xml {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/obsidian.css b/src/javadoc/js/highlight-8.6-java/styles/obsidian.css
deleted file mode 100644
index 3886f83a9e..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/obsidian.css
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * Obsidian style
- * ported by Alexander Marenin (http://github.com/ioncreature)
- */
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #282b2e;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.css .hljs-id,
-.tex .hljs-special {
-  color: #93c763;
-}
-
-.hljs-number {
-  color: #ffcd22;
-}
-
-.hljs {
-  color: #e0e2e4;
-}
-
-.css .hljs-tag,
-.css .hljs-pseudo {
-  color: #d0d2b5;
-}
-
-.hljs-attribute,
-.hljs .hljs-constant {
-  color: #668bb0;
-}
-
-.xml .hljs-attribute {
-  color: #b3b689;
-}
-
-.xml .hljs-tag .hljs-value {
-  color: #e8e2b7;
-}
-
-.hljs-code,
-.hljs-class .hljs-title,
-.hljs-header {
-  color: white;
-}
-
-.hljs-class,
-.hljs-hexcolor {
-  color: #93c763;
-}
-
-.hljs-regexp {
-  color: #d39745;
-}
-
-.hljs-at_rule,
-.hljs-at_rule .hljs-keyword {
-  color: #a082bd;
-}
-
-.hljs-doctype {
-  color: #557182;
-}
-
-.hljs-link_url,
-.hljs-tag,
-.hljs-tag .hljs-title,
-.hljs-bullet,
-.hljs-subst,
-.hljs-emphasis,
-.hljs-type,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.tex .hljs-command,
-.hljs-prompt,
-.hljs-name {
-  color: #8cbbad;
-}
-
-.hljs-string {
-  color: #ec7600;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.hljs-blockquote,
-.hljs-horizontal_rule,
-.hljs-decorator,
-.hljs-pi,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket,
-.tex .hljs-formula {
-  color: #818e96;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.css .hljs-id,
-.hljs-doctag,
-.hljs-title,
-.hljs-header,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.diff .hljs-header,
-.hljs-chunk,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.tex .hljs-special,
-.hljs-request,
-.hljs-at_rule .hljs-keyword,
-.hljs-status {
-  font-weight: bold;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/paraiso.dark.css b/src/javadoc/js/highlight-8.6-java/styles/paraiso.dark.css
deleted file mode 100644
index 0f7eedbf60..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/paraiso.dark.css
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-    Paraíso (dark)
-    Created by Jan T. Sott (http://github.com/idleberg)
-    Inspired by the art of Rubens LP (http://www.rubenslp.com.br)
-*/
-
-/* Paraíso Comment */
-.hljs-comment,
-.hljs-title {
-  color: #8d8687;
-}
-
-/* Paraíso Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ef6155;
-}
-
-/* Paraíso Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #f99b15;
-}
-
-/* Paraíso Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #fec418;
-}
-
-/* Paraíso Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #48b685;
-}
-
-/* Paraíso Aqua */
-.css .hljs-hexcolor {
-  color: #5bc4bf;
-}
-
-/* Paraíso Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #06b6ef;
-}
-
-/* Paraíso Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #815ba4;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #2f1e2e;
-  color: #a39e9b;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/paraiso.light.css b/src/javadoc/js/highlight-8.6-java/styles/paraiso.light.css
deleted file mode 100644
index 1562007f2b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/paraiso.light.css
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-    Paraíso (light)
-    Created by Jan T. Sott (http://github.com/idleberg)
-    Inspired by the art of Rubens LP (http://www.rubenslp.com.br)
-*/
-
-/* Paraíso Comment */
-.hljs-comment,
-.hljs-title {
-  color: #776e71;
-}
-
-/* Paraíso Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.hljs-name,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ef6155;
-}
-
-/* Paraíso Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #f99b15;
-}
-
-/* Paraíso Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #fec418;
-}
-
-/* Paraíso Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #48b685;
-}
-
-/* Paraíso Aqua */
-.css .hljs-hexcolor {
-  color: #5bc4bf;
-}
-
-/* Paraíso Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #06b6ef;
-}
-
-/* Paraíso Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #815ba4;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #e7e9db;
-  color: #4f424c;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/pojoaque.css b/src/javadoc/js/highlight-8.6-java/styles/pojoaque.css
deleted file mode 100644
index 177ab5cb80..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/pojoaque.css
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-
-Pojoaque Style by Jason Tate
-http://web-cms-designs.com/ftopict-10-pojoaque-style-for-highlight-js-code-highlighter.html
-Based on Solarized Style from http://ethanschoonover.com/solarized
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  color: #dccf8f;
-  background: url(pojoaque.jpg) repeat scroll left top #181914;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.diff .hljs-header,
-.hljs-doctype,
-.lisp .hljs-string {
-  color: #586e75;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.css .rule .hljs-keyword,
-.hljs-winutils,
-.javascript .hljs-title,
-.method,
-.hljs-addition,
-.css .hljs-tag,
-.hljs-list .hljs-keyword,
-.nginx .hljs-title {
-  color: #b64926;
-}
-
-.hljs-number,
-.hljs-command,
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-doctag,
-.tex .hljs-formula,
-.hljs-regexp,
-.hljs-hexcolor {
-  color: #468966;
-}
-
-.hljs-title,
-.hljs-localvars,
-.hljs-function .hljs-title,
-.hljs-chunk,
-.hljs-decorator,
-.hljs-built_in,
-.hljs-identifier,
-.hljs-name,
-.hljs-id {
-  color: #ffb03b;
-}
-
-.hljs-attribute,
-.hljs-variable,
-.lisp .hljs-body,
-.smalltalk .hljs-number,
-.hljs-constant,
-.hljs-class .hljs-title,
-.hljs-parent,
-.hljs-type {
-  color: #b58900;
-}
-
-.css .hljs-attribute {
-  color: #b89859;
-}
-
-.css .hljs-number,
-.css .hljs-hexcolor {
-  color: #dccf8f;
-}
-
-.css .hljs-class {
-  color: #d3a60c;
-}
-
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-pi,
-.hljs-shebang,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.diff .hljs-change,
-.hljs-special,
-.hljs-attr_selector,
-.hljs-important,
-.hljs-subst,
-.hljs-cdata {
-  color: #cb4b16;
-}
-
-.hljs-deletion {
-  color: #dc322f;
-}
-
-.tex .hljs-formula {
-  background: #073642;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/pojoaque.jpg b/src/javadoc/js/highlight-8.6-java/styles/pojoaque.jpg
deleted file mode 100644
index 9c07d4ab40..0000000000
Binary files a/src/javadoc/js/highlight-8.6-java/styles/pojoaque.jpg and /dev/null differ
diff --git a/src/javadoc/js/highlight-8.6-java/styles/railscasts.css b/src/javadoc/js/highlight-8.6-java/styles/railscasts.css
deleted file mode 100644
index 50507dfbb2..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/railscasts.css
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-
-Railscasts-like style (c) Visoft, Inc. (Damien White)
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #232323;
-  color: #e6e1dc;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.hljs-shebang {
-  color: #bc9458;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.ruby .hljs-function .hljs-keyword,
-.hljs-request,
-.hljs-status,
-.nginx .hljs-title,
-.method,
-.hljs-list .hljs-title {
-  color: #c26230;
-}
-
-.hljs-string,
-.hljs-number,
-.hljs-regexp,
-.hljs-tag .hljs-value,
-.hljs-cdata,
-.hljs-filter .hljs-argument,
-.hljs-attr_selector,
-.apache .hljs-cbracket,
-.hljs-date,
-.tex .hljs-command,
-.asciidoc .hljs-link_label,
-.markdown .hljs-link_label {
-  color: #a5c261;
-}
-
-.hljs-subst {
-  color: #519f50;
-}
-
-.hljs-tag,
-.hljs-tag .hljs-keyword,
-.hljs-tag .hljs-title,
-.hljs-doctype,
-.hljs-sub .hljs-identifier,
-.hljs-pi,
-.input_number {
-  color: #e8bf6a;
-}
-
-.hljs-identifier {
-  color: #d0d0ff;
-}
-
-.hljs-class .hljs-title,
-.hljs-type,
-.smalltalk .hljs-class,
-.hljs-doctag {
-  text-decoration: none;
-}
-
-.hljs-constant,
-.hljs-name {
-  color: #da4939;
-}
-
-
-.hljs-symbol,
-.hljs-built_in,
-.ruby .hljs-symbol .hljs-string,
-.ruby .hljs-symbol .hljs-identifier,
-.asciidoc .hljs-link_url,
-.markdown .hljs-link_url,
-.hljs-attribute {
-  color: #6d9cbe;
-}
-
-.asciidoc .hljs-link_url,
-.markdown .hljs-link_url {
-  text-decoration: underline;
-}
-
-
-
-.hljs-params,
-.hljs-variable,
-.clojure .hljs-attribute {
-  color: #d0d0ff;
-}
-
-.css .hljs-tag,
-.hljs-rule .hljs-property,
-.hljs-pseudo,
-.tex .hljs-special {
-  color: #cda869;
-}
-
-.css .hljs-class {
-  color: #9b703f;
-}
-
-.hljs-rule .hljs-keyword {
-  color: #c5af75;
-}
-
-.hljs-rule .hljs-value {
-  color: #cf6a4c;
-}
-
-.css .hljs-id {
-  color: #8b98ab;
-}
-
-.hljs-annotation,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in {
-  color: #9b859d;
-}
-
-.hljs-preprocessor,
-.hljs-preprocessor *,
-.hljs-pragma {
-  color: #8996a8 !important;
-}
-
-.hljs-hexcolor,
-.css .hljs-value .hljs-number {
-  color: #a5c261;
-}
-
-.hljs-title,
-.hljs-decorator,
-.css .hljs-function {
-  color: #ffc66d;
-}
-
-.diff .hljs-header,
-.hljs-chunk {
-  background-color: #2f33ab;
-  color: #e6e1dc;
-  display: inline-block;
-  width: 100%;
-}
-
-.diff .hljs-change {
-  background-color: #4a410d;
-  color: #f8f8f8;
-  display: inline-block;
-  width: 100%;
-}
-
-.hljs-addition {
-  background-color: #144212;
-  color: #e6e1dc;
-  display: inline-block;
-  width: 100%;
-}
-
-.hljs-deletion {
-  background-color: #600;
-  color: #e6e1dc;
-  display: inline-block;
-  width: 100%;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.7;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/rainbow.css b/src/javadoc/js/highlight-8.6-java/styles/rainbow.css
deleted file mode 100644
index ac536a7f62..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/rainbow.css
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-
-Style with support for rainbow parens
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #474949;
-  color: #d1d9e1;
-  -webkit-text-size-adjust: none;
-}
-
-
-.hljs-body,
-.hljs-collection {
-   color: #d1d9e1;
-}
-
-.hljs-comment,
-.diff .hljs-header,
-.hljs-doctype,
-.lisp .hljs-string {
-  color: #969896;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.clojure .hljs-attribute,
-.hljs-winutils,
-.javascript .hljs-title,
-.hljs-addition,
-.css .hljs-tag {
-  color: #cc99cc;
-}
-
-.hljs-number { color: #f99157; }
-
-.hljs-command,
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-doctag,
-.tex .hljs-formula,
-.hljs-regexp,
-.hljs-hexcolor {
-  color: #8abeb7;
-}
-
-.hljs-title,
-.hljs-localvars,
-.hljs-function .hljs-title,
-.hljs-chunk,
-.hljs-decorator,
-.hljs-built_in,
-.hljs-identifier {
-  color: #b5bd68;
-}
-
-.hljs-class .hljs-keyword {
-  color: #f2777a;
-}
-
-.hljs-variable,
-.smalltalk .hljs-number,
-.hljs-constant,
-.hljs-class .hljs-title,
-.hljs-parent,
-.haskell .hljs-label,
-.hljs-id,
-.hljs-name {
-   color: #ffcc66;
-}
-
-.hljs-tag .hljs-title,
-.hljs-rule .hljs-property,
-.django .hljs-tag .hljs-keyword {
-  font-weight: bold;
-}
-
-.hljs-attribute {
-  color: #81a2be;
-}
-
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-pi,
-.hljs-shebang,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.diff .hljs-change,
-.hljs-special,
-.hljs-attr_selector,
-.hljs-important,
-.hljs-subst,
-.hljs-cdata {
-  color: #f99157;
-}
-
-.hljs-deletion {
-  color: #dc322f;
-}
-
-.tex .hljs-formula {
-  background: #eee8d5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/school_book.css b/src/javadoc/js/highlight-8.6-java/styles/school_book.css
deleted file mode 100644
index 9e096d9b54..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/school_book.css
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-
-School Book style from goldblog.com.ua (c) Zaripov Yura <yur4ik7@ukr.net>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 15px 0.5em 0.5em 30px;
-  font-size: 11px !important;
-  line-height:16px !important;
-  -webkit-text-size-adjust: none;
-}
-
-pre{
-  background:#f6f6ae url(school_book.png);
-  border-top: solid 2px #d2e8b9;
-  border-bottom: solid 1px #d2e8b9;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.hljs-change,
-.hljs-winutils,
-.hljs-flow,
-.nginx .hljs-title,
-.tex .hljs-special {
-  color:#005599;
-  font-weight:bold;
-}
-
-.hljs,
-.hljs-subst,
-.hljs-tag .hljs-keyword {
-  color: #3e5915;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-type,
-.hljs-tag .hljs-value,
-.css .hljs-rule .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.ruby .hljs-class .hljs-parent,
-.hljs-built_in,
-.django .hljs-template_tag,
-.django .hljs-variable,
-.smalltalk .hljs-class,
-.ruby .hljs-string,
-.django .hljs-filter .hljs-argument,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-addition,
-.hljs-stream,
-.hljs-envvar,
-.apache .hljs-tag,
-.apache .hljs-cbracket,
-.nginx .hljs-built_in,
-.tex .hljs-command,
-.coffeescript .hljs-attribute,
-.hljs-name {
-  color: #2c009f;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.hljs-decorator,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-shebang,
-.apache .hljs-sqbracket {
-  color: #e60415;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.css .hljs-id,
-.hljs-doctag,
-.hljs-title,
-.hljs-type,
-.vbscript .hljs-built_in,
-.rsl .hljs-built_in,
-.smalltalk .hljs-class,
-.xml .hljs-tag .hljs-title,
-.diff .hljs-header,
-.hljs-chunk,
-.hljs-winutils,
-.bash .hljs-variable,
-.apache .hljs-tag,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status {
-  font-weight: bold;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/school_book.png b/src/javadoc/js/highlight-8.6-java/styles/school_book.png
deleted file mode 100644
index 956e9790a0..0000000000
Binary files a/src/javadoc/js/highlight-8.6-java/styles/school_book.png and /dev/null differ
diff --git a/src/javadoc/js/highlight-8.6-java/styles/solarized_dark.css b/src/javadoc/js/highlight-8.6-java/styles/solarized_dark.css
deleted file mode 100644
index f1bf4ec49d..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/solarized_dark.css
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-
-Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull <sourdrums@gmail.com>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #002b36;
-  color: #839496;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.diff .hljs-header,
-.hljs-doctype,
-.hljs-pi,
-.lisp .hljs-string {
-  color: #586e75;
-}
-
-/* Solarized Green */
-.hljs-keyword,
-.hljs-winutils,
-.method,
-.hljs-addition,
-.css .hljs-tag,
-.hljs-request,
-.hljs-status,
-.nginx .hljs-title {
-  color: #859900;
-}
-
-/* Solarized Cyan */
-.hljs-number,
-.hljs-command,
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.hljs-doctag,
-.tex .hljs-formula,
-.hljs-regexp,
-.hljs-hexcolor,
-.hljs-link_url {
-  color: #2aa198;
-}
-
-/* Solarized Blue */
-.hljs-title,
-.hljs-localvars,
-.hljs-chunk,
-.hljs-decorator,
-.hljs-built_in,
-.hljs-identifier,
-.vhdl .hljs-literal,
-.hljs-id,
-.css .hljs-function,
-.hljs-name {
-  color: #268bd2;
-}
-
-/* Solarized Yellow */
-.hljs-attribute,
-.hljs-variable,
-.lisp .hljs-body,
-.smalltalk .hljs-number,
-.hljs-constant,
-.hljs-class .hljs-title,
-.hljs-parent,
-.hljs-type,
-.hljs-link_reference {
-  color: #b58900;
-}
-
-/* Solarized Orange */
-.hljs-preprocessor,
-.hljs-preprocessor .hljs-keyword,
-.hljs-pragma,
-.hljs-shebang,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.diff .hljs-change,
-.hljs-special,
-.hljs-attr_selector,
-.hljs-subst,
-.hljs-cdata,
-.css .hljs-pseudo,
-.hljs-header {
-  color: #cb4b16;
-}
-
-/* Solarized Red */
-.hljs-deletion,
-.hljs-important {
-  color: #dc322f;
-}
-
-/* Solarized Violet */
-.hljs-link_label {
-  color: #6c71c4;
-}
-
-.tex .hljs-formula {
-  background: #073642;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/solarized_light.css b/src/javadoc/js/highlight-8.6-java/styles/solarized_light.css
deleted file mode 100644
index 04adb2136a..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/solarized_light.css
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-
-Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull <sourdrums@gmail.com>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #fdf6e3;
-  color: #657b83;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.diff .hljs-header,
-.hljs-doctype,
-.hljs-pi,
-.lisp .hljs-string {
-  color: #93a1a1;
-}
-
-/* Solarized Green */
-.hljs-keyword,
-.hljs-winutils,
-.method,
-.hljs-addition,
-.css .hljs-tag,
-.hljs-request,
-.hljs-status,
-.nginx .hljs-title {
-  color: #859900;
-}
-
-/* Solarized Cyan */
-.hljs-number,
-.hljs-command,
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.hljs-doctag,
-.tex .hljs-formula,
-.hljs-regexp,
-.hljs-hexcolor,
-.hljs-link_url {
-  color: #2aa198;
-}
-
-/* Solarized Blue */
-.hljs-title,
-.hljs-localvars,
-.hljs-chunk,
-.hljs-decorator,
-.hljs-built_in,
-.hljs-identifier,
-.vhdl .hljs-literal,
-.hljs-id,
-.css .hljs-function,
-.hljs-name {
-  color: #268bd2;
-}
-
-/* Solarized Yellow */
-.hljs-attribute,
-.hljs-variable,
-.lisp .hljs-body,
-.smalltalk .hljs-number,
-.hljs-constant,
-.hljs-class .hljs-title,
-.hljs-parent,
-.hljs-type,
-.hljs-link_reference {
-  color: #b58900;
-}
-
-/* Solarized Orange */
-.hljs-preprocessor,
-.hljs-preprocessor .hljs-keyword,
-.hljs-pragma,
-.hljs-shebang,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.diff .hljs-change,
-.hljs-special,
-.hljs-attr_selector,
-.hljs-subst,
-.hljs-cdata,
-.css .hljs-pseudo,
-.hljs-header {
-  color: #cb4b16;
-}
-
-/* Solarized Red */
-.hljs-deletion,
-.hljs-important {
-  color: #dc322f;
-}
-
-/* Solarized Violet */
-.hljs-link_label {
-  color: #6c71c4;
-}
-
-.tex .hljs-formula {
-  background: #eee8d5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/sunburst.css b/src/javadoc/js/highlight-8.6-java/styles/sunburst.css
deleted file mode 100644
index 4f468f1270..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/sunburst.css
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-
-Sunburst-like style (c) Vasily Polovnyov <vast@whiteants.net>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #000;
-  color: #f8f8f8;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment {
-  color: #aeaeae;
-  font-style: italic;
-}
-
-.hljs-keyword,
-.ruby .hljs-function .hljs-keyword,
-.hljs-request,
-.hljs-status,
-.nginx .hljs-title {
-  color: #e28964;
-}
-
-.hljs-function .hljs-keyword,
-.hljs-sub .hljs-keyword,
-.method,
-.hljs-list .hljs-title {
-  color: #99cf50;
-}
-
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-cdata,
-.hljs-filter .hljs-argument,
-.hljs-attr_selector,
-.apache .hljs-cbracket,
-.hljs-date,
-.tex .hljs-command,
-.coffeescript .hljs-attribute,
-.hljs-name {
-  color: #65b042;
-}
-
-.hljs-subst {
-  color: #daefa3;
-}
-
-.hljs-regexp {
-  color: #e9c062;
-}
-
-.hljs-title,
-.hljs-sub .hljs-identifier,
-.hljs-pi,
-.hljs-tag,
-.hljs-tag .hljs-keyword,
-.hljs-decorator,
-.hljs-shebang,
-.hljs-prompt {
-  color: #89bdff;
-}
-
-.hljs-class .hljs-title,
-.hljs-type,
-.smalltalk .hljs-class,
-.hljs-doctag {
-  text-decoration: underline;
-}
-
-.hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-number {
-  color: #3387cc;
-}
-
-.hljs-params,
-.hljs-variable,
-.clojure .hljs-attribute {
-  color: #3e87e3;
-}
-
-.css .hljs-tag,
-.hljs-rule .hljs-property,
-.hljs-pseudo,
-.tex .hljs-special {
-  color: #cda869;
-}
-
-.css .hljs-class {
-  color: #9b703f;
-}
-
-.hljs-rule .hljs-keyword {
-  color: #c5af75;
-}
-
-.hljs-rule .hljs-value {
-  color: #cf6a4c;
-}
-
-.css .hljs-id {
-  color: #8b98ab;
-}
-
-.hljs-annotation,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in {
-  color: #9b859d;
-}
-
-.hljs-preprocessor,
-.hljs-pragma {
-  color: #8996a8;
-}
-
-.hljs-hexcolor,
-.css .hljs-value .hljs-number {
-  color: #dd7b3b;
-}
-
-.css .hljs-function {
-  color: #dad085;
-}
-
-.diff .hljs-header,
-.hljs-chunk,
-.tex .hljs-formula {
-  background-color: #0e2231;
-  color: #f8f8f8;
-  font-style: italic;
-}
-
-.diff .hljs-change {
-  background-color: #4a410d;
-  color: #f8f8f8;
-}
-
-.hljs-addition {
-  background-color: #253b22;
-  color: #f8f8f8;
-}
-
-.hljs-deletion {
-  background-color: #420e09;
-  color: #f8f8f8;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-blue.css b/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-blue.css
deleted file mode 100644
index 96e52270bd..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-blue.css
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Tomorrow Night Blue Theme */
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-/* Original theme - https://github.com/chriskempson/tomorrow-theme */
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-
-/* Tomorrow Comment */
-.hljs-comment {
-  color: #7285b7;
-}
-
-/* Tomorrow Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #ff9da4;
-}
-
-/* Tomorrow Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #ffc58f;
-}
-
-/* Tomorrow Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #ffeead;
-}
-
-/* Tomorrow Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.hljs-name,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #d1f1a9;
-}
-
-/* Tomorrow Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #99ffff;
-}
-
-/* Tomorrow Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #bbdaff;
-}
-
-/* Tomorrow Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #ebbbff;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #002451;
-  color: white;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-bright.css b/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-bright.css
deleted file mode 100644
index 00604fbca7..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-bright.css
+++ /dev/null
@@ -1,95 +0,0 @@
-/* Tomorrow Night Bright Theme */
-/* Original theme - https://github.com/chriskempson/tomorrow-theme */
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-
-/* Tomorrow Comment */
-.hljs-comment {
-  color: #969896;
-}
-
-/* Tomorrow Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #d54e53;
-}
-
-/* Tomorrow Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #e78c45;
-}
-
-/* Tomorrow Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #e7c547;
-}
-
-/* Tomorrow Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.hljs-name,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #b9ca4a;
-}
-
-/* Tomorrow Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #70c0b1;
-}
-
-/* Tomorrow Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #7aa6da;
-}
-
-/* Tomorrow Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #c397d8;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: black;
-  color: #eaeaea;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-eighties.css b/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-eighties.css
deleted file mode 100644
index 1f2791fbd6..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night-eighties.css
+++ /dev/null
@@ -1,95 +0,0 @@
-/* Tomorrow Night Eighties Theme */
-/* Original theme - https://github.com/chriskempson/tomorrow-theme */
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-
-/* Tomorrow Comment */
-.hljs-comment {
-  color: #999999;
-}
-
-/* Tomorrow Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #f2777a;
-}
-
-/* Tomorrow Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #f99157;
-}
-
-/* Tomorrow Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #ffcc66;
-}
-
-/* Tomorrow Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.hljs-name,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #99cc99;
-}
-
-/* Tomorrow Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #66cccc;
-}
-
-/* Tomorrow Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #6699cc;
-}
-
-/* Tomorrow Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #cc99cc;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #2d2d2d;
-  color: #cccccc;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night.css b/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night.css
deleted file mode 100644
index 9788e0846b..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/tomorrow-night.css
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Tomorrow Night Theme */
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-/* Original theme - https://github.com/chriskempson/tomorrow-theme */
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-
-/* Tomorrow Comment */
-.hljs-comment {
-  color: #969896;
-}
-
-/* Tomorrow Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #cc6666;
-}
-
-/* Tomorrow Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #de935f;
-}
-
-/* Tomorrow Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #f0c674;
-}
-
-/* Tomorrow Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.hljs-name,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #b5bd68;
-}
-
-/* Tomorrow Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #8abeb7;
-}
-
-/* Tomorrow Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #81a2be;
-}
-
-/* Tomorrow Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #b294bb;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: #1d1f21;
-  color: #c5c8c6;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/tomorrow.css b/src/javadoc/js/highlight-8.6-java/styles/tomorrow.css
deleted file mode 100644
index fb2e161a90..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/tomorrow.css
+++ /dev/null
@@ -1,93 +0,0 @@
-/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
-
-/* Tomorrow Comment */
-.hljs-comment {
-  color: #8e908c;
-}
-
-/* Tomorrow Red */
-.hljs-variable,
-.hljs-attribute,
-.hljs-tag,
-.hljs-regexp,
-.ruby .hljs-constant,
-.xml .hljs-tag .hljs-title,
-.xml .hljs-pi,
-.xml .hljs-doctype,
-.html .hljs-doctype,
-.css .hljs-id,
-.css .hljs-class,
-.css .hljs-pseudo {
-  color: #c82829;
-}
-
-/* Tomorrow Orange */
-.hljs-number,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-built_in,
-.hljs-literal,
-.hljs-params,
-.hljs-constant {
-  color: #f5871f;
-}
-
-/* Tomorrow Yellow */
-.ruby .hljs-class .hljs-title,
-.css .hljs-rule .hljs-attribute {
-  color: #eab700;
-}
-
-/* Tomorrow Green */
-.hljs-string,
-.hljs-value,
-.hljs-inheritance,
-.hljs-header,
-.hljs-name,
-.ruby .hljs-symbol,
-.xml .hljs-cdata {
-  color: #718c00;
-}
-
-/* Tomorrow Aqua */
-.hljs-title,
-.css .hljs-hexcolor {
-  color: #3e999f;
-}
-
-/* Tomorrow Blue */
-.hljs-function,
-.python .hljs-decorator,
-.python .hljs-title,
-.ruby .hljs-function .hljs-title,
-.ruby .hljs-title .hljs-keyword,
-.perl .hljs-sub,
-.javascript .hljs-title,
-.coffeescript .hljs-title {
-  color: #4271ae;
-}
-
-/* Tomorrow Purple */
-.hljs-keyword,
-.javascript .hljs-function {
-  color: #8959a8;
-}
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  background: white;
-  color: #4d4d4c;
-  padding: 0.5em;
-  -webkit-text-size-adjust: none;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/vs.css b/src/javadoc/js/highlight-8.6-java/styles/vs.css
deleted file mode 100644
index 25d4308669..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/vs.css
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-
-Visual Studio-like style based on original C# coloring by Jason Diamond <jason@diamond.name>
-
-*/
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: white;
-  color: black;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment,
-.hljs-annotation,
-.diff .hljs-header,
-.hljs-chunk,
-.apache .hljs-cbracket {
-  color: #008000;
-}
-
-.hljs-keyword,
-.hljs-id,
-.hljs-built_in,
-.smalltalk .hljs-class,
-.hljs-winutils,
-.bash .hljs-variable,
-.tex .hljs-command,
-.hljs-request,
-.hljs-status,
-.nginx .hljs-title,
-.xml .hljs-tag,
-.xml .hljs-tag .hljs-value {
-  color: #00f;
-}
-
-.hljs-string,
-.hljs-title,
-.hljs-parent,
-.hljs-tag .hljs-value,
-.hljs-rule .hljs-value,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.hljs-template_tag,
-.django .hljs-variable,
-.hljs-addition,
-.hljs-flow,
-.hljs-stream,
-.apache .hljs-tag,
-.hljs-date,
-.tex .hljs-formula,
-.coffeescript .hljs-attribute,
-.hljs-name {
-  color: #a31515;
-}
-
-.ruby .hljs-string,
-.hljs-decorator,
-.hljs-filter .hljs-argument,
-.hljs-localvars,
-.hljs-array,
-.hljs-attr_selector,
-.hljs-pseudo,
-.hljs-pi,
-.hljs-doctype,
-.hljs-deletion,
-.hljs-envvar,
-.hljs-shebang,
-.hljs-preprocessor,
-.hljs-pragma,
-.userType,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in,
-.tex .hljs-special,
-.hljs-prompt {
-  color: #2b91af;
-}
-
-.hljs-doctag,
-.hljs-xmlDocTag {
-  color: #808080;
-}
-
-.hljs-type,
-.hljs-typename { font-weight: bold; }
-
-.vhdl .hljs-string { color: #666666; }
-.vhdl .hljs-literal { color: #a31515; }
-.vhdl .hljs-attribute { color: #00b0e8; }
-
-.xml .hljs-attribute { color: #f00; }
diff --git a/src/javadoc/js/highlight-8.6-java/styles/xcode.css b/src/javadoc/js/highlight-8.6-java/styles/xcode.css
deleted file mode 100644
index 21bf1ff6c3..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/xcode.css
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
-
-XCode style (c) Angel Garcia <angelgarcia.mail@gmail.com>
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #fff;
-  color: black;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-comment {
-  color: #006a00;
-}
-
-.hljs-keyword,
-.hljs-literal,
-.nginx .hljs-title {
-  color: #aa0d91;
-}
-.method,
-.hljs-list .hljs-title,
-.hljs-tag .hljs-title,
-.setting .hljs-value,
-.hljs-winutils,
-.tex .hljs-command,
-.http .hljs-title,
-.hljs-request,
-.hljs-status,
-.hljs-name {
-  color: #008;
-}
-
-.hljs-envvar,
-.tex .hljs-special {
-  color: #660;
-}
-
-.hljs-string {
-  color: #c41a16;
-}
-.hljs-tag .hljs-value,
-.hljs-cdata,
-.hljs-filter .hljs-argument,
-.hljs-attr_selector,
-.apache .hljs-cbracket,
-.hljs-date,
-.hljs-regexp {
-  color: #080;
-}
-
-.hljs-sub .hljs-identifier,
-.hljs-pi,
-.hljs-tag,
-.hljs-tag .hljs-keyword,
-.hljs-decorator,
-.ini .hljs-title,
-.hljs-shebang,
-.hljs-prompt,
-.hljs-hexcolor,
-.hljs-rule .hljs-value,
-.hljs-symbol,
-.hljs-symbol .hljs-string,
-.hljs-number,
-.css .hljs-function,
-.hljs-function .hljs-title,
-.coffeescript .hljs-attribute {
-  color: #1c00cf;
-}
-
-.hljs-class .hljs-title,
-.smalltalk .hljs-class,
-.hljs-type,
-.hljs-typename,
-.hljs-tag .hljs-attribute,
-.hljs-doctype,
-.hljs-class .hljs-id,
-.hljs-built_in,
-.setting,
-.hljs-params,
-.clojure .hljs-attribute {
-  color: #5c2699;
-}
-
-.hljs-variable {
- color: #3f6e74;
-}
-.css .hljs-tag,
-.hljs-rule .hljs-property,
-.hljs-pseudo,
-.hljs-subst {
-  color: #000;
-}
-
-.css .hljs-class,
-.css .hljs-id {
-  color: #9b703f;
-}
-
-.hljs-value .hljs-important {
-  color: #ff7700;
-  font-weight: bold;
-}
-
-.hljs-rule .hljs-keyword {
-  color: #c5af75;
-}
-
-.hljs-annotation,
-.apache .hljs-sqbracket,
-.nginx .hljs-built_in {
-  color: #9b859d;
-}
-
-.hljs-preprocessor,
-.hljs-preprocessor *,
-.hljs-pragma {
-  color: #643820;
-}
-
-.tex .hljs-formula {
-  background-color: #eee;
-  font-style: italic;
-}
-
-.diff .hljs-header,
-.hljs-chunk {
-  color: #808080;
-  font-weight: bold;
-}
-
-.diff .hljs-change {
-  background-color: #bccff9;
-}
-
-.hljs-addition {
-  background-color: #baeeba;
-}
-
-.hljs-deletion {
-  background-color: #ffc8bd;
-}
-
-.hljs-comment .hljs-doctag {
-  font-weight: bold;
-}
-
-.method .hljs-id {
-  color: #000;
-}
diff --git a/src/javadoc/js/highlight-8.6-java/styles/zenburn.css b/src/javadoc/js/highlight-8.6-java/styles/zenburn.css
deleted file mode 100644
index c7f5bc5a22..0000000000
--- a/src/javadoc/js/highlight-8.6-java/styles/zenburn.css
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-
-Zenburn style from voldmar.ru (c) Vladimir Epifanov <voldmar@voldmar.ru>
-based on dark.css by Ivan Sagalaev
-
-*/
-
-.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 0.5em;
-  background: #3f3f3f;
-  color: #dcdcdc;
-  -webkit-text-size-adjust: none;
-}
-
-.hljs-keyword,
-.hljs-tag,
-.css .hljs-class,
-.css .hljs-id,
-.lisp .hljs-title,
-.nginx .hljs-title,
-.hljs-request,
-.hljs-status,
-.clojure .hljs-attribute {
-  color: #e3ceab;
-}
-
-.django .hljs-template_tag,
-.django .hljs-variable,
-.django .hljs-filter .hljs-argument {
-  color: #dcdcdc;
-}
-
-.hljs-number,
-.hljs-date {
-  color: #8cd0d3;
-}
-
-.dos .hljs-envvar,
-.dos .hljs-stream,
-.hljs-variable,
-.apache .hljs-sqbracket,
-.hljs-name {
-  color: #efdcbc;
-}
-
-.dos .hljs-flow,
-.diff .hljs-change,
-.python .exception,
-.python .hljs-built_in,
-.hljs-literal,
-.tex .hljs-special {
-  color: #efefaf;
-}
-
-.diff .hljs-chunk,
-.hljs-subst {
-  color: #8f8f8f;
-}
-
-.dos .hljs-keyword,
-.hljs-decorator,
-.hljs-title,
-.hljs-type,
-.diff .hljs-header,
-.ruby .hljs-class .hljs-parent,
-.apache .hljs-tag,
-.nginx .hljs-built_in,
-.tex .hljs-command,
-.hljs-prompt {
-  color: #efef8f;
-}
-
-.dos .hljs-winutils,
-.ruby .hljs-symbol,
-.ruby .hljs-symbol .hljs-string,
-.ruby .hljs-string {
-  color: #dca3a3;
-}
-
-.diff .hljs-deletion,
-.hljs-string,
-.hljs-tag .hljs-value,
-.hljs-preprocessor,
-.hljs-pragma,
-.hljs-built_in,
-.smalltalk .hljs-class,
-.smalltalk .hljs-localvars,
-.smalltalk .hljs-array,
-.css .hljs-rule .hljs-value,
-.hljs-attr_selector,
-.hljs-pseudo,
-.apache .hljs-cbracket,
-.tex .hljs-formula,
-.coffeescript .hljs-attribute {
-  color: #cc9393;
-}
-
-.hljs-shebang,
-.diff .hljs-addition,
-.hljs-comment,
-.hljs-annotation,
-.hljs-pi,
-.hljs-doctype {
-  color: #7f9f7f;
-}
-
-.coffeescript .javascript,
-.javascript .xml,
-.tex .hljs-formula,
-.xml .javascript,
-.xml .vbscript,
-.xml .css,
-.xml .hljs-cdata {
-  opacity: 0.5;
-}
-
diff --git a/src/javadoc/js/index.js b/src/javadoc/js/index.js
deleted file mode 100644
index ea46b120ca..0000000000
--- a/src/javadoc/js/index.js
+++ /dev/null
@@ -1,10 +0,0 @@
-var usingOldIE = $.browser.msie && parseInt($.browser.version) < 9;
-if(!usingOldIE) {
-    $("head").append("<link rel=\"shortcut icon\" href=\"{@docRoot}/favicon.ico?v=cafebabe\">");
-    $("head", window.parent.document).append("<link rel=\"shortcut icon\" href=\"{@docRoot}/favicon.ico?v=cafebabe\">");
-    hljs.initHighlightingOnLoad();
-    $("pre.code").css("font-size", "0.9em");
-    injectProjectVersionForJavadocJDK6("Mockito ${project.version} API",
-        "em#mockito-version-header-javadoc7-header",
-        "em#mockito-version-header-javadoc7-footer");
-}
diff --git a/src/javadoc/js/jdk6-project-version-insert.js b/src/javadoc/js/jdk6-project-version-insert.js
deleted file mode 100644
index c305f4e557..0000000000
--- a/src/javadoc/js/jdk6-project-version-insert.js
+++ /dev/null
@@ -1,30 +0,0 @@
-function injectProjectVersionForJavadocJDK6(projectVersionString, javadoc7Header, javadoc7Footer) {
-    // register custom function to remove attributes from an element
-    jQuery.fn.removeAttributes = function() {
-        return this.each(function() {
-            var attributes = $.map(this.attributes, function(item) {
-                return item.name;
-            });
-            var img = $(this);
-            $.each(attributes, function(i, item) {
-                img.removeAttr(item);
-            });
-        });
-    };
-
-    $(function () {
-        /* Add name & version to header for Javadoc 1.6 */
-        $("td.NavBarCell1[colspan=2]").each(function(index, element) {
-            var jqueryTD = $(element);
-            jqueryTD.after(
-                $("<td><em><strong>" + projectVersionString + "</strong></em></td>").attr("class","NavBarCell1").attr("id","project-version-header-javadoc6")
-            );
-            jqueryTD.removeAttr("colspan");
-        });
-        /* Cleans up mess with Javadoc 1.7 */
-        $("body > h1").removeAttributes().attr("class", "bar").attr("title", projectVersionString);
-        /* Cleans up mess with Javadoc 1.7 with Javadoc 1.6 */
-        $("td " + javadoc7Header).remove();
-        $("td " + javadoc7Footer).remove();
-    });
-}
diff --git a/src/javadoc/js/jdk6-project-version-insert.min.js b/src/javadoc/js/jdk6-project-version-insert.min.js
deleted file mode 100644
index 29462955ed..0000000000
--- a/src/javadoc/js/jdk6-project-version-insert.min.js
+++ /dev/null
@@ -1 +0,0 @@
-function injectProjectVersionForJavadocJDK6(t,e,r){jQuery.fn.removeAttributes=function(){return this.each(function(){var t=$.map(this.attributes,function(t){return t.name}),e=$(this);$.each(t,function(t,r){e.removeAttr(r)})})},$(function(){$("td.NavBarCell1[colspan=2]").each(function(e,r){var a=$(r);a.after($("<td><em><strong>"+t+"</strong></em></td>").attr("class","NavBarCell1").attr("id","project-version-header-javadoc6")),a.removeAttr("colspan")}),$("body > h1").removeAttributes().attr("class","bar").attr("title",t),$("td "+e).remove(),$("td "+r).remove()})}
diff --git a/src/javadoc/js/jquery-1.7.min.js b/src/javadoc/js/jquery-1.7.min.js
deleted file mode 100644
index 3ca5e0f5de..0000000000
--- a/src/javadoc/js/jquery-1.7.min.js
+++ /dev/null
@@ -1,4 +0,0 @@
-/*! jQuery v1.7 jquery.com | jquery.org/license */
-(function(a,b){function cA(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cx(a){if(!cm[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){cn||(cn=c.createElement("iframe"),cn.frameBorder=cn.width=cn.height=0),b.appendChild(cn);if(!co||!cn.createElement)co=(cn.contentWindow||cn.contentDocument).document,co.write((c.compatMode==="CSS1Compat"?"<!doctype html>":"")+"<html><body>"),co.close();d=co.createElement(a),co.body.appendChild(d),e=f.css(d,"display"),b.removeChild(cn)}cm[a]=e}return cm[a]}function cw(a,b){var c={};f.each(cs.concat.apply([],cs.slice(0,b)),function(){c[this]=a});return c}function cv(){ct=b}function cu(){setTimeout(cv,0);return ct=f.now()}function cl(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function ck(){try{return new a.XMLHttpRequest}catch(b){}}function ce(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var d=a.dataTypes,e={},g,h,i=d.length,j,k=d[0],l,m,n,o,p;for(g=1;g<i;g++){if(g===1)for(h in a.converters)typeof h=="string"&&(e[h.toLowerCase()]=a.converters[h]);l=k,k=d[g];if(k==="*")k=l;else if(l!=="*"&&l!==k){m=l+" "+k,n=e[m]||e["* "+k];if(!n){p=b;for(o in e){j=o.split(" ");if(j[0]===l||j[0]==="*"){p=e[j[1]+" "+k];if(p){o=e[o],o===!0?n=p:p===!0&&(n=o);break}}}}!n&&!p&&f.error("No conversion from "+m.replace(" "," to ")),n!==!0&&(c=n?n(c):p(o(c)))}}return c}function cd(a,c,d){var e=a.contents,f=a.dataTypes,g=a.responseFields,h,i,j,k;for(i in g)i in d&&(c[g[i]]=d[i]);while(f[0]==="*")f.shift(),h===b&&(h=a.mimeType||c.getResponseHeader("content-type"));if(h)for(i in e)if(e[i]&&e[i].test(h)){f.unshift(i);break}if(f[0]in d)j=f[0];else{for(i in d){if(!f[0]||a.converters[i+" "+f[0]]){j=i;break}k||(k=i)}j=j||k}if(j){j!==f[0]&&f.unshift(j);return d[j]}}function cc(a,b,c,d){if(f.isArray(b))f.each(b,function(b,e){c||bG.test(a)?d(a,e):cc(a+"["+(typeof e=="object"||f.isArray(e)?b:"")+"]",e,c,d)});else if(!c&&b!=null&&typeof b=="object")for(var e in b)cc(a+"["+e+"]",b[e],c,d);else d(a,b)}function cb(a,c){var d,e,g=f.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((g[d]?a:e||(e={}))[d]=c[d]);e&&f.extend(!0,a,e)}function ca(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h=a[f],i=0,j=h?h.length:0,k=a===bV,l;for(;i<j&&(k||!l);i++)l=h[i](c,d,e),typeof l=="string"&&(!k||g[l]?l=b:(c.dataTypes.unshift(l),l=ca(a,c,d,e,l,g)));(k||!l)&&!g["*"]&&(l=ca(a,c,d,e,"*",g));return l}function b_(a){return function(b,c){typeof b!="string"&&(c=b,b="*");if(f.isFunction(c)){var d=b.toLowerCase().split(bR),e=0,g=d.length,h,i,j;for(;e<g;e++)h=d[e],j=/^\+/.test(h),j&&(h=h.substr(1)||"*"),i=a[h]=a[h]||[],i[j?"unshift":"push"](c)}}}function bE(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=b==="width"?bz:bA;if(d>0){c!=="border"&&f.each(e,function(){c||(d-=parseFloat(f.css(a,"padding"+this))||0),c==="margin"?d+=parseFloat(f.css(a,c+this))||0:d-=parseFloat(f.css(a,"border"+this+"Width"))||0});return d+"px"}d=bB(a,b,b);if(d<0||d==null)d=a.style[b]||0;d=parseFloat(d)||0,c&&f.each(e,function(){d+=parseFloat(f.css(a,"padding"+this))||0,c!=="padding"&&(d+=parseFloat(f.css(a,"border"+this+"Width"))||0),c==="margin"&&(d+=parseFloat(f.css(a,c+this))||0)});return d+"px"}function br(a,b){b.src?f.ajax({url:b.src,async:!1,dataType:"script"}):f.globalEval((b.text||b.textContent||b.innerHTML||"").replace(bi,"/*$0*/")),b.parentNode&&b.parentNode.removeChild(b)}function bq(a){var b=(a.nodeName||"").toLowerCase();b==="input"?bp(a):b!=="script"&&typeof a.getElementsByTagName!="undefined"&&f.grep(a.getElementsByTagName("input"),bp)}function bp(a){if(a.type==="checkbox"||a.type==="radio")a.defaultChecked=a.checked}function bo(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bn(a,b){var c;if(b.nodeType===1){b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase();if(c==="object")b.outerHTML=a.outerHTML;else if(c!=="input"||a.type!=="checkbox"&&a.type!=="radio"){if(c==="option")b.selected=a.defaultSelected;else if(c==="input"||c==="textarea")b.defaultValue=a.defaultValue}else a.checked&&(b.defaultChecked=b.checked=a.checked),b.value!==a.value&&(b.value=a.value);b.removeAttribute(f.expando)}}function bm(a,b){if(b.nodeType===1&&!!f.hasData(a)){var c,d,e,g=f._data(a),h=f._data(b,g),i=g.events;if(i){delete h.handle,h.events={};for(c in i)for(d=0,e=i[c].length;d<e;d++)f.event.add(b,c+(i[c][d].namespace?".":"")+i[c][d].namespace,i[c][d],i[c][d].data)}h.data&&(h.data=f.extend({},h.data))}}function bl(a,b){return f.nodeName(a,"table")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function X(a){var b=Y.split(" "),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function W(a,b,c){b=b||0;if(f.isFunction(b))return f.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return f.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=f.grep(a,function(a){return a.nodeType===1});if(R.test(b))return f.filter(b,d,!c);b=f.filter(b,d)}return f.grep(a,function(a,d){return f.inArray(a,b)>=0===c})}function V(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function N(){return!0}function M(){return!1}function n(a,b,c){var d=b+"defer",e=b+"queue",g=b+"mark",h=f._data(a,d);h&&(c==="queue"||!f._data(a,e))&&(c==="mark"||!f._data(a,g))&&setTimeout(function(){!f._data(a,e)&&!f._data(a,g)&&(f.removeData(a,d,!0),h.fire())},0)}function m(a){for(var b in a){if(b==="data"&&f.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function l(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(k,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:f.isNumeric(d)?parseFloat(d):j.test(d)?f.parseJSON(d):d}catch(g){}f.data(a,c,d)}else d=b}return d}function h(a){var b=g[a]={},c,d;a=a.split(/\s+/);for(c=0,d=a.length;c<d;c++)b[a[c]]=!0;return b}var c=a.document,d=a.navigator,e=a.location,f=function(){function K(){if(!e.isReady){try{c.documentElement.doScroll("left")}catch(a){setTimeout(K,1);return}e.ready()}}var e=function(a,b){return new e.fn.init(a,b,h)},f=a.jQuery,g=a.$,h,i=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,j=/\S/,k=/^\s+/,l=/\s+$/,m=/\d/,n=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,o=/^[\],:{}\s]*$/,p=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,q=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,r=/(?:^|:|,)(?:\s*\[)+/g,s=/(webkit)[ \/]([\w.]+)/,t=/(opera)(?:.*version)?[ \/]([\w.]+)/,u=/(msie) ([\w.]+)/,v=/(mozilla)(?:.*? rv:([\w.]+))?/,w=/-([a-z]|[0-9])/ig,x=/^-ms-/,y=function(a,b){return(b+"").toUpperCase()},z=d.userAgent,A,B,C,D=Object.prototype.toString,E=Object.prototype.hasOwnProperty,F=Array.prototype.push,G=Array.prototype.slice,H=String.prototype.trim,I=Array.prototype.indexOf,J={};e.fn=e.prototype={constructor:e,init:function(a,d,f){var g,h,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!d&&c.body){this.context=c,this[0]=c.body,this.selector=a,this.length=1;return this}if(typeof a=="string"){a.charAt(0)!=="<"||a.charAt(a.length-1)!==">"||a.length<3?g=i.exec(a):g=[null,a,null];if(g&&(g[1]||!d)){if(g[1]){d=d instanceof e?d[0]:d,k=d?d.ownerDocument||d:c,j=n.exec(a),j?e.isPlainObject(d)?(a=[c.createElement(j[1])],e.fn.attr.call(a,d,!0)):a=[k.createElement(j[1])]:(j=e.buildFragment([g[1]],[k]),a=(j.cacheable?e.clone(j.fragment):j.fragment).childNodes);return e.merge(this,a)}h=c.getElementById(g[2]);if(h&&h.parentNode){if(h.id!==g[2])return f.find(a);this.length=1,this[0]=h}this.context=c,this.selector=a;return this}return!d||d.jquery?(d||f).find(a):this.constructor(d).find(a)}if(e.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return e.makeArray(a,this)},selector:"",jquery:"1.7",length:0,size:function(){return this.length},toArray:function(){return G.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=this.constructor();e.isArray(a)?F.apply(d,a):e.merge(d,a),d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")");return d},each:function(a,b){return e.each(this,a,b)},ready:function(a){e.bindReady(),B.add(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(G.apply(this,arguments),"slice",G.call(arguments).join(","))},map:function(a){return this.pushStack(e.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:F,sort:[].sort,splice:[].splice},e.fn.init.prototype=e.fn,e.extend=e.fn.extend=function(){var a,c,d,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i=="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!="object"&&!e.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j<k;j++)if((a=arguments[j])!=null)for(c in a){d=i[c],f=a[c];if(i===f)continue;l&&f&&(e.isPlainObject(f)||(g=e.isArray(f)))?(g?(g=!1,h=d&&e.isArray(d)?d:[]):h=d&&e.isPlainObject(d)?d:{},i[c]=e.extend(l,h,f)):f!==b&&(i[c]=f)}return i},e.extend({noConflict:function(b){a.$===e&&(a.$=g),b&&a.jQuery===e&&(a.jQuery=f);return e},isReady:!1,readyWait:1,holdReady:function(a){a?e.readyWait++:e.ready(!0)},ready:function(a){if(a===!0&&!--e.readyWait||a!==!0&&!e.isReady){if(!c.body)return setTimeout(e.ready,1);e.isReady=!0;if(a!==!0&&--e.readyWait>0)return;B.fireWith(c,[e]),e.fn.trigger&&e(c).trigger("ready").unbind("ready")}},bindReady:function(){if(!B){B=e.Callbacks("once memory");if(c.readyState==="complete")return setTimeout(e.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",C,!1),a.addEventListener("load",e.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",C),a.attachEvent("onload",e.ready);var b=!1;try{b=a.frameElement==null}catch(d){}c.documentElement.doScroll&&b&&K()}}},isFunction:function(a){return e.type(a)==="function"},isArray:Array.isArray||function(a){return e.type(a)==="array"},isWindow:function(a){return a&&typeof a=="object"&&"setInterval"in a},isNumeric:function(a){return a!=null&&m.test(a)&&!isNaN(a)},type:function(a){return a==null?String(a):J[D.call(a)]||"object"},isPlainObject:function(a){if(!a||e.type(a)!=="object"||a.nodeType||e.isWindow(a))return!1;try{if(a.constructor&&!E.call(a,"constructor")&&!E.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||E.call(a,d)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw a},parseJSON:function(b){if(typeof b!="string"||!b)return null;b=e.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(o.test(b.replace(p,"@").replace(q,"]").replace(r,"")))return(new Function("return "+b))();e.error("Invalid JSON: "+b)},parseXML:function(c){var d,f;try{a.DOMParser?(f=new DOMParser,d=f.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(g){d=b}(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&e.error("Invalid XML: "+c);return d},noop:function(){},globalEval:function(b){b&&j.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(x,"ms-").replace(w,y)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,d){var f,g=0,h=a.length,i=h===b||e.isFunction(a);if(d){if(i){for(f in a)if(c.apply(a[f],d)===!1)break}else for(;g<h;)if(c.apply(a[g++],d)===!1)break}else if(i){for(f in a)if(c.call(a[f],f,a[f])===!1)break}else for(;g<h;)if(c.call(a[g],g,a[g++])===!1)break;return a},trim:H?function(a){return a==null?"":H.call(a)}:function(a){return a==null?"":(a+"").replace(k,"").replace(l,"")},makeArray:function(a,b){var c=b||[];if(a!=null){var d=e.type(a);a.length==null||d==="string"||d==="function"||d==="regexp"||e.isWindow(a)?F.call(c,a):e.merge(c,a)}return c},inArray:function(a,b,c){var d;if(b){if(I)return I.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=a.length,e=0;if(typeof c.length=="number")for(var f=c.length;e<f;e++)a[d++]=c[e];else while(c[e]!==b)a[d++]=c[e++];a.length=d;return a},grep:function(a,b,c){var d=[],e;c=!!c;for(var f=0,g=a.length;f<g;f++)e=!!b(a[f],f),c!==e&&d.push(a[f]);return d},map:function(a,c,d){var f,g,h=[],i=0,j=a.length,k=a instanceof e||j!==b&&typeof j=="number"&&(j>0&&a[0]&&a[j-1]||j===0||e.isArray(a));if(k)for(;i<j;i++)f=c(a[i],i,d),f!=null&&(h[h.length]=f);else for(g in a)f=c(a[g],g,d),f!=null&&(h[h.length]=f);return h.concat.apply([],h)},guid:1,proxy:function(a,c){if(typeof c=="string"){var d=a[c];c=a,a=d}if(!e.isFunction(a))return b;var f=G.call(arguments,2),g=function(){return a.apply(c,f.concat(G.call(arguments)))};g.guid=a.guid=a.guid||g.guid||e.guid++;return g},access:function(a,c,d,f,g,h){var i=a.length;if(typeof c=="object"){for(var j in c)e.access(a,j,c[j],f,g,d);return a}if(d!==b){f=!h&&f&&e.isFunction(d);for(var k=0;k<i;k++)g(a[k],c,f?d.call(a[k],k,g(a[k],c)):d,h);return a}return i?g(a[0],c):b},now:function(){return(new Date).getTime()},uaMatch:function(a){a=a.toLowerCase();var b=s.exec(a)||t.exec(a)||u.exec(a)||a.indexOf("compatible")<0&&v.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},sub:function(){function a(b,c){return new a.fn.init(b,c)}e.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function(d,f){f&&f instanceof e&&!(f instanceof a)&&(f=a(f));return e.fn.init.call(this,d,f,b)},a.fn.init.prototype=a.fn;var b=a(c);return a},browser:{}}),e.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){J["[object "+b+"]"]=b.toLowerCase()}),A=e.uaMatch(z),A.browser&&(e.browser[A.browser]=!0,e.browser.version=A.version),e.browser.webkit&&(e.browser.safari=!0),j.test(" ")&&(k=/^[\s\xA0]+/,l=/[\s\xA0]+$/),h=e(c),c.addEventListener?C=function(){c.removeEventListener("DOMContentLoaded",C,!1),e.ready()}:c.attachEvent&&(C=function(){c.readyState==="complete"&&(c.detachEvent("onreadystatechange",C),e.ready())}),typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return e});return e}(),g={};f.Callbacks=function(a){a=a?g[a]||h(a):{};var c=[],d=[],e,i,j,k,l,m=function(b){var d,e,g,h,i;for(d=0,e=b.length;d<e;d++)g=b[d],h=f.type(g),h==="array"?m(g):h==="function"&&(!a.unique||!o.has(g))&&c.push(g)},n=function(b,f){f=f||[],e=!a.memory||[b,f],i=!0,l=j||0,j=0,k=c.length;for(;c&&l<k;l++)if(c[l].apply(b,f)===!1&&a.stopOnFalse){e=!0;break}i=!1,c&&(a.once?e===!0?o.disable():c=[]:d&&d.length&&(e=d.shift(),o.fireWith(e[0],e[1])))},o={add:function(){if(c){var a=c.length;m(arguments),i?k=c.length:e&&e!==!0&&(j=a,n(e[0],e[1]))}return this},remove:function(){if(c){var b=arguments,d=0,e=b.length;for(;d<e;d++)for(var f=0;f<c.length;f++)if(b[d]===c[f]){i&&f<=k&&(k--,f<=l&&l--),c.splice(f--,1);if(a.unique)break}}return this},has:function(a){if(c){var b=0,d=c.length;for(;b<d;b++)if(a===c[b])return!0}return!1},empty:function(){c=[];return this},disable:function(){c=d=e=b;return this},disabled:function(){return!c},lock:function(){d=b,(!e||e===!0)&&o.disable();return this},locked:function(){return!d},fireWith:function(b,c){d&&(i?a.once||d.push([b,c]):(!a.once||!e)&&n(b,c));return this},fire:function(){o.fireWith(this,arguments);return this},fired:function(){return!!e}};return o};var i=[].slice;f.extend({Deferred:function(a){var b=f.Callbacks("once memory"),c=f.Callbacks("once memory"),d=f.Callbacks("memory"),e="pending",g={resolve:b,reject:c,notify:d},h={done:b.add,fail:c.add,progress:d.add,state:function(){return e},isResolved:b.fired,isRejected:c.fired,then:function(a,b,c){i.done(a).fail(b).progress(c);return this},always:function(){return i.done.apply(i,arguments).fail.apply(i,arguments)},pipe:function(a,b,c){return f.Deferred(function(d){f.each({done:[a,"resolve"],fail:[b,"reject"],progress:[c,"notify"]},function(a,b){var c=b[0],e=b[1],g;f.isFunction(c)?i[a](function(){g=c.apply(this,arguments),g&&f.isFunction(g.promise)?g.promise().then(d.resolve,d.reject,d.notify):d[e+"With"](this===i?d:this,[g])}):i[a](d[e])})}).promise()},promise:function(a){if(a==null)a=h;else for(var b in h)a[b]=h[b];return a}},i=h.promise({}),j;for(j in g)i[j]=g[j].fire,i[j+"With"]=g[j].fireWith;i.done(function(){e="resolved"},c.disable,d.lock).fail(function(){e="rejected"},b.disable,d.lock),a&&a.call(i,i);return i},when:function(a){function m(a){return function(b){e[a]=arguments.length>1?i.call(arguments,0):b,j.notifyWith(k,e)}}function l(a){return function(c){b[a]=arguments.length>1?i.call(arguments,0):c,--g||j.resolveWith(j,b)}}var b=i.call(arguments,0),c=0,d=b.length,e=Array(d),g=d,h=d,j=d<=1&&a&&f.isFunction(a.promise)?a:f.Deferred(),k=j.promise();if(d>1){for(;c<d;c++)b[c]&&b[c].promise&&f.isFunction(b[c].promise)?b[c].promise().then(l(c),j.reject,m(c)):--g;g||j.resolveWith(j,b)}else j!==a&&j.resolveWith(j,d?[a]:[]);return k}}),f.support=function(){var a=c.createElement("div"),b=c.documentElement,d,e,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;a.setAttribute("className","t"),a.innerHTML="   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/><nav></nav>",d=a.getElementsByTagName("*"),e=a.getElementsByTagName("a")[0];if(!d||!d.length||!e)return{};g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=a.getElementsByTagName("input")[0],k={leadingWhitespace:a.firstChild.nodeType===3,tbody:!a.getElementsByTagName("tbody").length,htmlSerialize:!!a.getElementsByTagName("link").length,style:/top/.test(e.getAttribute("style")),hrefNormalized:e.getAttribute("href")==="/a",opacity:/^0.55/.test(e.style.opacity),cssFloat:!!e.style.cssFloat,unknownElems:!!a.getElementsByTagName("nav").length,checkOn:i.value==="on",optSelected:h.selected,getSetAttribute:a.className!=="t",enctype:!!c.createElement("form").enctype,submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0},i.checked=!0,k.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,k.optDisabled=!h.disabled;try{delete a.test}catch(v){k.deleteExpando=!1}!a.addEventListener&&a.attachEvent&&a.fireEvent&&(a.attachEvent("onclick",function(){k.noCloneEvent=!1}),a.cloneNode(!0).fireEvent("onclick")),i=c.createElement("input"),i.value="t",i.setAttribute("type","radio"),k.radioValue=i.value==="t",i.setAttribute("checked","checked"),a.appendChild(i),l=c.createDocumentFragment(),l.appendChild(a.lastChild),k.checkClone=l.cloneNode(!0).cloneNode(!0).lastChild.checked,a.innerHTML="",a.style.width=a.style.paddingLeft="1px",m=c.getElementsByTagName("body")[0],o=c.createElement(m?"div":"body"),p={visibility:"hidden",width:0,height:0,border:0,margin:0,background:"none"},m&&f.extend(p,{position:"absolute",left:"-999px",top:"-999px"});for(t in p)o.style[t]=p[t];o.appendChild(a),n=m||b,n.insertBefore(o,n.firstChild),k.appendChecked=i.checked,k.boxModel=a.offsetWidth===2,"zoom"in a.style&&(a.style.display="inline",a.style.zoom=1,k.inlineBlockNeedsLayout=a.offsetWidth===2,a.style.display="",a.innerHTML="<div style='width:4px;'></div>",k.shrinkWrapBlocks=a.offsetWidth!==2),a.innerHTML="<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>",q=a.getElementsByTagName("td"),u=q[0].offsetHeight===0,q[0].style.display="",q[1].style.display="none",k.reliableHiddenOffsets=u&&q[0].offsetHeight===0,a.innerHTML="",c.defaultView&&c.defaultView.getComputedStyle&&(j=c.createElement("div"),j.style.width="0",j.style.marginRight="0",a.appendChild(j),k.reliableMarginRight=(parseInt((c.defaultView.getComputedStyle(j,null)||{marginRight:0}).marginRight,10)||0)===0);if(a.attachEvent)for(t in{submit:1,change:1,focusin:1})s="on"+t,u=s in a,u||(a.setAttribute(s,"return;"),u=typeof a[s]=="function"),k[t+"Bubbles"]=u;f(function(){var a,b,d,e,g,h,i=1,j="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;",l="visibility:hidden;border:0;",n="style='"+j+"border:5px solid #000;padding:0;'",p="<div "+n+"><div></div></div>"+"<table "+n+" cellpadding='0' cellspacing='0'>"+"<tr><td></td></tr></table>";m=c.getElementsByTagName("body")[0];!m||(a=c.createElement("div"),a.style.cssText=l+"width:0;height:0;position:static;top:0;margin-top:"+i+"px",m.insertBefore(a,m.firstChild),o=c.createElement("div"),o.style.cssText=j+l,o.innerHTML=p,a.appendChild(o),b=o.firstChild,d=b.firstChild,g=b.nextSibling.firstChild.firstChild,h={doesNotAddBorder:d.offsetTop!==5,doesAddBorderForTableAndCells:g.offsetTop===5},d.style.position="fixed",d.style.top="20px",h.fixedPosition=d.offsetTop===20||d.offsetTop===15,d.style.position=d.style.top="",b.style.overflow="hidden",b.style.position="relative",h.subtractsBorderForOverflowNotVisible=d.offsetTop===-5,h.doesNotIncludeMarginInBodyOffset=m.offsetTop!==i,m.removeChild(a),o=a=null,f.extend(k,h))}),o.innerHTML="",n.removeChild(o),o=l=g=h=m=j=a=i=null;return k}(),f.boxModel=f.support.boxModel;var j=/^(?:\{.*\}|\[.*\])$/,k=/([A-Z])/g;f.extend({cache:{},uuid:0,expando:"jQuery"+(f.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?f.cache[a[f.expando]]:a[f.expando];return!!a&&!m(a)},data:function(a,c,d,e){if(!!f.acceptData(a)){var g,h,i,j=f.expando,k=typeof c=="string",l=a.nodeType,m=l?f.cache:a,n=l?a[f.expando]:a[f.expando]&&f.expando,o=c==="events";if((!n||!m[n]||!o&&!e&&!m[n].data)&&k&&d===b)return;n||(l?a[f.expando]=n=++f.uuid:n=f.expando),m[n]||(m[n]={},l||(m[n].toJSON=f.noop));if(typeof c=="object"||typeof c=="function")e?m[n]=f.extend(m[n],c):m[n].data=f.extend(m[n].data,c);g=h=m[n],e||(h.data||(h.data={}),h=h.data),d!==b&&(h[f.camelCase(c)]=d);if(o&&!h[c])return g.events;k?(i=h[c],i==null&&(i=h[f.camelCase(c)])):i=h;return i}},removeData:function(a,b,c){if(!!f.acceptData(a)){var d,e,g,h=f.expando,i=a.nodeType,j=i?f.cache:a,k=i?a[f.expando]:f.expando;if(!j[k])return;if(b){d=c?j[k]:j[k].data;if(d){f.isArray(b)?b=b:b in d?b=[b]:(b=f.camelCase(b),b in d?b=[b]:b=b.split(" "));for(e=0,g=b.length;e<g;e++)delete d[b[e]];if(!(c?m:f.isEmptyObject)(d))return}}if(!c){delete j[k].data;if(!m(j[k]))return}f.support.deleteExpando||!j.setInterval?delete j[k]:j[k]=null,i&&(f.support.deleteExpando?delete a[f.expando]:a.removeAttribute?a.removeAttribute(f.expando):a[f.expando]=null)}},_data:function(a,b,c){return f.data(a,b,c,!0)},acceptData:function(a){if(a.nodeName){var b=f.noData[a.nodeName.toLowerCase()];if(b)return b!==!0&&a.getAttribute("classid")===b}return!0}}),f.fn.extend({data:function(a,c){var d,e,g,h=null;if(typeof a=="undefined"){if(this.length){h=f.data(this[0]);if(this[0].nodeType===1&&!f._data(this[0],"parsedAttrs")){e=this[0].attributes;for(var i=0,j=e.length;i<j;i++)g=e[i].name,g.indexOf("data-")===0&&(g=f.camelCase(g.substring(5)),l(this[0],g,h[g]));f._data(this[0],"parsedAttrs",!0)}}return h}if(typeof a=="object")return this.each(function(){f.data(this,a)});d=a.split("."),d[1]=d[1]?"."+d[1]:"";if(c===b){h=this.triggerHandler("getData"+d[1]+"!",[d[0]]),h===b&&this.length&&(h=f.data(this[0],a),h=l(this[0],a,h));return h===b&&d[1]?this.data(d[0]):h}return this.each(function(){var b=f(this),e=[d[0],c];b.triggerHandler("setData"+d[1]+"!",e),f.data(this,a,c),b.triggerHandler("changeData"+d[1]+"!",e)})},removeData:function(a){return this.each(function(){f.removeData(this,a)})}}),f.extend({_mark:function(a,b){a&&(b=(b||"fx")+"mark",f._data(a,b,(f._data(a,b)||0)+1))},_unmark:function(a,b,c){a!==!0&&(c=b,b=a,a=!1);if(b){c=c||"fx";var d=c+"mark",e=a?0:(f._data(b,d)||1)-1;e?f._data(b,d,e):(f.removeData(b,d,!0),n(b,c,"mark"))}},queue:function(a,b,c){var d;if(a){b=(b||"fx")+"queue",d=f._data(a,b),c&&(!d||f.isArray(c)?d=f._data(a,b,f.makeArray(c)):d.push(c));return d||[]}},dequeue:function(a,b){b=b||"fx";var c=f.queue(a,b),d=c.shift(),e={};d==="inprogress"&&(d=c.shift()),d&&(b==="fx"&&c.unshift("inprogress"),f._data(a,b+".run",e),d.call(a,function(){f.dequeue(a,b)},e)),c.length||(f.removeData(a,b+"queue "+b+".run",!0),n(a,b,"queue"))}}),f.fn.extend({queue:function(a,c){typeof a!="string"&&(c=a,a="fx");if(c===b)return f.queue(this[0],a);return this.each(function(){var b=f.queue(this,a,c);a==="fx"&&b[0]!=="inprogress"&&f.dequeue(this,a)})},dequeue:function(a){return this.each(function(){f.dequeue(this,a)})},delay:function(a,b){a=f.fx?f.fx.speeds[a]||a:a,b=b||"fx";return this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){function m(){--h||d.resolveWith(e,[e])}typeof a!="string"&&(c=a,a=b),a=a||"fx";var d=f.Deferred(),e=this,g=e.length,h=1,i=a+"defer",j=a+"queue",k=a+"mark",l;while(g--)if(l=f.data(e[g],i,b,!0)||(f.data(e[g],j,b,!0)||f.data(e[g],k,b,!0))&&f.data(e[g],i,f.Callbacks("once memory"),!0))h++,l.add(m);m();return d.promise()}});var o=/[\n\t\r]/g,p=/\s+/,q=/\r/g,r=/^(?:button|input)$/i,s=/^(?:button|input|object|select|textarea)$/i,t=/^a(?:rea)?$/i,u=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,v=f.support.getSetAttribute,w,x,y;f.fn.extend({attr:function(a,b){return f.access(this,a,b,!0,f.attr)},removeAttr:function(a){return this.each(function(){f.removeAttr(this,a)})},prop:function(a,b){return f.access(this,a,b,!0,f.prop)},removeProp:function(a){a=f.propFix[a]||a;return this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,g,h,i;if(f.isFunction(a))return this.each(function(b){f(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(p);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{g=" "+e.className+" ";for(h=0,i=b.length;h<i;h++)~g.indexOf(" "+b[h]+" ")||(g+=b[h]+" ");e.className=f.trim(g)}}}return this},removeClass:function(a){var c,d,e,g,h,i,j;if(f.isFunction(a))return this.each(function(b){f(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(p);for(d=0,e=this.length;d<e;d++){g=this[d];if(g.nodeType===1&&g.className)if(a){h=(" "+g.className+" ").replace(o," ");for(i=0,j=c.length;i<j;i++)h=h.replace(" "+c[i]+" "," ");g.className=f.trim(h)}else g.className=""}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";if(f.isFunction(a))return this.each(function(c){f(this).toggleClass(a.call(this,c,this.className,b),b)});return this.each(function(){if(c==="string"){var e,g=0,h=f(this),i=b,j=a.split(p);while(e=j[g++])i=d?i:!h.hasClass(e),h[i?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&f._data(this,"__className__",this.className),this.className=this.className||a===!1?"":f._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(o," ").indexOf(b)>-1)return!0;return!1},val:function(a){var c,d,e,g=this[0];if(!arguments.length){if(g){c=f.valHooks[g.nodeName.toLowerCase()]||f.valHooks[g.type];if(c&&"get"in c&&(d=c.get(g,"value"))!==b)return d;d=g.value;return typeof d=="string"?d.replace(q,""):d==null?"":d}return b}e=f.isFunction(a);return this.each(function(d){var g=f(this),h;if(this.nodeType===1){e?h=a.call(this,d,g.val()):h=a,h==null?h="":typeof h=="number"?h+="":f.isArray(h)&&(h=f.map(h,function(a){return a==null?"":a+""})),c=f.valHooks[this.nodeName.toLowerCase()]||f.valHooks[this.type];if(!c||!("set"in c)||c.set(this,h,"value")===b)this.value=h}})}}),f.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,g=a.selectedIndex,h=[],i=a.options,j=a.type==="select-one";if(g<0)return null;c=j?g:0,d=j?g+1:i.length;for(;c<d;c++){e=i[c];if(e.selected&&(f.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!f.nodeName(e.parentNode,"optgroup"))){b=f(e).val();if(j)return b;h.push(b)}}if(j&&!h.length&&i.length)return f(i[g]).val();return h},set:function(a,b){var c=f.makeArray(b);f(a).find("option").each(function(){this.selected=f.inArray(f(this).val(),c)>=0}),c.length||(a.selectedIndex=-1);return c}}},attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attr:function(a,c,d,e){var g,h,i,j=a.nodeType;if(!a||j===3||j===8||j===2)return b;if(e&&c in f.attrFn)return f(a)[c](d);if(!("getAttribute"in a))return f.prop(a,c,d);i=j!==1||!f.isXMLDoc(a),i&&(c=c.toLowerCase(),h=f.attrHooks[c]||(u.test(c)?x:w));if(d!==b){if(d===null){f.removeAttr(a,c);return b}if(h&&"set"in h&&i&&(g=h.set(a,d,c))!==b)return g;a.setAttribute(c,""+d);return d}if(h&&"get"in h&&i&&(g=h.get(a,c))!==null)return g;g=a.getAttribute(c);return g===null?b:g},removeAttr:function(a,b){var c,d,e,g,h=0;if(a.nodeType===1){d=(b||"").split(p),g=d.length;for(;h<g;h++)e=d[h].toLowerCase(),c=f.propFix[e]||e,f.attr(a,e,""),a.removeAttribute(v?e:c),u.test(e)&&c in a&&(a[c]=!1)}},attrHooks:{type:{set:function(a,b){if(r.test(a.nodeName)&&a.parentNode)f.error("type property can't be changed");else if(!f.support.radioValue&&b==="radio"&&f.nodeName(a,"input")){var c=a.value;a.setAttribute("type",b),c&&(a.value=c);return b}}},value:{get:function(a,b){if(w&&f.nodeName(a,"button"))return w.get(a,b);return b in a?a.value:null},set:function(a,b,c){if(w&&f.nodeName(a,"button"))return w.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,g,h,i=a.nodeType;if(!a||i===3||i===8||i===2)return b;h=i!==1||!f.isXMLDoc(a),h&&(c=f.propFix[c]||c,g=f.propHooks[c]);return d!==b?g&&"set"in g&&(e=g.set(a,d,c))!==b?e:a[c]=d:g&&"get"in g&&(e=g.get(a,c))!==null?e:a[c]},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):s.test(a.nodeName)||t.test(a.nodeName)&&a.href?0:b}}}}),f.attrHooks.tabindex=f.propHooks.tabIndex,x={get:function(a,c){var d,e=f.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;b===!1?f.removeAttr(a,c):(d=f.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase()));return c}},v||(y={name:!0,id:!0},w=f.valHooks.button={get:function(a,c){var d;d=a.getAttributeNode(c);return d&&(y[c]?d.nodeValue!=="":d.specified)?d.nodeValue:b},set:function(a,b,d){var e=a.getAttributeNode(d);e||(e=c.createAttribute(d),a.setAttributeNode(e));return e.nodeValue=b+""}},f.attrHooks.tabindex.set=w.set,f.each(["width","height"],function(a,b){f.attrHooks[b]=f.extend(f.attrHooks[b],{set:function(a,c){if(c===""){a.setAttribute(b,"auto");return c}}})}),f.attrHooks.contenteditable={get:w.get,set:function(a,b,c){b===""&&(b="false"),w.set(a,b,c)}}),f.support.hrefNormalized||f.each(["href","src","width","height"],function(a,c){f.attrHooks[c]=f.extend(f.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),f.support.style||(f.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=""+b}}),f.support.optSelected||(f.propHooks.selected=f.extend(f.propHooks.selected,{get:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex);return null}})),f.support.enctype||(f.propFix.enctype="encoding"),f.support.checkOn||f.each(["radio","checkbox"],function(){f.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),f.each(["radio","checkbox"],function(){f.valHooks[this]=f.extend(f.valHooks[this],{set:function(a,b){if(f.isArray(b))return a.checked=f.inArray(f(a).val(),b)>=0}})});var z=/\.(.*)$/,A=/^(?:textarea|input|select)$/i,B=/\./g,C=/ /g,D=/[^\w\s.|`]/g,E=/^([^\.]*)?(?:\.(.+))?$/,F=/\bhover(\.\S+)?/,G=/^key/,H=/^(?:mouse|contextmenu)|click/,I=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,J=function(a){var b=I.exec(a);b&&
-(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},K=function(a,b){return(!b[1]||a.nodeName.toLowerCase()===b[1])&&(!b[2]||a.id===b[2])&&(!b[3]||b[3].test(a.className))},L=function(a){return f.event.special.hover?a:a.replace(F,"mouseenter$1 mouseleave$1")};f.event={add:function(a,c,d,e,g){var h,i,j,k,l,m,n,o,p,q,r,s;if(!(a.nodeType===3||a.nodeType===8||!c||!d||!(h=f._data(a)))){d.handler&&(p=d,d=p.handler),d.guid||(d.guid=f.guid++),j=h.events,j||(h.events=j={}),i=h.handle,i||(h.handle=i=function(a){return typeof f!="undefined"&&(!a||f.event.triggered!==a.type)?f.event.dispatch.apply(i.elem,arguments):b},i.elem=a),c=L(c).split(" ");for(k=0;k<c.length;k++){l=E.exec(c[k])||[],m=l[1],n=(l[2]||"").split(".").sort(),s=f.event.special[m]||{},m=(g?s.delegateType:s.bindType)||m,s=f.event.special[m]||{},o=f.extend({type:m,origType:l[1],data:e,handler:d,guid:d.guid,selector:g,namespace:n.join(".")},p),g&&(o.quick=J(g),!o.quick&&f.expr.match.POS.test(g)&&(o.isPositional=!0)),r=j[m];if(!r){r=j[m]=[],r.delegateCount=0;if(!s.setup||s.setup.call(a,e,n,i)===!1)a.addEventListener?a.addEventListener(m,i,!1):a.attachEvent&&a.attachEvent("on"+m,i)}s.add&&(s.add.call(a,o),o.handler.guid||(o.handler.guid=d.guid)),g?r.splice(r.delegateCount++,0,o):r.push(o),f.event.global[m]=!0}a=null}},global:{},remove:function(a,b,c,d){var e=f.hasData(a)&&f._data(a),g,h,i,j,k,l,m,n,o,p,q;if(!!e&&!!(m=e.events)){b=L(b||"").split(" ");for(g=0;g<b.length;g++){h=E.exec(b[g])||[],i=h[1],j=h[2];if(!i){j=j?"."+j:"";for(l in m)f.event.remove(a,l+j,c,d);return}n=f.event.special[i]||{},i=(d?n.delegateType:n.bindType)||i,p=m[i]||[],k=p.length,j=j?new RegExp("(^|\\.)"+j.split(".").sort().join("\\.(?:.*\\.)?")+"(\\.|$)"):null;if(c||j||d||n.remove)for(l=0;l<p.length;l++){q=p[l];if(!c||c.guid===q.guid)if(!j||j.test(q.namespace))if(!d||d===q.selector||d==="**"&&q.selector)p.splice(l--,1),q.selector&&p.delegateCount--,n.remove&&n.remove.call(a,q)}else p.length=0;p.length===0&&k!==p.length&&((!n.teardown||n.teardown.call(a,j)===!1)&&f.removeEvent(a,i,e.handle),delete m[i])}f.isEmptyObject(m)&&(o=e.handle,o&&(o.elem=null),f.removeData(a,["events","handle"],!0))}},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,e,g){if(!e||e.nodeType!==3&&e.nodeType!==8){var h=c.type||c,i=[],j,k,l,m,n,o,p,q,r,s;h.indexOf("!")>=0&&(h=h.slice(0,-1),k=!0),h.indexOf(".")>=0&&(i=h.split("."),h=i.shift(),i.sort());if((!e||f.event.customEvent[h])&&!f.event.global[h])return;c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.isTrigger=!0,c.exclusive=k,c.namespace=i.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\\.|$)"):null,o=h.indexOf(":")<0?"on"+h:"",(g||!e)&&c.preventDefault();if(!e){j=f.cache;for(l in j)j[l].events&&j[l].events[h]&&f.event.trigger(c,d,j[l].handle.elem,!0);return}c.result=b,c.target||(c.target=e),d=d!=null?f.makeArray(d):[],d.unshift(c),p=f.event.special[h]||{};if(p.trigger&&p.trigger.apply(e,d)===!1)return;r=[[e,p.bindType||h]];if(!g&&!p.noBubble&&!f.isWindow(e)){s=p.delegateType||h,n=null;for(m=e.parentNode;m;m=m.parentNode)r.push([m,s]),n=m;n&&n===e.ownerDocument&&r.push([n.defaultView||n.parentWindow||a,s])}for(l=0;l<r.length;l++){m=r[l][0],c.type=r[l][1],q=(f._data(m,"events")||{})[c.type]&&f._data(m,"handle"),q&&q.apply(m,d),q=o&&m[o],q&&f.acceptData(m)&&q.apply(m,d);if(c.isPropagationStopped())break}c.type=h,c.isDefaultPrevented()||(!p._default||p._default.apply(e.ownerDocument,d)===!1)&&(h!=="click"||!f.nodeName(e,"a"))&&f.acceptData(e)&&o&&e[h]&&(h!=="focus"&&h!=="blur"||c.target.offsetWidth!==0)&&!f.isWindow(e)&&(n=e[o],n&&(e[o]=null),f.event.triggered=h,e[h](),f.event.triggered=b,n&&(e[o]=n));return c.result}},dispatch:function(c){c=f.event.fix(c||a.event);var d=(f._data(this,"events")||{})[c.type]||[],e=d.delegateCount,g=[].slice.call(arguments,0),h=!c.exclusive&&!c.namespace,i=(f.event.special[c.type]||{}).handle,j=[],k,l,m,n,o,p,q,r,s,t,u;g[0]=c,c.delegateTarget=this;if(e&&!c.target.disabled&&(!c.button||c.type!=="click"))for(m=c.target;m!=this;m=m.parentNode||this){o={},q=[];for(k=0;k<e;k++)r=d[k],s=r.selector,t=o[s],r.isPositional?t=(t||(o[s]=f(s))).index(m)>=0:t===b&&(t=o[s]=r.quick?K(m,r.quick):f(m).is(s)),t&&q.push(r);q.length&&j.push({elem:m,matches:q})}d.length>e&&j.push({elem:this,matches:d.slice(e)});for(k=0;k<j.length&&!c.isPropagationStopped();k++){p=j[k],c.currentTarget=p.elem;for(l=0;l<p.matches.length&&!c.isImmediatePropagationStopped();l++){r=p.matches[l];if(h||!c.namespace&&!r.namespace||c.namespace_re&&c.namespace_re.test(r.namespace))c.data=r.data,c.handleObj=r,n=(i||r.handler).apply(p.elem,g),n!==b&&(c.result=n,n===!1&&(c.preventDefault(),c.stopPropagation()))}}return c.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode);return a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement wheelDelta".split(" "),filter:function(a,d){var e,f,g,h=d.button,i=d.fromElement;a.pageX==null&&d.clientX!=null&&(e=a.target.ownerDocument||c,f=e.documentElement,g=e.body,a.pageX=d.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=d.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?d.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0);return a}},fix:function(a){if(a[f.expando])return a;var d,e,g=a,h=f.event.fixHooks[a.type]||{},i=h.props?this.props.concat(h.props):this.props;a=f.Event(g);for(d=i.length;d;)e=i[--d],a[e]=g[e];a.target||(a.target=g.srcElement||c),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey===b&&(a.metaKey=a.ctrlKey);return h.filter?h.filter(a,g):a},special:{ready:{setup:f.bindReady},focus:{delegateType:"focusin",noBubble:!0},blur:{delegateType:"focusout",noBubble:!0},beforeunload:{setup:function(a,b,c){f.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=f.extend(new f.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?f.event.trigger(e,null,b):f.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},f.event.handle=f.event.dispatch,f.removeEvent=c.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){a.detachEvent&&a.detachEvent("on"+b,c)},f.Event=function(a,b){if(!(this instanceof f.Event))return new f.Event(a,b);a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?N:M):this.type=a,b&&f.extend(this,b),this.timeStamp=a&&a.timeStamp||f.now(),this[f.expando]=!0},f.Event.prototype={preventDefault:function(){this.isDefaultPrevented=N;var a=this.originalEvent;!a||(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){this.isPropagationStopped=N;var a=this.originalEvent;!a||(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=N,this.stopPropagation()},isDefaultPrevented:M,isPropagationStopped:M,isImmediatePropagationStopped:M},f.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){f.event.special[a]=f.event.special[b]={delegateType:b,bindType:b,handle:function(a){var b=this,c=a.relatedTarget,d=a.handleObj,e=d.selector,g,h;if(!c||d.origType===a.type||c!==b&&!f.contains(b,c))g=a.type,a.type=d.origType,h=d.handler.apply(this,arguments),a.type=g;return h}}}),f.support.submitBubbles||(f.event.special.submit={setup:function(){if(f.nodeName(this,"form"))return!1;f.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=f.nodeName(c,"input")||f.nodeName(c,"button")?c.form:b;d&&!d._submit_attached&&(f.event.add(d,"submit._submit",function(a){this.parentNode&&f.event.simulate("submit",this.parentNode,a,!0)}),d._submit_attached=!0)})},teardown:function(){if(f.nodeName(this,"form"))return!1;f.event.remove(this,"._submit")}}),f.support.changeBubbles||(f.event.special.change={setup:function(){if(A.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")f.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),f.event.add(this,"click._change",function(a){this._just_changed&&(this._just_changed=!1,f.event.simulate("change",this,a,!0))});return!1}f.event.add(this,"beforeactivate._change",function(a){var b=a.target;A.test(b.nodeName)&&!b._change_attached&&(f.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&f.event.simulate("change",this.parentNode,a,!0)}),b._change_attached=!0)})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){f.event.remove(this,"._change");return A.test(this.nodeName)}}),f.support.focusinBubbles||f.each({focus:"focusin",blur:"focusout"},function(a,b){var d=0,e=function(a){f.event.simulate(b,a.target,f.event.fix(a),!0)};f.event.special[b]={setup:function(){d++===0&&c.addEventListener(a,e,!0)},teardown:function(){--d===0&&c.removeEventListener(a,e,!0)}}}),f.fn.extend({on:function(a,c,d,e,g){var h,i;if(typeof a=="object"){typeof c!="string"&&(d=c,c=b);for(i in a)this.on(i,c,d,a[i],g);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=M;else if(!e)return this;g===1&&(h=e,e=function(a){f().off(a);return h.apply(this,arguments)},e.guid=h.guid||(h.guid=f.guid++));return this.each(function(){f.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on.call(this,a,b,c,d,1)},off:function(a,c,d){if(a&&a.preventDefault&&a.handleObj){var e=a.handleObj;f(a.delegateTarget).off(e.namespace?e.type+"."+e.namespace:e.type,e.selector,e.handler);return this}if(typeof a=="object"){for(var g in a)this.off(g,c,a[g]);return this}if(c===!1||typeof c=="function")d=c,c=b;d===!1&&(d=M);return this.each(function(){f.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){f(this.context).on(a,this.selector,b,c);return this},die:function(a,b){f(this.context).off(a,this.selector||"**",b);return this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length==1?this.off(a,"**"):this.off(b,a,c)},trigger:function(a,b){return this.each(function(){f.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return f.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||f.guid++,d=0,e=function(c){var e=(f._data(this,"lastToggle"+a.guid)||0)%d;f._data(this,"lastToggle"+a.guid,e+1),c.preventDefault();return b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),f.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){f.fn[b]=function(a,c){c==null&&(c=a,a=null);return arguments.length>0?this.bind(b,a,c):this.trigger(b)},f.attrFn&&(f.attrFn[b]=!0),G.test(b)&&(f.event.fixHooks[b]=f.event.keyHooks),H.test(b)&&(f.event.fixHooks[b]=f.event.mouseHooks)}),function(){function x(a,b,c,e,f,g){for(var h=0,i=e.length;h<i;h++){var j=e[h];if(j){var k=!1;j=j[a];while(j){if(j[d]===c){k=e[j.sizset];break}if(j.nodeType===1){g||(j[d]=c,j.sizset=h);if(typeof b!="string"){if(j===b){k=!0;break}}else if(m.filter(b,[j]).length>0){k=j;break}}j=j[a]}e[h]=k}}}function w(a,b,c,e,f,g){for(var h=0,i=e.length;h<i;h++){var j=e[h];if(j){var k=!1;j=j[a];while(j){if(j[d]===c){k=e[j.sizset];break}j.nodeType===1&&!g&&(j[d]=c,j.sizset=h);if(j.nodeName.toLowerCase()===b){k=j;break}j=j[a]}e[h]=k}}}var a=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,d="sizcache"+(Math.random()+"").replace(".",""),e=0,g=Object.prototype.toString,h=!1,i=!0,j=/\\/g,k=/\r\n/g,l=/\W/;[0,0].sort(function(){i=!1;return 0});var m=function(b,d,e,f){e=e||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!="string")return e;var i,j,k,l,n,q,r,t,u=!0,v=m.isXML(d),w=[],x=b;do{a.exec(""),i=a.exec(x);if(i){x=i[3],w.push(i[1]);if(i[2]){l=i[3];break}}}while(i);if(w.length>1&&p.exec(b))if(w.length===2&&o.relative[w[0]])j=y(w[0]+w[1],d,f);else{j=o.relative[w[0]]?[d]:m(w.shift(),d);while(w.length)b=w.shift(),o.relative[b]&&(b+=w.shift()),j=y(b,j,f)}else{!f&&w.length>1&&d.nodeType===9&&!v&&o.match.ID.test(w[0])&&!o.match.ID.test(w[w.length-1])&&(n=m.find(w.shift(),d,v),d=n.expr?m.filter(n.expr,n.set)[0]:n.set[0]);if(d){n=f?{expr:w.pop(),set:s(f)}:m.find(w.pop(),w.length===1&&(w[0]==="~"||w[0]==="+")&&d.parentNode?d.parentNode:d,v),j=n.expr?m.filter(n.expr,n.set):n.set,w.length>0?k=s(j):u=!1;while(w.length)q=w.pop(),r=q,o.relative[q]?r=w.pop():q="",r==null&&(r=d),o.relative[q](k,r,v)}else k=w=[]}k||(k=j),k||m.error(q||b);if(g.call(k)==="[object Array]")if(!u)e.push.apply(e,k);else if(d&&d.nodeType===1)for(t=0;k[t]!=null;t++)k[t]&&(k[t]===!0||k[t].nodeType===1&&m.contains(d,k[t]))&&e.push(j[t]);else for(t=0;k[t]!=null;t++)k[t]&&k[t].nodeType===1&&e.push(j[t]);else s(k,e);l&&(m(l,h,e,f),m.uniqueSort(e));return e};m.uniqueSort=function(a){if(u){h=i,a.sort(u);if(h)for(var b=1;b<a.length;b++)a[b]===a[b-1]&&a.splice(b--,1)}return a},m.matches=function(a,b){return m(a,null,null,b)},m.matchesSelector=function(a,b){return m(b,null,null,[a]).length>0},m.find=function(a,b,c){var d,e,f,g,h,i;if(!a)return[];for(e=0,f=o.order.length;e<f;e++){h=o.order[e];if(g=o.leftMatch[h].exec(a)){i=g[1],g.splice(1,1);if(i.substr(i.length-1)!=="\\"){g[1]=(g[1]||"").replace(j,""),d=o.find[h](g,b,c);if(d!=null){a=a.replace(o.match[h],"");break}}}}d||(d=typeof b.getElementsByTagName!="undefined"?b.getElementsByTagName("*"):[]);return{set:d,expr:a}},m.filter=function(a,c,d,e){var f,g,h,i,j,k,l,n,p,q=a,r=[],s=c,t=c&&c[0]&&m.isXML(c[0]);while(a&&c.length){for(h in o.filter)if((f=o.leftMatch[h].exec(a))!=null&&f[2]){k=o.filter[h],l=f[1],g=!1,f.splice(1,1);if(l.substr(l.length-1)==="\\")continue;s===r&&(r=[]);if(o.preFilter[h]){f=o.preFilter[h](f,s,d,r,e,t);if(!f)g=i=!0;else if(f===!0)continue}if(f)for(n=0;(j=s[n])!=null;n++)j&&(i=k(j,f,n,s),p=e^i,d&&i!=null?p?g=!0:s[n]=!1:p&&(r.push(j),g=!0));if(i!==b){d||(s=r),a=a.replace(o.match[h],"");if(!g)return[];break}}if(a===q)if(g==null)m.error(a);else break;q=a}return s},m.error=function(a){throw"Syntax error, unrecognized expression: "+a};var n=m.getText=function(a){var b,c,d=a.nodeType,e="";if(d){if(d===1){if(typeof a.textContent=="string")return a.textContent;if(typeof a.innerText=="string")return a.innerText.replace(k,"");for(a=a.firstChild;a;a=a.nextSibling)e+=n(a)}else if(d===3||d===4)return a.nodeValue}else for(b=0;c=a[b];b++)c.nodeType!==8&&(e+=n(c));return e},o=m.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,CLASS:/\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(a){return a.getAttribute("href")},type:function(a){return a.getAttribute("type")}},relative:{"+":function(a,b){var c=typeof b=="string",d=c&&!l.test(b),e=c&&!d;d&&(b=b.toLowerCase());for(var f=0,g=a.length,h;f<g;f++)if(h=a[f]){while((h=h.previousSibling)&&h.nodeType!==1);a[f]=e||h&&h.nodeName.toLowerCase()===b?h||!1:h===b}e&&m.filter(b,a,!0)},">":function(a,b){var c,d=typeof b=="string",e=0,f=a.length;if(d&&!l.test(b)){b=b.toLowerCase();for(;e<f;e++){c=a[e];if(c){var g=c.parentNode;a[e]=g.nodeName.toLowerCase()===b?g:!1}}}else{for(;e<f;e++)c=a[e],c&&(a[e]=d?c.parentNode:c.parentNode===b);d&&m.filter(b,a,!0)}},"":function(a,b,c){var d,f=e++,g=x;typeof b=="string"&&!l.test(b)&&(b=b.toLowerCase(),d=b,g=w),g("parentNode",b,f,a,d,c)},"~":function(a,b,c){var d,f=e++,g=x;typeof b=="string"&&!l.test(b)&&(b=b.toLowerCase(),d=b,g=w),g("previousSibling",b,f,a,d,c)}},find:{ID:function(a,b,c){if(typeof b.getElementById!="undefined"&&!c){var d=b.getElementById(a[1]);return d&&d.parentNode?[d]:[]}},NAME:function(a,b){if(typeof b.getElementsByName!="undefined"){var c=[],d=b.getElementsByName(a[1]);for(var e=0,f=d.length;e<f;e++)d[e].getAttribute("name")===a[1]&&c.push(d[e]);return c.length===0?null:c}},TAG:function(a,b){if(typeof b.getElementsByTagName!="undefined")return b.getElementsByTagName(a[1])}},preFilter:{CLASS:function(a,b,c,d,e,f){a=" "+a[1].replace(j,"")+" ";if(f)return a;for(var g=0,h;(h=b[g])!=null;g++)h&&(e^(h.className&&(" "+h.className+" ").replace(/[\t\n\r]/g," ").indexOf(a)>=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(j,"")},TAG:function(a,b){return a[1].replace(j,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||m.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&m.error(a[0]);a[0]=e++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(j,"");!f&&o.attrMap[g]&&(a[1]=o.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(j,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=m(b[3],null,null,c);else{var g=m.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(o.match.POS.test(b[0])||o.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!m(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return a.nodeName.toLowerCase()==="input"&&"text"===c&&(b===c||b===null)},radio:function(a){return a.nodeName.toLowerCase()==="input"&&"radio"===a.type},checkbox:function(a){return a.nodeName.toLowerCase()==="input"&&"checkbox"===a.type},file:function(a){return a.nodeName.toLowerCase()==="input"&&"file"===a.type},password:function(a){return a.nodeName.toLowerCase()==="input"&&"password"===a.type},submit:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"submit"===a.type},image:function(a){return a.nodeName.toLowerCase()==="input"&&"image"===a.type},reset:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"reset"===a.type},button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&"button"===a.type||b==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)},focus:function(a){return a===a.ownerDocument.activeElement}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return b<c[3]-0},gt:function(a,b,c){return b>c[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=o.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||n([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h<i;h++)if(g[h]===a)return!1;return!0}m.error(e)},CHILD:function(a,b){var c,e,f,g,h,i,j,k=b[1],l=a;switch(k){case"only":case"first":while(l=l.previousSibling)if(l.nodeType===1)return!1;if(k==="first")return!0;l=a;case"last":while(l=l.nextSibling)if(l.nodeType===1)return!1;return!0;case"nth":c=b[2],e=b[3];if(c===1&&e===0)return!0;f=b[0],g=a.parentNode;if(g&&(g[d]!==f||!a.nodeIndex)){i=0;for(l=g.firstChild;l;l=l.nextSibling)l.nodeType===1&&(l.nodeIndex=++i);g[d]=f}j=a.nodeIndex-e;return c===0?j===0:j%c===0&&j/c>=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||!!a.nodeName&&a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=m.attr?m.attr(a,c):o.attrHandle[c]?o.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":!f&&m.attr?d!=null:f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=o.setFilters[e];if(f)return f(a,c,b,d)}}},p=o.match.POS,q=function(a,b){return"\\"+(b-0+1)};for(var r in o.match)o.match[r]=new RegExp(o.match[r].source+/(?![^\[]*\])(?![^\(]*\))/.source),o.leftMatch[r]=new RegExp(/(^(?:.|\r|\n)*?)/.source+o.match[r].source.replace(/\\(\d+)/g,q));var s=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(t){s=function(a,b){var c=0,d=b||[];if(g.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length=="number")for(var e=a.length;c<e;c++)d.push(a[c]);else for(;a[c];c++)d.push(a[c]);return d}}var u,v;c.documentElement.compareDocumentPosition?u=function(a,b){if(a===b){h=!0;return 0}if(!a.compareDocumentPosition||!b.compareDocumentPosition)return a.compareDocumentPosition?-1:1;return a.compareDocumentPosition(b)&4?-1:1}:(u=function(a,b){if(a===b){h=!0;return 0}if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,i=b.parentNode,j=g;if(g===i)return v(a,b);if(!g)return-1;if(!i)return 1;while(j)e.unshift(j),j=j.parentNode;j=i;while(j)f.unshift(j),j=j.parentNode;c=e.length,d=f.length;for(var k=0;k<c&&k<d;k++)if(e[k]!==f[k])return v(e[k],f[k]);return k===c?v(a,f[k],-1):v(e[k],b,1)},v=function(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}),function(){var a=c.createElement("div"),d="script"+(new Date).getTime(),e=c.documentElement;a.innerHTML="<a name='"+d+"'/>",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(o.find.ID=function(a,c,d){if(typeof c.getElementById!="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},o.filter.ID=function(a,b){var c=typeof a.getAttributeNode!="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(o.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(o.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=m,b=c.createElement("div"),d="__sizzle__";b.innerHTML="<p class='TEST'></p>";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){m=function(b,e,f,g){e=e||c;if(!g&&!m.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return s(e.getElementsByTagName(b),f);if(h[2]&&o.find.CLASS&&e.getElementsByClassName)return s(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return s([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return s([],f);if(i.id===h[3])return s([i],f)}try{return s(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var k=e,l=e.getAttribute("id"),n=l||d,p=e.parentNode,q=/^\s*[+~]/.test(b);l?n=n.replace(/'/g,"\\$&"):e.setAttribute("id",n),q&&p&&(e=e.parentNode);try{if(!q||p)return s(e.querySelectorAll("[id='"+n+"'] "+b),f)}catch(r){}finally{l||k.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)m[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}m.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!m.isXML(a))try{if(e||!o.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return m(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="<div class='test e'></div><div class='test'></div>";if(!!a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;o.order.splice(1,0,"CLASS"),o.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?m.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?m.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:m.contains=function(){return!1},m.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var y=function(a,b,c){var d,e=[],f="",g=b.nodeType?[b]:b;while(d=o.match.PSEUDO.exec(a))f+=d[0],a=a.replace(o.match.PSEUDO,"");a=o.relative[a]?a+"*":a;for(var h=0,i=g.length;h<i;h++)m(a,g[h],e,c);return m.filter(f,e)};m.attr=f.attr,m.selectors.attrMap={},f.find=m,f.expr=m.selectors,f.expr[":"]=f.expr.filters,f.unique=m.uniqueSort,f.text=m.getText,f.isXMLDoc=m.isXML,f.contains=m.contains}();var O=/Until$/,P=/^(?:parents|prevUntil|prevAll)/,Q=/,/,R=/^.[^:#\[\.,]*$/,S=Array.prototype.slice,T=f.expr.match.POS,U={children:!0,contents:!0,next:!0,prev:!0};f.fn.extend({find:function(a){var b=this,c,d;if(typeof a!="string")return f(a).filter(function(){for(c=0,d=b.length;c<d;c++)if(f.contains(b[c],this))return!0});var e=this.pushStack("","find",a),g,h,i;for(c=0,d=this.length;c<d;c++){g=e.length,f.find(a,this[c],e);if(c>0)for(h=g;h<e.length;h++)for(i=0;i<g;i++)if(e[i]===e[h]){e.splice(h--,1);break}}return e},has:function(a){var b=f(a);return this.filter(function(){for(var a=0,c=b.length;a<c;a++)if(f.contains(this,b[a]))return!0})},not:function(a){return this.pushStack(W(this,a,!1),"not",a)},filter:function(a){return this.pushStack(W(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?T.test(a)?f(a,this.context).index(this[0])>=0:f.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c=[],d,e,g=this[0];if(f.isArray(a)){var h=1;while(g&&g.ownerDocument&&g!==b){for(d=0;d<a.length;d++)f(g).is(a[d])&&c.push({selector:a[d],elem:g,level:h});g=g.parentNode,h++}return c}var i=T.test(a)||typeof a!="string"?f(a,b||this.context):0;for(d=0,e=this.length;d<e;d++){g=this[d];while(g){if(i?i.index(g)>-1:f.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b||g.nodeType===11)break}}c=c.length>1?f.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a)return this[0]&&this[0].parentNode?this.prevAll().length:-1;if(typeof a=="string")return f.inArray(this[0],f(a));return f.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a=="string"?f(a,b):f.makeArray(a&&a.nodeType?[a]:a),d=f.merge(this.get(),c);return this.pushStack(V(c[0])||V(d[0])?d:f.unique(d))},andSelf:function(){return this.add(this.prevObject)}}),f.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return f.dir(a,"parentNode")},parentsUntil:function(a,b,c){return f.dir(a,"parentNode",c)},next:function(a){return f.nth(a,2,"nextSibling")},prev:function(a){return f.nth(a,2,"previousSibling")},nextAll:function(a){return f.dir(a,"nextSibling")},prevAll:function(a){return f.dir(a,"previousSibling")},nextUntil:function(a,b,c){return f.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return f.dir(a,"previousSibling",c)},siblings:function(a){return f.sibling(a.parentNode.firstChild,a)},children:function(a){return f.sibling(a.firstChild)},contents:function(a){return f.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:f.makeArray(a.childNodes)}},function(a,b){f.fn[a]=function(c,d){var e=f.map(this,b,c),g=S.call(arguments);O.test(a)||(d=c),d&&typeof d=="string"&&(e=f.filter(d,e)),e=this.length>1&&!U[a]?f.unique(e):e,(this.length>1||Q.test(d))&&P.test(a)&&(e=e.reverse());return this.pushStack(e,a,g.join(","))}}),f.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?f.find.matchesSelector(b[0],a)?[b[0]]:[]:f.find.matches(a,b)},dir:function(a,c,d){var e=[],g=a[c];while(g&&g.nodeType!==9&&(d===b||g.nodeType!==1||!f(g).is(d)))g.nodeType===1&&e.push(g),g=g[c];return e},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var Y="abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video",Z=/ jQuery\d+="(?:\d+|null)"/g,$=/^\s+/,_=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,ba=/<([\w:]+)/,bb=/<tbody/i,bc=/<|&#?\w+;/,bd=/<(?:script|style)/i,be=/<(?:script|object|embed|option|style)/i,bf=new RegExp("<(?:"+Y.replace(" ","|")+")","i"),bg=/checked\s*(?:[^=]|=\s*.checked.)/i,bh=/\/(java|ecma)script/i,bi=/^\s*<!(?:\[CDATA\[|\-\-)/,bj={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bk=X(c);bj.optgroup=bj.option,bj.tbody=bj.tfoot=bj.colgroup=bj.caption=bj.thead,bj.th=bj.td,f.support.htmlSerialize||(bj._default=[1,"div<div>","</div>"]),f.fn.extend({text:function(a){if(f.isFunction(a))return this.each(function(b){var c=f(this);c.text(a.call(this,b,c.text()))});if(typeof a!="object"&&a!==b)return this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a));return f.text(this)},wrapAll:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapAll(a.call(this,b))});if(this[0]){var b=f(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapInner(a.call(this,b))});return this.each(function(){var b=f(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){f(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){f.nodeName(this,"body")||f(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=f(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after"
-,arguments);a.push.apply(a,f(arguments[0]).toArray());return a}},remove:function(a,b){for(var c=0,d;(d=this[c])!=null;c++)if(!a||f.filter(a,[d]).length)!b&&d.nodeType===1&&(f.cleanData(d.getElementsByTagName("*")),f.cleanData([d])),d.parentNode&&d.parentNode.removeChild(d);return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&f.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return f.clone(this,a,b)})},html:function(a){if(a===b)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(Z,""):null;if(typeof a=="string"&&!bd.test(a)&&(f.support.leadingWhitespace||!$.test(a))&&!bj[(ba.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(_,"<$1></$2>");try{for(var c=0,d=this.length;c<d;c++)this[c].nodeType===1&&(f.cleanData(this[c].getElementsByTagName("*")),this[c].innerHTML=a)}catch(e){this.empty().append(a)}}else f.isFunction(a)?this.each(function(b){var c=f(this);c.html(a.call(this,b,c.html()))}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&this[0].parentNode){if(f.isFunction(a))return this.each(function(b){var c=f(this),d=c.html();c.replaceWith(a.call(this,b,d))});typeof a!="string"&&(a=f(a).detach());return this.each(function(){var b=this.nextSibling,c=this.parentNode;f(this).remove(),b?f(b).before(a):f(c).append(a)})}return this.length?this.pushStack(f(f.isFunction(a)?a():a),"replaceWith",a):this},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){var e,g,h,i,j=a[0],k=[];if(!f.support.checkClone&&arguments.length===3&&typeof j=="string"&&bg.test(j))return this.each(function(){f(this).domManip(a,c,d,!0)});if(f.isFunction(j))return this.each(function(e){var g=f(this);a[0]=j.call(this,e,c?g.html():b),g.domManip(a,c,d)});if(this[0]){i=j&&j.parentNode,f.support.parentNode&&i&&i.nodeType===11&&i.childNodes.length===this.length?e={fragment:i}:e=f.buildFragment(a,this,k),h=e.fragment,h.childNodes.length===1?g=h=h.firstChild:g=h.firstChild;if(g){c=c&&f.nodeName(g,"tr");for(var l=0,m=this.length,n=m-1;l<m;l++)d.call(c?bl(this[l],g):this[l],e.cacheable||m>1&&l<n?f.clone(h,!0,!0):h)}k.length&&f.each(k,br)}return this}}),f.buildFragment=function(a,b,d){var e,g,h,i,j=a[0];b&&b[0]&&(i=b[0].ownerDocument||b[0]),i.createDocumentFragment||(i=c),a.length===1&&typeof j=="string"&&j.length<512&&i===c&&j.charAt(0)==="<"&&!be.test(j)&&(f.support.checkClone||!bg.test(j))&&!f.support.unknownElems&&bf.test(j)&&(g=!0,h=f.fragments[j],h&&h!==1&&(e=h)),e||(e=i.createDocumentFragment(),f.clean(a,i,e,d)),g&&(f.fragments[j]=h?e:1);return{fragment:e,cacheable:g}},f.fragments={},f.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){f.fn[a]=function(c){var d=[],e=f(c),g=this.length===1&&this[0].parentNode;if(g&&g.nodeType===11&&g.childNodes.length===1&&e.length===1){e[b](this[0]);return this}for(var h=0,i=e.length;h<i;h++){var j=(h>0?this.clone(!0):this).get();f(e[h])[b](j),d=d.concat(j)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d=a.cloneNode(!0),e,g,h;if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bn(a,d),e=bo(a),g=bo(d);for(h=0;e[h];++h)g[h]&&bn(e[h],g[h])}if(b){bm(a,d);if(c){e=bo(a),g=bo(d);for(h=0;e[h];++h)bm(e[h],g[h])}}e=g=null;return d},clean:function(a,b,d,e){var g;b=b||c,typeof b.createElement=="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);var h=[],i;for(var j=0,k;(k=a[j])!=null;j++){typeof k=="number"&&(k+="");if(!k)continue;if(typeof k=="string")if(!bc.test(k))k=b.createTextNode(k);else{k=k.replace(_,"<$1></$2>");var l=(ba.exec(k)||["",""])[1].toLowerCase(),m=bj[l]||bj._default,n=m[0],o=b.createElement("div");b===c?bk.appendChild(o):X(b).appendChild(o),o.innerHTML=m[1]+k+m[2];while(n--)o=o.lastChild;if(!f.support.tbody){var p=bb.test(k),q=l==="table"&&!p?o.firstChild&&o.firstChild.childNodes:m[1]==="<table>"&&!p?o.childNodes:[];for(i=q.length-1;i>=0;--i)f.nodeName(q[i],"tbody")&&!q[i].childNodes.length&&q[i].parentNode.removeChild(q[i])}!f.support.leadingWhitespace&&$.test(k)&&o.insertBefore(b.createTextNode($.exec(k)[0]),o.firstChild),k=o.childNodes}var r;if(!f.support.appendChecked)if(k[0]&&typeof (r=k.length)=="number")for(i=0;i<r;i++)bq(k[i]);else bq(k);k.nodeType?h.push(k):h=f.merge(h,k)}if(d){g=function(a){return!a.type||bh.test(a.type)};for(j=0;h[j];j++)if(e&&f.nodeName(h[j],"script")&&(!h[j].type||h[j].type.toLowerCase()==="text/javascript"))e.push(h[j].parentNode?h[j].parentNode.removeChild(h[j]):h[j]);else{if(h[j].nodeType===1){var s=f.grep(h[j].getElementsByTagName("script"),g);h.splice.apply(h,[j+1,0].concat(s))}d.appendChild(h[j])}}return h},cleanData:function(a){var b,c,d=f.cache,e=f.event.special,g=f.support.deleteExpando;for(var h=0,i;(i=a[h])!=null;h++){if(i.nodeName&&f.noData[i.nodeName.toLowerCase()])continue;c=i[f.expando];if(c){b=d[c];if(b&&b.events){for(var j in b.events)e[j]?f.event.remove(i,j):f.removeEvent(i,j,b.handle);b.handle&&(b.handle.elem=null)}g?delete i[f.expando]:i.removeAttribute&&i.removeAttribute(f.expando),delete d[c]}}}});var bs=/alpha\([^)]*\)/i,bt=/opacity=([^)]*)/,bu=/([A-Z]|^ms)/g,bv=/^-?\d+(?:px)?$/i,bw=/^-?\d/,bx=/^([\-+])=([\-+.\de]+)/,by={position:"absolute",visibility:"hidden",display:"block"},bz=["Left","Right"],bA=["Top","Bottom"],bB,bC,bD;f.fn.css=function(a,c){if(arguments.length===2&&c===b)return this;return f.access(this,a,c,!0,function(a,c,d){return d!==b?f.style(a,c,d):f.css(a,c)})},f.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bB(a,"opacity","opacity");return c===""?"1":c}return a.style.opacity}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":f.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!!a&&a.nodeType!==3&&a.nodeType!==8&&!!a.style){var g,h,i=f.camelCase(c),j=a.style,k=f.cssHooks[i];c=f.cssProps[i]||i;if(d===b){if(k&&"get"in k&&(g=k.get(a,!1,e))!==b)return g;return j[c]}h=typeof d,h==="string"&&(g=bx.exec(d))&&(d=+(g[1]+1)*+g[2]+parseFloat(f.css(a,c)),h="number");if(d==null||h==="number"&&isNaN(d))return;h==="number"&&!f.cssNumber[i]&&(d+="px");if(!k||!("set"in k)||(d=k.set(a,d))!==b)try{j[c]=d}catch(l){}}},css:function(a,c,d){var e,g;c=f.camelCase(c),g=f.cssHooks[c],c=f.cssProps[c]||c,c==="cssFloat"&&(c="float");if(g&&"get"in g&&(e=g.get(a,!0,d))!==b)return e;if(bB)return bB(a,c)},swap:function(a,b,c){var d={};for(var e in b)d[e]=a.style[e],a.style[e]=b[e];c.call(a);for(e in b)a.style[e]=d[e]}}),f.curCSS=f.css,f.each(["height","width"],function(a,b){f.cssHooks[b]={get:function(a,c,d){var e;if(c){if(a.offsetWidth!==0)return bE(a,b,d);f.swap(a,by,function(){e=bE(a,b,d)});return e}},set:function(a,b){if(!bv.test(b))return b;b=parseFloat(b);if(b>=0)return b+"px"}}}),f.support.opacity||(f.cssHooks.opacity={get:function(a,b){return bt.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=f.isNumeric(b)?"alpha(opacity="+b*100+")":"",g=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&f.trim(g.replace(bs,""))===""){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bs.test(g)?g.replace(bs,e):g+" "+e}}),f(function(){f.support.reliableMarginRight||(f.cssHooks.marginRight={get:function(a,b){var c;f.swap(a,{display:"inline-block"},function(){b?c=bB(a,"margin-right","marginRight"):c=a.style.marginRight});return c}})}),c.defaultView&&c.defaultView.getComputedStyle&&(bC=function(a,c){var d,e,g;c=c.replace(bu,"-$1").toLowerCase();if(!(e=a.ownerDocument.defaultView))return b;if(g=e.getComputedStyle(a,null))d=g.getPropertyValue(c),d===""&&!f.contains(a.ownerDocument.documentElement,a)&&(d=f.style(a,c));return d}),c.documentElement.currentStyle&&(bD=function(a,b){var c,d,e,f=a.currentStyle&&a.currentStyle[b],g=a.style;f===null&&g&&(e=g[b])&&(f=e),!bv.test(f)&&bw.test(f)&&(c=g.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),g.left=b==="fontSize"?"1em":f||0,f=g.pixelLeft+"px",g.left=c,d&&(a.runtimeStyle.left=d));return f===""?"auto":f}),bB=bC||bD,f.expr&&f.expr.filters&&(f.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!f.support.reliableHiddenOffsets&&(a.style&&a.style.display||f.css(a,"display"))==="none"},f.expr.filters.visible=function(a){return!f.expr.filters.hidden(a)});var bF=/%20/g,bG=/\[\]$/,bH=/\r?\n/g,bI=/#.*$/,bJ=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bK=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bL=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,bM=/^(?:GET|HEAD)$/,bN=/^\/\//,bO=/\?/,bP=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,bQ=/^(?:select|textarea)/i,bR=/\s+/,bS=/([?&])_=[^&]*/,bT=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bU=f.fn.load,bV={},bW={},bX,bY,bZ=["*/"]+["*"];try{bX=e.href}catch(b$){bX=c.createElement("a"),bX.href="",bX=bX.href}bY=bT.exec(bX.toLowerCase())||[],f.fn.extend({load:function(a,c,d){if(typeof a!="string"&&bU)return bU.apply(this,arguments);if(!this.length)return this;var e=a.indexOf(" ");if(e>=0){var g=a.slice(e,a.length);a=a.slice(0,e)}var h="GET";c&&(f.isFunction(c)?(d=c,c=b):typeof c=="object"&&(c=f.param(c,f.ajaxSettings.traditional),h="POST"));var i=this;f.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?f("<div>").append(c.replace(bP,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bQ.test(this.nodeName)||bK.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bH,"\r\n")}}):{name:b.name,value:c.replace(bH,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.bind(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?cb(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),cb(a,b);return a},ajaxSettings:{url:bX,isLocal:bL.test(bY[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bZ},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:b_(bV),ajaxTransport:b_(bW),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?cd(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=ce(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bJ.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bI,"").replace(bN,bY[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bR),d.crossDomain==null&&(r=bT.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bY[1]&&r[2]==bY[2]&&(r[3]||(r[1]==="http:"?80:443))==(bY[3]||(bY[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),ca(bV,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bM.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bO.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bS,"$1_="+x);d.url=y+(y===d.url?(bO.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bZ+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=ca(bW,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){s<2?w(-1,z):f.error(z)}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)cc(g,a[g],c,e);return d.join("&").replace(bF,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cf=f.now(),cg=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cf++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=b.contentType==="application/x-www-form-urlencoded"&&typeof b.data=="string";if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(cg.test(b.url)||e&&cg.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(cg,l),b.url===j&&(e&&(k=k.replace(cg,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var ch=a.ActiveXObject?function(){for(var a in cj)cj[a](0,1)}:!1,ci=0,cj;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ck()||cl()}:ck,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c){if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,ch&&delete cj[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n),m.text=h.responseText;try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++ci,ch&&(cj||(cj={},f(a).unload(ch)),cj[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var cm={},cn,co,cp=/^(?:toggle|show|hide)$/,cq=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,cr,cs=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],ct;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(cw("show",3),a,b,c);for(var g=0,h=this.length;g<h;g++)d=this[g],d.style&&(e=d.style.display,!f._data(d,"olddisplay")&&e==="none"&&(e=d.style.display=""),e===""&&f.css(d,"display")==="none"&&f._data(d,"olddisplay",cx(d.nodeName)));for(g=0;g<h;g++){d=this[g];if(d.style){e=d.style.display;if(e===""||e==="none")d.style.display=f._data(d,"olddisplay")||""}}return this},hide:function(a,b,c){if(a||a===0)return this.animate(cw("hide",3),a,b,c);var d,e,g=0,h=this.length;for(;g<h;g++)d=this[g],d.style&&(e=f.css(d,"display"),e!=="none"&&!f._data(d,"olddisplay")&&f._data(d,"olddisplay",e));for(g=0;g<h;g++)this[g].style&&(this[g].style.display="none");return this},_toggle:f.fn.toggle,toggle:function(a,b,c){var d=typeof a=="boolean";f.isFunction(a)&&f.isFunction(b)?this._toggle.apply(this,arguments):a==null||d?this.each(function(){var b=d?a:f(this).is(":hidden");f(this)[b?"show":"hide"]()}):this.animate(cw("toggle",3),a,b,c);return this},fadeTo:function(a,b,c,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){function g(){e.queue===!1&&f._mark(this);var b=f.extend({},e),c=this.nodeType===1,d=c&&f(this).is(":hidden"),g,h,i,j,k,l,m,n,o;b.animatedProperties={};for(i in a){g=f.camelCase(i),i!==g&&(a[g]=a[i],delete a[i]),h=a[g],f.isArray(h)?(b.animatedProperties[g]=h[1],h=a[g]=h[0]):b.animatedProperties[g]=b.specialEasing&&b.specialEasing[g]||b.easing||"swing";if(h==="hide"&&d||h==="show"&&!d)return b.complete.call(this);c&&(g==="height"||g==="width")&&(b.overflow=[this.style.overflow,this.style.overflowX,this.style.overflowY],f.css(this,"display")==="inline"&&f.css(this,"float")==="none"&&(!f.support.inlineBlockNeedsLayout||cx(this.nodeName)==="inline"?this.style.display="inline-block":this.style.zoom=1))}b.overflow!=null&&(this.style.overflow="hidden");for(i in a)j=new f.fx(this,b,i),h=a[i],cp.test(h)?(o=f._data(this,"toggle"+i)||(h==="toggle"?d?"show":"hide":0),o?(f._data(this,"toggle"+i,o==="show"?"hide":"show"),j[o]()):j[h]()):(k=cq.exec(h),l=j.cur(),k?(m=parseFloat(k[2]),n=k[3]||(f.cssNumber[i]?"":"px"),n!=="px"&&(f.style(this,i,(m||1)+n),l=(m||1)/j.cur()*l,f.style(this,i,l+n)),k[1]&&(m=(k[1]==="-="?-1:1)*m+l),j.custom(l,m,n)):j.custom(l,h,""));return!0}var e=f.speed(b,c,d);if(f.isEmptyObject(a))return this.each(e.complete,[!1]);a=f.extend({},a);return e.queue===!1?this.each(g):this.queue(e.queue,g)},stop:function(a,c,d){typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]);return this.each(function(){function h(a,b,c){var e=b[c];f.removeData(a,c,!0),e.stop(d)}var b,c=!1,e=f.timers,g=f._data(this);d||f._unmark(!0,this);if(a==null)for(b in g)g[b].stop&&b.indexOf(".run")===b.length-4&&h(this,g,b);else g[b=a+".run"]&&g[b].stop&&h(this,g,b);for(b=e.length;b--;)e[b].elem===this&&(a==null||e[b].queue===a)&&(d?e[b](!0):e[b].saveState(),c=!0,e.splice(b,1));(!d||!c)&&f.dequeue(this,a)})}}),f.each({slideDown:cw("show",1),slideUp:cw("hide",1),slideToggle:cw("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){f.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),f.extend({speed:function(a,b,c){var d=a&&typeof a=="object"?f.extend({},a):{complete:c||!c&&b||f.isFunction(a)&&a,duration:a,easing:c&&b||b&&!f.isFunction(b)&&b};d.duration=f.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in f.fx.speeds?f.fx.speeds[d.duration]:f.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";d.old=d.complete,d.complete=function(a){f.isFunction(d.old)&&d.old.call(this),d.queue?f.dequeue(this,d.queue):a!==!1&&f._unmark(this)};return d},easing:{linear:function(a,b,c,d){return c+d*a},swing:function(a,b,c,d){return(-Math.cos(a*Math.PI)/2+.5)*d+c}},timers:[],fx:function(a,b,c){this.options=b,this.elem=a,this.prop=c,b.orig=b.orig||{}}}),f.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this),(f.fx.step[this.prop]||f.fx.step._default)(this)},cur:function(){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];var a,b=f.css(this.elem,this.prop);return isNaN(a=parseFloat(b))?!b||b==="auto"?0:b:a},custom:function(a,c,d){function h(a){return e.step(a)}var e=this,g=f.fx;this.startTime=ct||cu(),this.end=c,this.now=this.start=a,this.pos=this.state=0,this.unit=d||this.unit||(f.cssNumber[this.prop]?"":"px"),h.queue=this.options.queue,h.elem=this.elem,h.saveState=function(){e.options.hide&&f._data(e.elem,"fxshow"+e.prop)===b&&f._data(e.elem,"fxshow"+e.prop,e.start)},h()&&f.timers.push(h)&&!cr&&(cr=setInterval(g.tick,g.interval))},show:function(){var a=f._data(this.elem,"fxshow"+this.prop);this.options.orig[this.prop]=a||f.style(this.elem,this.prop),this.options.show=!0,a!==b?this.custom(this.cur(),a):this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur()),f(this.elem).show()},hide:function(){this.options.orig[this.prop]=f._data(this.elem,"fxshow"+this.prop)||f.style(this.elem,this.prop),this.options.hide=!0,this.custom(this.cur(),0)},step:function(a){var b,c,d,e=ct||cu(),g=!0,h=this.elem,i=this.options;if(a||e>=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||f.fx.stop()},interval:13,stop:function(){clearInterval(cr),cr=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){f.style(a.elem,"opacity",a.now)},_default:function(a){a.elem.style&&a.elem.style[a.prop]!=null?a.elem.style[a.prop]=a.now+a.unit:a.elem[a.prop]=a.now}}}),f.each(["width","height"],function(a,b){f.fx.step[b]=function(a){f.style(a.elem,b,Math.max(0,a.now))}}),f.expr&&f.expr.filters&&(f.expr.filters.animated=function(a){return f.grep(f.timers,function(b){return a===b.elem}).length});var cy=/^t(?:able|d|h)$/i,cz=/^(?:body|html)$/i;"getBoundingClientRect"in c.documentElement?f.fn.offset=function(a){var b=this[0],c;if(a)return this.each(function(b){f.offset.setOffset(this,a,b)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return f.offset.bodyOffset(b);try{c=b.getBoundingClientRect()}catch(d){}var e=b.ownerDocument,g=e.documentElement;if(!c||!f.contains(g,b))return c?{top:c.top,left:c.left}:{top:0,left:0};var h=e.body,i=cA(e),j=g.clientTop||h.clientTop||0,k=g.clientLeft||h.clientLeft||0,l=i.pageYOffset||f.support.boxModel&&g.scrollTop||h.scrollTop,m=i.pageXOffset||f.support.boxModel&&g.scrollLeft||h.scrollLeft,n=c.top+l-j,o=c.left+m-k;return{top:n,left:o}}:f.fn.offset=function(a){var b=this[0];if(a)return this.each(function(b){f.offset.setOffset(this,a,b)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return f.offset.bodyOffset(b);var c,d=b.offsetParent,e=b,g=b.ownerDocument,h=g.documentElement,i=g.body,j=g.defaultView,k=j?j.getComputedStyle(b,null):b.currentStyle,l=b.offsetTop,m=b.offsetLeft;while((b=b.parentNode)&&b!==i&&b!==h){if(f.support.fixedPosition&&k.position==="fixed")break;c=j?j.getComputedStyle(b,null):b.currentStyle,l-=b.scrollTop,m-=b.scrollLeft,b===d&&(l+=b.offsetTop,m+=b.offsetLeft,f.support.doesNotAddBorder&&(!f.support.doesAddBorderForTableAndCells||!cy.test(b.nodeName))&&(l+=parseFloat(c.borderTopWidth)||0,m+=parseFloat(c.borderLeftWidth)||0),e=d,d=b.offsetParent),f.support.subtractsBorderForOverflowNotVisible&&c.overflow!=="visible"&&(l+=parseFloat(c.borderTopWidth)||0,m+=parseFloat(c.borderLeftWidth)||0),k=c}if(k.position==="relative"||k.position==="static")l+=i.offsetTop,m+=i.offsetLeft;f.support.fixedPosition&&k.position==="fixed"&&(l+=Math.max(h.scrollTop,i.scrollTop),m+=Math.max(h.scrollLeft,i.scrollLeft));return{top:l,left:m}},f.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;f.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(f.css(a,"marginTop"))||0,c+=parseFloat(f.css(a,"marginLeft"))||0);return{top:b,left:c}},setOffset:function(a,b,c){var d=f.css(a,"position");d==="static"&&(a.style.position="relative");var e=f(a),g=e.offset(),h=f.css(a,"top"),i=f.css(a,"left"),j=(d==="absolute"||d==="fixed")&&f.inArray("auto",[h,i])>-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cz.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cz.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each(["Left","Top"],function(a,c){var d="scroll"+c;f.fn[d]=function(c){var e,g;if(c===b){e=this[0];if(!e)return null;g=cA(e);return g?"pageXOffset"in g?g[a?"pageYOffset":"pageXOffset"]:f.support.boxModel&&g.document.documentElement[d]||g.document.body[d]:e[d]}return this.each(function(){g=cA(this),g?g.scrollTo(a?f(g).scrollLeft():c,a?c:f(g).scrollTop()):this[d]=c})}}),f.each(["Height","Width"],function(a,c){var d=c.toLowerCase();f.fn["inner"+c]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,d,"padding")):this[d]():null},f.fn["outer"+c]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,d,a?"margin":"border")):this[d]():null},f.fn[d]=function(a){var e=this[0];if(!e)return a==null?null:this;if(f.isFunction(a))return this.each(function(b){var c=f(this);c[d](a.call(this,b,c[d]()))});if(f.isWindow(e)){var g=e.document.documentElement["client"+c],h=e.document.body;return e.document.compatMode==="CSS1Compat"&&g||h&&h["client"+c]||g}if(e.nodeType===9)return Math.max(e.documentElement["client"+c],e.body["scroll"+c],e.documentElement["scroll"+c],e.body["offset"+c],e.documentElement["offset"+c]);if(a===b){var i=f.css(e,d),j=parseFloat(i);return f.isNumeric(j)?j:i}return this.css(d,typeof a=="string"?a:a+"px")}}),a.jQuery=a.$=f})(window);
\ No newline at end of file
diff --git a/src/javadoc/stylesheet.css b/src/javadoc/stylesheet.css
deleted file mode 100644
index f4b3dd7fd5..0000000000
--- a/src/javadoc/stylesheet.css
+++ /dev/null
@@ -1,429 +0,0 @@
-/* Javadoc style sheet */
-/*
-Overall document style
-*/
-
-/* This stylesheet is for javadoc generated by OpenJDK 6 not for javadoc generated by Sun JDK6 */
-
-* { margin:0; padding:0; }
-body { background-color: #FFFFFF; color:#333; font-size: 100%; }
-body { font-size: 0.875em; line-height: 1.286em; font-family: "Helvetica", "Arial", sans-serif; }
-code { color: #777; line-height: 1.286em; font-family: "Consolas", "Lucida Console", "Droid Sans Mono", "Andale Mono", "Monaco", "Lucida Sans Typewriter"; }
-pre { color: #555; line-height: 1.0em; font-family: "Consolas", "Lucida Console", "Droid Sans Mono", "Andale Mono", "Monaco", "Lucida Sans Typewriter"; }
-
-a { text-decoration: none; color: #16569A; /* also try #2E85ED, #0033FF, #6C93C6, #1D7BBE, #1D8DD2 */ }
-a:hover, a:hover code { color: #EEEEEE; background-color: #16569A; }
-a:visited, a:visited code { color: #CC3300; }
-a:visited:hover, a:visited:hover code { color: #fff; background-color: #CC3300; }
-
-a.meaningful_link { text-decoration: none; color: #333333; background-color: #EAF9DD; border-bottom: 1px dashed #006400 }
-a.meaningful_link code { text-decoration: none; color: #777; border-bottom: 1px dashed #006400 }
-a.meaningful_link:hover, a.meaningful_link:hover code { background-color: #E0F9C9; }
-a.meaningful_link:visited, a.meaningful_link:visited code { color: #4B0012; }
-a.meaningful_link:visited:hover, a.meaningful_link:visited:hover code{ color: #4B0012; background-color: #ADE78B; }
-
-p { margin:20px 0; }
-pre { font-size:1.0em; }
-h1 { font-size:1.4em; line-height: 1.4em; margin-top: 1em; }
-h2 { font-size:1.35em; line-height: 1.4em; margin-top: 1em; }
-h3 { font-size:1.3em; line-height: 1.4em; margin-top: 1em; }
-h4 { font-size:1.25em; line-height: 1.4em; margin-top: 1em; }
-
-ul { margin:10px 0 10px 20px; }
-li { list-style:disc; }
-
-dl dt { font-size:0.95em; font-weight:bold; margin:10px 0 0 0; }
-dl dd { margin:10px 0 10px 20px; }
-dl dd ul { margin-left:0; }
-dl dd ul li { list-style:none; margin:10px 0 10px 0; }
-caption {
-    background: #E0E6DF;
-    color:#333;
-    text-align: left;
-    font-size: 100%;
-    font-weight: bold;
-    border-left: 1px solid #C0C0C0;
-    border-right: 1px solid #C0C0C0;
-    border-top: 1px solid #C0C0C0;
-    padding-left: 5px;
-    width:auto;
-}
-hr {
-    border: 0;
-    height: 0;
-    border-top: 1px solid #C0C0C0;
-    border-bottom: 1px solid #FFF;
-}
-/*
-Document title and Copyright styles
-*/
-.aboutLanguage {
-    float:right;
-    margin: 0.8em 1.2em;
-    color:#333;
-}
-.legalCopy {
-    margin:7px;
-}
-.bar {
-    font-size:1em;
-    margin:10px 0 0 10px;
-}
-.bar a {
-    font-weight:normal;
-}
-/*
-Navigation bar styles
-*/
-.topNav {
-    border-top:2px solid #C0C0C0;
-    height:2.8em;
-    background-color: #E0E6DF;
-    width:101%;
-}
-.bottomNav {
-    border-top:2px solid #C0C0C0;
-    height:2.8em;
-    background-color: #E0E6DF;
-    width:101%;
-}
-.subNav {
-    border-bottom:2px solid #C0C0C0;
-    float:left;
-    width:100%;
-    padding: 7px;
-    min-width:600px;
-}
-.subNav div {
-    clear:left;
-    float:left;
-    padding:0 0 5px 2px;
-    width:100%;
-}
-.topNav a:link,.topNav a:active, .topNav a:visited, .topNav a:hover,
-.bottomNav a:link,.bottomNav a:active, .bottomNav a:visited, .bottomNav a:hover {
-    font-weight:bold;
-    text-decoration:underline;
-    font-size:1em;
-}
-/* Navigation bar list styles */
-.topNav ul.navList, .bottomNav ul.navList {
-    background-color:#E0E6DF;
-    padding:7px 5px;
-    margin:0;
-    float:left;
-    width:60%;
-}
-ul.navList li{
-    list-style:none;
-    float:left;
-    padding:3px 4px;
-    font-size:1em;
-}
-ul.navList li.navBarCell1Rev {
-    background-color:#16569A;
-    color:#FFFFFF;
-    font-weight:bold;
-    font-size:1em;
-}
-/* Sub-navigation bar list styles */
-.subNav ul.navList {
-    float:left;
-    margin:0;
-    font-size:0.9em;
-    width:40%;
-}
-ul.subNavList {
-    float:left;
-    margin:0;
-    font-size:0.8em;
-    width:40%;
-}
-ul.subNavList li{
-    list-style:none;
-    float:left;
-}
-/*
-Page header and footer styles
-*/
-.header, .footer {
-    clear:both;
-    margin:0 7px;
-}
-.indexHeader {
-    font-size:0.9em;
-    margin:10px 0 7px 10px;
-}
-.header ul {
-    padding-left:20px;
-}
-/* Header and footer title styles */
-.header h1.title {
-    font-size:1.4em;
-    text-align:center;
-    margin:0;
-}
-.header h2.title {
-    font-size:1.4em;
-    margin:0;
-}
-.subTitle {
-    margin:0;
-    padding-top:10px;
-    font-size:0.9em;
-    font-weight:bold;
-}
-/*
-Page layout container styles
-*/
-.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer,
-.constantValuesContainer {
-    clear:both;
-    padding:10px 10px;
-    position:relative;
-}
-.indexContainer {
-    padding:0 0 10px 10px;
-    font-size:0.9em;
-}
-/*
-Class inheritance information styles
-*/
-ul.inheritance {
-    margin:0;
-    padding:0;
-}
-ul.inheritance li {
-    display:inline;
-    list-style:none;
-}
-ul.inheritance li ul.inheritance {
-    margin-left:15px;
-    background-image:url(resources/inherit.gif);
-    background-repeat:no-repeat;
-    padding-left:15px;
-    padding-top:1px;
-}
-/*
-Heading styles
-*/
-.indexContainer h2 {
-    font-weight:normal;
-    font-size:1.0em;
-    padding:10px 0 0 0;
-}
-.contentContainer h2 {
-    margin:10px 0;
-}
-.constantValuesContainer h2 {
-    background:#E0E6DF;
-    border:1px solid #C0C0C0;
-    padding:3px;
-    margin:0 0 10px 0;
-}
-.serializedFormContainer ul.blockList li.blockList h2 {
-    background:#E0E6DF;
-    border:1px solid #C0C0C0;
-    padding:3px;
-    margin:0 0 15px 0;
-    text-align:center;
-}
-.classUseContainer ul li ul li h3 {
-    margin-bottom:30px;
-    padding:3px;
-}
-.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList h3 {
-    background:#E0E6DF;
-    margin:0 0 15px 0;
-    padding:3px;
-}
-.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList h3 {
-    background:#E0E6DF;
-    margin:0 0 15px 0;
-    padding:3px;
-    border:1px solid #C0C0C0;
-}
-ul.blockList ul.blockList li.blockList h3, ul.blockList ul.blockList li.blockList h3 {
-    background:#E0E6DF;
-    border:1px solid #C0C0C0;
-    width: 100%;
-    margin-left: 0;
-    padding-left: 0;
-}
-div.summary ul.blockList ul.blockList li.blockList h3 {
-    background:#E0E6DF;
-    border: 0 solid #C0C0C0;
-    padding: 0;
-    margin: 0;
-    width: 100%;
-}
-div.summary ul.blockList ul.blockList ul.blockList li.blockList h3 {
-    background:#E0E6DF;
-    border:0;
-    border-bottom:1px solid #C0C0C0;
-}
-div.details ul.blockList ul.blockList ul.blockList li.blockList h4,
-div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 {
-    font-size:1.15em;
-    font-weight:bold;
-    padding:0 0 10px 0;
-}
-/*
-Table styles
-*/
-.contentContainer table {
-    border-collapse: collapse ;
-    width:100%;
-}
-.contentContainer table td, .contentContainer table th {
-    border:1px solid #C0C0C0;
-    padding:3px;
-}
-/* Constant values page table styles */
-.constantValuesContainer table {
-    border-collapse: collapse ;
-    margin:0 0 10px 0;
-}
-.constantValuesContainer table caption{
-    font-size:0.95em;
-    padding:3px;
-    background:#E0E6DF;
-}
-.constantValuesContainer table td, .constantValuesContainer table th {
-    border:1px solid #C0C0C0;
-    padding:3px;
-}
-/* Class-use/Package-use page table styles */
-.classUseContainer table {
-    border-collapse: collapse ;
-    width:100%;
-    margin:0 0 15px 0;
-}
-.classUseContainer ul li ul li table {
-    margin-bottom:30px;
-}
-.classUseContainer ul li ul li table caption{
-    font-size:0.95em;
-    padding:3px;
-    background:#E0E6DF;
-}
-.classUseContainer table td, .classUseContainer table th {
-    border:1px solid #C0C0C0;
-    padding:3px;
-}
-/* Summary table styles */
-ul.blockList li.blockList table.overviewSummary {
-    margin:0;
-    margin-bottom:15px;
-}
-ul.blockList li.blockList table caption {
-    padding:3px;
-}
-ul.blockList li.blockList table.overviewSummary td.colFirst{
-    text-align:right;
-}
-table.packageSummary td.colFirst, table.overviewSummary th.colFirst {
-    width:15%;
-}
-div.summary ul.blockList ul.blockList li.blockList caption {
-    display:none;
-}
-div.summary ul.blockList li.blockList ul.blockList li.blockList table.overviewSummary th {
-    border-top:0;
-}
-/* Table column block styles */
-ul.blockList li.blockList table.overviewSummary td.colLast div.block{
-    padding:0;
-    padding-left:40px;
-}
-ul.blockList li.blockList table.overviewSummary td.colOne div.block{
-    padding:0;
-    padding-left:40px;
-}
-.contentContainer ul.blockList li.blockList table .colOne div.block{
-    padding-left:40px;
-}
-.classUseContainer ul li ul li table .colLast div.block,
-.classUseContainer ul li ul li table .colOne div.block{
-    padding-left:40px;
-}
-/*
-List styles
-*/
-ul.horizontal li {
-    display:inline;
-    font-size:0.9em;
-}
-/* Container specific list styles */
-.indexContainer ul {
-    margin:0;
-}
-.indexContainer ul li {
-    list-style:none;
-}
-.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList {
-    border:0;
-}
-.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList {
-    list-style:none;
-    border:0;
-    border-bottom:1px solid #C0C0C0;
-}
-.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockListLast {
-    list-style:none;
-}
-/* General list styles */
-ul.blockList, ul.blockListLast {
-    margin-left:0;
-    padding-left:0;
-}
-ul.blockList li.blockList, ul.blockListLast li.blockList {
-    list-style:none;
-    margin-bottom:25px;
-}
-ul.blockList ul.blockList ul.blockList li.blockList {
-    border:1px solid #C0C0C0;
-}
-div.details ul.blockList ul.blockList ul.blockList li.blockList {
-    border:0;
-    border-bottom:1px solid #C0C0C0;
-}
-/* Definition list styles */
-ul.blockList li.blockList dl{
-    margin-bottom:15px;
-}
-ul.blockList li.blockList dl dd{
-    margin:0 0 0 30px;
-}
-ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList dl,
-ul.blockList li.blockList ul.blockList li.blockList ul.blockListLast li.blockList dl{
-    padding:0 0 10px 35px;
-}
-dl.nameValue dt, dl.nameValue dd{
-    display:inline;
-}
-ul.blockList li.blockList pre{
-    margin:0 0 15px 0;
-}
-/* List content styles */
-ul.blockList li.blockList ul.blockList li.blockList pre{
-    margin:10px 0 15px 0;
-}
-ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList pre,
-ul.blockList li.blockList ul.blockList li.blockList ul.blockListLast li.blockList pre{
-    padding:0 0 10px 0;
-}
-ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList div.block,
-ul.blockList li.blockList ul.blockList li.blockList ul.blockListLast li.blockList div.block{
-    padding:0 0 10px 35px;
-}
-/*
-Formatting effect styles
-*/
-.strong {
-    font-weight:bold;
-}
-.sourceLineNo {
-    color:green;
-    padding:0 30px 0 0;
-}
diff --git a/src/main/java/org/mockito/ArgumentCaptor.java b/src/main/java/org/mockito/ArgumentCaptor.java
deleted file mode 100644
index b8b0c1d932..0000000000
--- a/src/main/java/org/mockito/ArgumentCaptor.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static org.mockito.internal.util.Primitives.defaultValue;
-
-import java.util.List;
-
-import org.mockito.internal.matchers.CapturingMatcher;
-
-/**
- * Use it to capture argument values for further assertions.
- *
- * <p>
- * Mockito verifies argument values in natural java style: by using an equals() method.
- * This is also the recommended way of matching arguments because it makes tests clean & simple.
- * In some situations though, it is helpful to assert on certain arguments after the actual verification.
- * For example:
- * <pre class="code"><code class="java">
- *   ArgumentCaptor&lt;Person&gt; argument = ArgumentCaptor.forClass(Person.class);
- *   verify(mock).doSomething(argument.capture());
- *   assertEquals("John", argument.getValue().getName());
- * </code></pre>
- *
- * Example of capturing varargs:
- * <pre class="code"><code class="java">
- *   //capturing varargs:
- *   ArgumentCaptor&lt;Person&gt; varArgs = ArgumentCaptor.forClass(Person.class);
- *   verify(mock).varArgMethod(varArgs.capture());
- *   List expected = asList(new Person("John"), new Person("Jane"));
- *   assertEquals(expected, varArgs.getAllValues());
- * </code></pre>
- *
- * <p>
- * <strong>Warning:</strong> it is recommended to use ArgumentCaptor with verification <strong>but not</strong> with stubbing.
- * Using ArgumentCaptor with stubbing may decrease test readability because captor is created outside of assert (aka verify or 'then') block.
- * Also it may reduce defect localization because if stubbed method was not called then no argument is captured.
- *
- * <p>
- * In a way ArgumentCaptor is related to custom argument matchers (see javadoc for {@link ArgumentMatcher} class).
- * Both techniques can be used for making sure certain arguments were passed to mocks.
- * However, ArgumentCaptor may be a better fit if:
- * <ul>
- * <li>custom argument matcher is not likely to be reused</li>
- * <li>you just need it to assert on argument values to complete verification</li>
- * </ul>
- * Custom argument matchers via {@link ArgumentMatcher} are usually better for stubbing.
- *
- * <p>
- * This utility class <strong>*doesn't do any type checks*</strong>. The generic signatures are only there to avoid casting
- * in your code.
- * <p>
- * There is an <strong>annotation</strong> that you might find useful: &#64;{@link Captor}
- * <p>
- * See the full documentation on Mockito in javadoc for {@link Mockito} class.
- *
- * @see Captor
- * @since 1.8.0
- */
-public class ArgumentCaptor<T> {
-
-
-    private final CapturingMatcher<T> capturingMatcher = new CapturingMatcher<T>();
-    private final Class<? extends T> clazz;
-
-    private ArgumentCaptor(Class<? extends T> clazz) {
-        this.clazz = clazz;
-    }
-
-    /**
-     * Use it to capture the argument. This method <b>must be used inside of verification</b>.
-     * <p>
-     * Internally, this method registers a special implementation of an {@link ArgumentMatcher}.
-     * This argument matcher stores the argument value so that you can use it later to perform assertions.
-     * <p>
-     * See examples in javadoc for {@link ArgumentCaptor} class.
-     *
-     * @return null or default values
-     */
-    public T capture() {
-        Mockito.argThat(capturingMatcher);
-        return defaultValue(clazz);
-    }
-
-    /**
-     * Returns the captured value of the argument. When capturing varargs use {@link #getAllValues()}.
-     * <p>
-     * If verified method was called multiple times then this method it returns the latest captured value.
-     * <p>
-     * See examples in javadoc for {@link ArgumentCaptor} class.
-     *
-     * @return captured argument value
-     */
-    public T getValue() {
-        return this.capturingMatcher.getLastValue();
-    }
-
-    /**
-     * Returns all captured values. Use it when capturing varargs or when the verified method was called multiple times.
-     * When varargs method was called multiple times, this method returns merged list of all values from all invocations.
-     * <p>
-     * Example:
-     * <pre class="code"><code class="java">
-     *   mock.doSomething(new Person("John");
-     *   mock.doSomething(new Person("Jane");
-     *
-     *   ArgumentCaptor&lt;Person&gt; peopleCaptor = ArgumentCaptor.forClass(Person.class);
-     *   verify(mock, times(2)).doSomething(peopleCaptor.capture());
-     *
-     *   List&lt;Person&gt; capturedPeople = peopleCaptor.getAllValues();
-     *   assertEquals("John", capturedPeople.get(0).getName());
-     *   assertEquals("Jane", capturedPeople.get(1).getName());
-     * </pre>
-     *
-     * Example of capturing varargs:
-     * <pre class="code"><code class="java">
-     *   mock.countPeople(new Person("John"), new Person("Jane"); //vararg method
-     *
-     *   ArgumentCaptor&lt;Person&gt; peopleCaptor = ArgumentCaptor.forClass(Person.class);
-     *
-     *   verify(mock).countPeople(peopleCaptor.capture());
-     *
-     *   List expected = asList(new Person("John"), new Person("Jane"));
-     *   assertEquals(expected, peopleCaptor.getAllValues());
-     * </code></pre>
-     * See more examples in javadoc for {@link ArgumentCaptor} class.
-     *
-     * @return captured argument value
-     */
-    public List<T> getAllValues() {
-        return this.capturingMatcher.getAllValues();
-    }
-
-    /**
-     * Build a new <code>ArgumentCaptor</code>.
-     * <p>
-     * Note that an <code>ArgumentCaptor</code> <b>*doesn't do any type checks*</b>. It is only there to avoid casting
-     * in your code. This might however change (type checks could be added) in a
-     * future major release.
-     *
-     * @param clazz Type matching the parameter to be captured.
-     * @param <S> Type of clazz
-     * @param <U> Type of object captured by the newly built ArgumentCaptor
-     * @return A new ArgumentCaptor
-     */
-    public static <U,S extends U> ArgumentCaptor<U> forClass(Class<S> clazz) {
-        return new ArgumentCaptor<U>(clazz);
-    }
-}
diff --git a/src/main/java/org/mockito/ArgumentMatcher.java b/src/main/java/org/mockito/ArgumentMatcher.java
deleted file mode 100644
index a1e27c98d6..0000000000
--- a/src/main/java/org/mockito/ArgumentMatcher.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-/**
- * Allows creating customized argument matchers.
- * This API was changed in Mockito 2.1.0 in an effort to decouple Mockito from Hamcrest
- * and reduce the risk of version incompatibility.
- * Migration guide is included close to the bottom of this javadoc.
- * <p>
- * For non-trivial method arguments used in stubbing or verification, you have following options
- * (in no particular order):
- * <ul>
- *     <li>refactor the code so that the interactions with collaborators are easier to test with mocks.
- *     Perhaps it is possible to pass a different argument to the method so that mocking is easier?
- *     If stuff is hard to test it usually indicates the design could be better, so do refactor for testability!
- *     </li>
- *     <li>don't match the argument strictly, just use one of the lenient argument matchers like
- *     {@link Mockito#notNull()}. Some times it is better to have a simple test that works than
- *     a complicated test that seem to work.
- *     </li>
- *     <li>implement equals() method in the objects that are used as arguments to mocks.
- *     Mockito naturally uses equals() for argument matching.
- *     Many times, this is option is clean and simple.
- *     </li>
- *     <li>use {@link ArgumentCaptor} to capture the arguments and perform assertions on their state.
- *     Useful when you need to verify the arguments. Captor is not useful if you need argument matching for stubbing.
- *     Many times, this option leads to clean and readable tests with fine-grained validation of arguments.
- *     </li>
- *     <li>use customized argument matchers by implementing {@link ArgumentMatcher} interface
- *     and passing the implementation to the {@link Mockito#argThat} method.
- *     This option is useful if custom matcher is needed for stubbing and can be reused a lot.
- *     Note that {@link Mockito#argThat} demonstrates <b>NullPointerException</b> auto-unboxing caveat.
- *     </li>
- *     <li>use an instance of hamcrest matcher and pass it to
- *     {@link org.mockito.hamcrest.MockitoHamcrest#argThat(org.hamcrest.Matcher)}
- *     Useful if you already have a hamcrest matcher. Reuse and win!
- *     Note that {@link org.mockito.hamcrest.MockitoHamcrest#argThat(org.hamcrest.Matcher)} demonstrates <b>NullPointerException</b> auto-unboxing caveat.
- *     </li>
- *     <li>Java 8 only - use a lambda in place of an {@link ArgumentMatcher} since {@link ArgumentMatcher}
- *     is effectively a functional interface. A lambda can be used with the {@link Mockito#argThat} method.</li>
- * </ul>
- *
- * <p>
- * Implementations of this interface can be used with {@link Matchers#argThat} method.
- * Use <code>toString()</code> method for description of the matcher
- * - it is printed in verification errors.
- *
- * <pre class="code"><code class="java">
- * class ListOfTwoElements implements ArgumentMatcher&lt;List&gt; {
- *     public boolean matches(List list) {
- *         return list.size() == 2;
- *     }
- *     public String toString() {
- *         //printed in verification errors
- *         return "[list of 2 elements]";
- *     }
- * }
- *
- * List mock = mock(List.class);
- *
- * when(mock.addAll(argThat(new ListOfTwoElements))).thenReturn(true);
- *
- * mock.addAll(Arrays.asList(&quot;one&quot;, &quot;two&quot;));
- *
- * verify(mock).addAll(argThat(new ListOfTwoElements()));
- * </code></pre>
- *
- * To keep it readable you can extract method, e.g:
- *
- * <pre class="code"><code class="java">
- *   verify(mock).addAll(<b>argThat(new ListOfTwoElements())</b>);
- *   //becomes
- *   verify(mock).addAll(<b>listOfTwoElements()</b>);
- * </code></pre>
- *
- * In Java 8 you can treat ArgumentMatcher as a functional interface
- * and use a lambda, e.g.:
- *
- * <pre class="code"><code class="java">
- *   verify(mock).addAll(<b>argThat(list -> list.size() == 2)</b>);
- * </code></pre>
- *
- * <p>
- * Read more about other matchers in javadoc for {@link Matchers} class.
- * <h2>2.1.0 migration guide</h2>
- *
- * All existing custom implementations of <code>ArgumentMatcher</code> will no longer compile.
- * All locations where hamcrest matchers are passed to <code>argThat()</code> will no longer compile.
- * There are 2 approaches to fix the problems:
- * <ul>
- * <li>a) Refactor the hamcrest matcher to Mockito matcher:
- * Use "implements ArgumentMatcher" instead of "extends ArgumentMatcher".
- * Then refactor <code>describeTo()</code> method into <code>toString()</code> method.
- * </li>
- * <li>
- * b) Use <code>org.mockito.hamcrest.MockitoHamcrest.argThat()</code> instead of <code>Mockito.argThat()</code>.
- * Ensure that there is <a href="http://hamcrest.org/JavaHamcrest/">hamcrest</a> dependency on classpath
- * (Mockito does not depend on hamcrest any more).
- *
- * </li>
- * </ul>
- * What option is right for you? If you don't mind compile dependency to hamcrest
- * then option b) is probably right for you.
- * Your choice should not have big impact and is fully reversible -
- * you can choose different option in future (and refactor the code)
- *
- * @param <T> type of argument
- * @since 2.1.0
- */
-public interface ArgumentMatcher<T> {
-
-    /**
-     * Informs if this matcher accepts the given argument.
-     * <p>
-     * The method should <b>never</b> assert if the argument doesn't match. It
-     * should only return false.
-     * <p>
-     * See the example in the top level javadoc for {@link ArgumentMatcher}
-     *
-     * @param argument
-     *            the argument
-     * @return true if this matcher accepts the given argument.
-     */
-    boolean matches(T argument);
-}
diff --git a/src/main/java/org/mockito/ArgumentMatchers.java b/src/main/java/org/mockito/ArgumentMatchers.java
deleted file mode 100644
index 9d79a72546..0000000000
--- a/src/main/java/org/mockito/ArgumentMatchers.java
+++ /dev/null
@@ -1,1332 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-import static org.mockito.internal.util.Primitives.defaultValue;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.regex.Pattern;
-
-import org.mockito.internal.matchers.Any;
-import org.mockito.internal.matchers.Contains;
-import org.mockito.internal.matchers.EndsWith;
-import org.mockito.internal.matchers.Equals;
-import org.mockito.internal.matchers.InstanceOf;
-import org.mockito.internal.matchers.Matches;
-import org.mockito.internal.matchers.NotNull;
-import org.mockito.internal.matchers.Null;
-import org.mockito.internal.matchers.Same;
-import org.mockito.internal.matchers.StartsWith;
-import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
-import org.mockito.internal.util.Primitives;
-
-/**
- * Allow flexible verification or stubbing. See also {@link AdditionalMatchers}.
- *
- * <p>
- * {@link Mockito} extends ArgumentMatchers so to get access to all matchers just import Mockito class statically.
- *
- * <pre class="code"><code class="java">
- * //stubbing using anyInt() argument matcher
- * when(mockedList.get(anyInt())).thenReturn("element");
- *
- * //following prints "element"
- * System.out.println(mockedList.get(999));
- *
- * //you can also verify using argument matcher
- * verify(mockedList).get(anyInt());
- * </code></pre>
- *
- * <p>
- * Since Mockito <code>any(Class)</code> and <code>anyInt</code> family matchers perform a type check, thus they won't
- * match <code>null</code> arguments. Instead use the <code>isNull</code> matcher.
- *
- * <pre class="code"><code class="java">
- * // stubbing using anyBoolean() argument matcher
- * when(mock.dryRun(anyBoolean())).thenReturn("state");
- *
- * // below the stub won't match, and won't return "state"
- * mock.dryRun(null);
- *
- * // either change the stub
- * when(mock.dryRun(isNull())).thenReturn("state");
- * mock.dryRun(null); // ok
- *
- * // or fix the code ;)
- * when(mock.dryRun(anyBoolean())).thenReturn("state");
- * mock.dryRun(true); // ok
- *
- * </code></pre>
- *
- * The same apply for verification.
- * </p>
- *
- *
- * Scroll down to see all methods - full list of matchers.
- *
- * <p>
- * <b>Warning:</b><br/>
- *
- * If you are using argument matchers, <b>all arguments</b> have to be provided by matchers.
- *
- * E.g: (example shows verification but the same applies to stubbing):
- * </p>
- *
- * <pre class="code"><code class="java">
- * verify(mock).someMethod(anyInt(), anyString(), <b>eq("third argument")</b>);
- * //above is correct - eq() is also an argument matcher
- *
- * verify(mock).someMethod(anyInt(), anyString(), <b>"third argument"</b>);
- * //above is incorrect - exception will be thrown because third argument is given without argument matcher.
- * </code></pre>
- *
- * <p>
- * Matcher methods like <code>anyObject()</code>, <code>eq()</code> <b>do not</b> return matchers.
- * Internally, they record a matcher on a stack and return a dummy value (usually null).
- * This implementation is due to static type safety imposed by java compiler.
- * The consequence is that you cannot use <code>anyObject()</code>, <code>eq()</code> methods outside of verified/stubbed method.
- * </p>
- *
- * <h1>Additional matchers</h1>
- * <p>
- * The class {@link AdditionalMatchers} offers rarely used matchers, although they can be useful, when
- * it is useful to combine multiple matchers or when it is useful to negate a matcher necessary.
- * </p>
- *
- * <h1>Custom Argument ArgumentMatchers</h1>
- * <p>
- * It is important to understand the use cases and available options for dealing with non-trivial arguments
- * <b>before</b> implementing custom argument matchers. This way, you can select the best possible approach
- * for given scenario and produce highest quality test (clean and maintainable).
- * Please read on in the javadoc for {@link ArgumentMatcher} to learn about approaches and see the examples.
- * </p>
- *
- * @see AdditionalMatchers
- */
-@SuppressWarnings("unchecked")
-public class ArgumentMatchers {
-
-    /**
-     * Matches <strong>anything</strong>, including nulls and varargs.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * This is an alias of: {@link #anyObject()} and {@link #any(java.lang.Class)}
-     * </p>
-     *
-     * <p>
-     * <strong>Notes : </strong><br/>
-     * <ul>
-     *     <li>For primitive types use {@link #anyChar()} family or {@link #isA(Class)} or {@link #any(Class)}.</li>
-     *     <li>Since mockito 2.1.0 {@link #any(Class)} is not anymore an alias of this method.</li>
-     * </ul>
-     * </p>
-     *
-     * @return <code>null</code>.
-     *
-     * @see #any(Class)
-     * @see #anyObject()
-     * @see #anyVararg()
-     * @see #anyChar()
-     * @see #anyInt()
-     * @see #anyBoolean()
-     * @see #anyCollectionOf(Class)
-     */
-    public static <T> T any() {
-        return anyObject();
-    }
-
-    /**
-     * Matches anything, including <code>null</code>.
-     *
-     * <p>
-     * This is an alias of: {@link #any()} and {@link #any(java.lang.Class)}.
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>null</code>.
-     * @see #any()
-     * @see #any(Class)
-     * @see #notNull()
-     * @see #notNull(Class)
-     * @deprecated This will be removed in Mockito 3.0 (which will be java 8 only)
-     */
-    @Deprecated
-    public static <T> T anyObject() {
-        reportMatcher(Any.ANY);
-        return null;
-    }
-
-    /**
-     * Matches any object of given type, excluding nulls.
-     *
-     * <p>
-     * This matcher will perform a type check with the given type, thus excluding values.
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     *
-     * This is an alias of: {@link #isA(Class)}}
-     * </p>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null instance of <code></code>, thus <code>null</code> is not anymore a valid value.
-     * As reference are nullable, the suggested API to <strong>match</strong> <code>null</code>
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p><strong>Notes : </strong><br/>
-     * <ul>
-     *     <li>For primitive types use {@link #anyChar()} family.</li>
-     *     <li>Since Mockito 2.1.0 this method will perform a type check thus <code>null</code> values are not authorized.</li>
-     *     <li>Since mockito 2.1.0 {@link #any()} and {@link #anyObject()} are not anymore aliases of this method.</li>
-     * </ul>
-     * </p>
-     *
-     * @param <T> The accepted type
-     * @param type the class of the accepted type.
-     * @return <code>null</code>.
-     * @see #any()
-     * @see #anyObject()
-     * @see #anyVararg()
-     * @see #isA(Class)
-     * @see #notNull()
-     * @see #notNull(Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static <T> T any(Class<T> type) {
-        reportMatcher(new InstanceOf.VarArgAware(type, "<any " + type.getCanonicalName() + ">"));
-        return defaultValue(type);
-    }
-
-    /**
-     * <code>Object</code> argument that implements the given class.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param <T>  the accepted type.
-     * @param type the class of the accepted type.
-     * @return <code>null</code>.
-     * @see #any(Class)
-     */
-    public static <T> T isA(Class<T> type) {
-        reportMatcher(new InstanceOf(type));
-        return defaultValue(type);
-    }
-
-    /**
-     * Any vararg, meaning any number and values of arguments.
-     *
-     * <p>
-     * Example:
-     * <pre class="code"><code class="java">
-     * //verification:
-     * mock.foo(1, 2);
-     * mock.foo(1, 2, 3, 4);
-     *
-     * verify(mock, times(2)).foo(anyVararg());
-     *
-     * //stubbing:
-     * when(mock.foo(anyVararg()).thenReturn(100);
-     *
-     * //prints 100
-     * System.out.println(mock.foo(1, 2));
-     * //also prints 100
-     * System.out.println(mock.foo(1, 2, 3, 4));
-     * </code></pre>
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>null</code>.
-     * @see #any()
-     * @see #any(Class)
-     * @deprecated as of 2.1.0 use {@link #any()}
-     */
-    @Deprecated
-    public static <T> T anyVararg() {
-        any();
-        return null;
-    }
-
-    /**
-     * Any <code>boolean</code> or <strong>non-null</strong> <code>Boolean</code>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Boolean</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>false</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static boolean anyBoolean() {
-        reportMatcher(new InstanceOf(Boolean.class, "<any boolean>"));
-        return false;
-    }
-
-    /**
-     * Any <code>byte</code> or <strong>non-null</strong> <code>Byte</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Byte</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static byte anyByte() {
-        reportMatcher(new InstanceOf(Byte.class, "<any byte>"));
-        return 0;
-    }
-
-    /**
-     * Any <code>char</code> or <strong>non-null</strong> <code>Character</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Character</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static char anyChar() {
-        reportMatcher(new InstanceOf(Character.class, "<any char>"));
-        return 0;
-    }
-
-    /**
-     * Any int or <strong>non-null</strong> <code>Integer</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Integer</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static int anyInt() {
-        reportMatcher(new InstanceOf(Integer.class, "<any integer>"));
-        return 0;
-    }
-
-    /**
-     * Any <code>long</code> or <strong>non-null</strong> <code>Long</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Long</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static long anyLong() {
-        reportMatcher(new InstanceOf(Long.class, "<any long>"));
-        return 0;
-    }
-
-    /**
-     * Any <code>float</code> or <strong>non-null</strong> <code>Float</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Float</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static float anyFloat() {
-        reportMatcher(new InstanceOf(Float.class, "<any float>"));
-        return 0;
-    }
-
-    /**
-     * Any <code>double</code> or <strong>non-null</strong> <code>Double</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Double</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static double anyDouble() {
-        reportMatcher(new InstanceOf(Double.class, "<any double>"));
-        return 0;
-    }
-
-    /**
-     * Any <code>short</code> or <strong>non-null</strong> <code>Short</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow valued <code>Short</code>, thus <code>null</code> is not anymore a valid value.
-     * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return <code>0</code>.
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static short anyShort() {
-        reportMatcher(new InstanceOf(Short.class, "<any short>"));
-        return 0;
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>String</code>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>String</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return empty String ("")
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static String anyString() {
-        reportMatcher(new InstanceOf(String.class, "<any string>"));
-        return "";
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>List</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>List</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return empty List.
-     * @see #anyListOf(Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static <T> List<T> anyList() {
-        reportMatcher(new InstanceOf(List.class, "<any List>"));
-        return new ArrayList<T>(0);
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>List</code>.
-     *
-     * Generic friendly alias to {@link ArgumentMatchers#anyList()}. It's an alternative to
-     * <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings.
-     *
-     * <p>
-     * This method doesn't do type checks of the list content with the given type parameter, it is only there
-     * to avoid casting in the code.
-     * </p>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>List</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @param clazz Type owned by the list to avoid casting
-     * @return empty List.
-     * @see #anyList()
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> List<T> anyListOf(Class<T> clazz) {
-        return anyList();
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Set</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Set</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return empty Set
-     * @see #anySetOf(Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static <T> Set<T> anySet() {
-        reportMatcher(new InstanceOf(Set.class, "<any set>"));
-        return new HashSet<T>(0);
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Set</code>.
-     *
-     * <p>
-     * Generic friendly alias to {@link ArgumentMatchers#anySet()}.
-     * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings.
-     * </p>
-     *
-     * <p>
-     * This method doesn't do type checks of the set content with the given type parameter, it is only there
-     * to avoid casting in the code.
-     * </p>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Set</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @param clazz Type owned by the Set to avoid casting
-     * @return empty Set
-     * @see #anySet()
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> Set<T> anySetOf(Class<T> clazz) {
-        return anySet();
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Map</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Map</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return empty Map.
-     * @see #anyMapOf(Class, Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static <K, V> Map<K, V> anyMap() {
-        reportMatcher(new InstanceOf(Map.class, "<any map>"));
-        return new HashMap<K, V>(0);
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Map</code>.
-     *
-     * <p>
-     * Generic friendly alias to {@link ArgumentMatchers#anyMap()}.
-     * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings.
-     * </p>
-     *
-     * <p>
-     * This method doesn't do type checks of the map content with the given type parameter, it is only there
-     * to avoid casting in the code.
-     * </p>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Map</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @param keyClazz   Type of the map key to avoid casting
-     * @param valueClazz Type of the value to avoid casting
-     * @return empty Map.
-     * @see #anyMap()
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <K, V> Map<K, V> anyMapOf(Class<K> keyClazz, Class<V> valueClazz) {
-        return anyMap();
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Collection</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Collection</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return empty Collection.
-     * @see #anyCollectionOf(Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static <T> Collection<T> anyCollection() {
-        reportMatcher(new InstanceOf(Collection.class, "<any collection>"));
-        return new ArrayList<T>(0);
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Collection</code>.
-     *
-     * <p>
-     * Generic friendly alias to {@link ArgumentMatchers#anyCollection()}.
-     * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings.
-     * </p>
-     *
-     * <p>
-     * This method doesn't do type checks of the collection content with the given type parameter, it is only there
-     * to avoid casting in the code.
-     * </p>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Collection</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @param clazz Type owned by the collection to avoid casting
-     * @return empty Collection.
-     * @see #anyCollection()
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> Collection<T> anyCollectionOf(Class<T> clazz) {
-        return anyCollection();
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Iterable</code>.
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>Iterable</code>.
-     * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @return empty Iterable.
-     * @see #anyIterableOf(Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @since 2.1.0
-     */
-    public static <T> Iterable<T> anyIterable() {
-        reportMatcher(new InstanceOf(Iterable.class, "<any iterable>"));
-        return new ArrayList<T>(0);
-    }
-
-    /**
-     * Any <strong>non-null</strong> <code>Iterable</code>.
-     *
-     * <p>
-     * Generic friendly alias to {@link ArgumentMatchers#anyIterable()}.
-     * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings.
-     * </p>
-     *
-     * <p>
-     * This method doesn't do type checks of the iterable content with the given type parameter, it is only there
-     * to avoid casting in the code.
-     * </p>
-     *
-     * <p>
-     * Since Mockito 2.1.0, only allow non-null <code>String</code>.
-     * As strings are nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
-     * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
-     * 1.x.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class.
-     * </p>
-     *
-     * @param clazz Type owned by the collection to avoid casting
-     * @return empty Iterable.
-     * @see #anyIterable()
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @since 2.1.0
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> Iterable<T> anyIterableOf(Class<T> clazz) {
-        return anyIterable();
-    }
-
-
-
-    /**
-     * <code>boolean</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static boolean eq(boolean value) {
-        reportMatcher(new Equals(value));
-        return false;
-    }
-
-    /**
-     * <code>byte</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static byte eq(byte value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * <code>char</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static char eq(char value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * <code>double</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static double eq(double value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * <code>float</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static float eq(float value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * <code>int</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static int eq(int value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * <code>long</code> argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static long eq(long value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * <code>short</code> argument that is equal to the given value.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param value the given value.
-     * @return <code>0</code>.
-     */
-    public static short eq(short value) {
-        reportMatcher(new Equals(value));
-        return 0;
-    }
-
-    /**
-     * Object argument that is equal to the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value the given value.
-     * @return <code>null</code>.
-     */
-    public static <T> T eq(T value) {
-        reportMatcher(new Equals(value));
-        if (value == null)
-            return null;
-        return (T) Primitives.defaultValue(value.getClass());
-    }
-
-    /**
-     * Object argument that is reflection-equal to the given value with support for excluding
-     * selected fields from a class.
-     *
-     * <p>
-     * This matcher can be used when equals() is not implemented on compared objects.
-     * Matcher uses java reflection API to compare fields of wanted and actual object.
-     * </p>
-     *
-     * <p>
-     * Works similarly to <code>EqualsBuilder.reflectionEquals(this, other, excludeFields)</code> from
-     * apache commons library.
-     * <p>
-     * <b>Warning</b> The equality check is shallow!
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param value         the given value.
-     * @param excludeFields fields to exclude, if field does not exist it is ignored.
-     * @return <code>null</code>.
-     */
-    public static <T> T refEq(T value, String... excludeFields) {
-        reportMatcher(new ReflectionEquals(value, excludeFields));
-        return null;
-    }
-
-    /**
-     * Object argument that is the same as the given value.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param <T>   the type of the object, it is passed through to prevent casts.
-     * @param value the given value.
-     * @return <code>null</code>.
-     */
-    public static <T> T same(T value) {
-        reportMatcher(new Same(value));
-        if (value == null)
-            return null;
-        return (T) Primitives.defaultValue(value.getClass());
-    }
-
-    /**
-     * <code>null</code> argument.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @return <code>null</code>.
-     * @see #isNull(Class)
-     * @see #isNotNull()
-     * @see #isNotNull(Class)
-     */
-    public static <T> T isNull() {
-        reportMatcher(Null.NULL);
-        return null;
-    }
-
-    /**
-     * <code>null</code> argument.
-     *
-     * <p>
-     * The class argument is provided to avoid casting.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param clazz Type to avoid casting
-     * @return <code>null</code>.
-     * @see #isNull()
-     * @see #isNotNull()
-     * @see #isNotNull(Class)
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> T isNull(Class<T> clazz) {
-        return isNull();
-    }
-
-    /**
-     * Not <code>null</code> argument.
-     *
-     * <p>
-     * Alias to {@link ArgumentMatchers#isNotNull()}
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @return <code>null</code>.
-     */
-    public static <T> T notNull() {
-        reportMatcher(NotNull.NOT_NULL);
-        return null;
-    }
-
-    /**
-     * Not <code>null</code> argument, not necessary of the given class.
-     *
-     * <p>
-     * The class argument is provided to avoid casting.
-     *
-     * Alias to {@link ArgumentMatchers#isNotNull(Class)}
-     * <p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param clazz Type to avoid casting
-     * @return <code>null</code>.
-     * @see #isNotNull()
-     * @see #isNull()
-     * @see #isNull(Class)
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> T notNull(Class<T> clazz) {
-        return notNull();
-    }
-
-    /**
-     * Not <code>null</code> argument.
-     *
-     * <p>
-     * Alias to {@link ArgumentMatchers#notNull()}
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @return <code>null</code>.
-     * @see #isNotNull(Class)
-     * @see #isNull()
-     * @see #isNull(Class)
-     */
-    public static <T> T isNotNull() {
-        return notNull();
-    }
-
-    /**
-     * Not <code>null</code> argument, not necessary of the given class.
-     *
-     * <p>
-     * The class argument is provided to avoid casting.
-     * Alias to {@link ArgumentMatchers#notNull(Class)}
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param clazz Type to avoid casting
-     * @return <code>null</code>.
-     * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
-     * friendliness to avoid casting, this is not anymore needed in Java 8.
-     */
-    @Deprecated
-    public static <T> T isNotNull(Class<T> clazz) {
-        return notNull(clazz);
-    }
-
-
-    /**
-     * Argument that is either <code>null</code> or of the given type.
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     * </p>
-     *
-     * @param clazz Type to avoid casting
-     * @return <code>null</code>.
-     */
-    public static <T> T nullable(Class<T> clazz) {
-        AdditionalMatchers.or(isNull(), isA(clazz));
-        return  (T) Primitives.defaultValue(clazz);
-    }
-
-    /**
-     * <code>String</code> argument that contains the given substring.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param substring the substring.
-     * @return empty String ("").
-     */
-    public static String contains(String substring) {
-        reportMatcher(new Contains(substring));
-        return "";
-    }
-
-    /**
-     * <code>String</code> argument that matches the given regular expression.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param regex the regular expression.
-     * @return empty String ("").
-     *
-     * @see AdditionalMatchers#not(boolean)
-     */
-    public static String matches(String regex) {
-        reportMatcher(new Matches(regex));
-        return "";
-    }
-
-    /**
-     * <code>Pattern</code> argument that matches the given regular expression.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param pattern the regular expression pattern.
-     * @return empty String ("").
-     *
-     * @see AdditionalMatchers#not(boolean)
-     */
-    public static String matches(Pattern pattern) {
-        reportMatcher(new Matches(pattern));
-        return "";
-    }
-
-    /**
-     * <code>String</code> argument that ends with the given suffix.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param suffix the suffix.
-     * @return empty String ("").
-     */
-    public static String endsWith(String suffix) {
-        reportMatcher(new EndsWith(suffix));
-        return "";
-    }
-
-    /**
-     * <code>String</code> argument that starts with the given prefix.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param prefix the prefix.
-     * @return empty String ("").
-     */
-    public static String startsWith(String prefix) {
-        reportMatcher(new StartsWith(prefix));
-        return "";
-    }
-
-    /**
-     * Allows creating custom argument matchers.
-     *
-     * <p>
-     * This API has changed in 2.1.0, please read {@link ArgumentMatcher} for rationale and migration guide.
-     * <b>NullPointerException</b> auto-unboxing caveat is described below.
-     * </p>
-     *
-     * <p>
-     * It is important to understand the use cases and available options for dealing with non-trivial arguments
-     * <b>before</b> implementing custom argument matchers. This way, you can select the best possible approach
-     * for given scenario and produce highest quality test (clean and maintainable).
-     * Please read the documentation for {@link ArgumentMatcher} to learn about approaches and see the examples.
-     * </p>
-     *
-     * <p>
-     * <b>NullPointerException</b> auto-unboxing caveat.
-     * In rare cases when matching primitive parameter types you <b>*must*</b> use relevant intThat(), floatThat(), etc. method.
-     * This way you will avoid <code>NullPointerException</code> during auto-unboxing.
-     * Due to how java works we don't really have a clean way of detecting this scenario and protecting the user from this problem.
-     * Hopefully, the javadoc describes the problem and solution well.
-     * If you have an idea how to fix the problem, let us know via the mailing list or the issue tracker.
-     * </p>
-     *
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatcher} class
-     * </p>
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>null</code>.
-     */
-    public static <T> T argThat(ArgumentMatcher<T> matcher) {
-        reportMatcher(matcher);
-        return null;
-    }
-
-    /**
-     * Allows creating custom <code>char</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>char</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static char charThat(ArgumentMatcher<Character> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    /**
-     * Allows creating custom <code>boolean</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>boolean</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>false</code>.
-     */
-    public static boolean booleanThat(ArgumentMatcher<Boolean> matcher) {
-        reportMatcher(matcher);
-        return false;
-    }
-
-    /**
-     * Allows creating custom <code>byte</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>byte</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static byte byteThat(ArgumentMatcher<Byte> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    /**
-     * Allows creating custom <code>short</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>short</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static short shortThat(ArgumentMatcher<Short> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    /**
-     * Allows creating custom <code>int</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>int</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static int intThat(ArgumentMatcher<Integer> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    /**
-     * Allows creating custom <code>long</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>long</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static long longThat(ArgumentMatcher<Long> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    /**
-     * Allows creating custom <code>float</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>float</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static float floatThat(ArgumentMatcher<Float> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    /**
-     * Allows creating custom <code>double</code> argument matchers.
-     *
-     * Note that {@link #argThat} will not work with primitive <code>double</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat.
-     * <p>
-     * See examples in javadoc for {@link ArgumentMatchers} class
-     *
-     * @param matcher decides whether argument matches
-     * @return <code>0</code>.
-     */
-    public static double doubleThat(ArgumentMatcher<Double> matcher) {
-        reportMatcher(matcher);
-        return 0;
-    }
-
-    private static void reportMatcher(ArgumentMatcher<?> matcher) {
-        mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher);
-    }
-}
diff --git a/src/main/java/org/mockito/Captor.java b/src/main/java/org/mockito/Captor.java
deleted file mode 100644
index 225bf700f2..0000000000
--- a/src/main/java/org/mockito/Captor.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import java.lang.annotation.*;
-
-/**
- * Allows shorthand {@link org.mockito.ArgumentCaptor} creation on fields.
- *
- * <p>Example:
- * <pre class="code"><code class="java">
- * public class Test{
- *
- *    &#64;Captor ArgumentCaptor&lt;AsyncCallback&lt;Foo&gt;&gt; captor;
- *
- *    &#64;Before
- *    public void init(){
- *       MockitoAnnotations.initMocks(this);
- *    }
- *
- *    &#64;Test public void shouldDoSomethingUseful() {
- *       //...
- *       verify(mock).doStuff(captor.capture());
- *       assertEquals("foo", captor.getValue());
- *    }
- * }
- * </code></pre>
- *
- * <p>
- * One of the advantages of using &#64;Captor annotation is that you can avoid warnings related capturing complex generic types.
- *
- * @see ArgumentCaptor
- * @since 1.8.3
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-@Documented
-public @interface Captor {}
diff --git a/src/main/java/org/mockito/InOrder.java b/src/main/java/org/mockito/InOrder.java
deleted file mode 100644
index b709bd4f1f..0000000000
--- a/src/main/java/org/mockito/InOrder.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import org.mockito.verification.VerificationMode;
-
-/**
- * Allows verification in order. E.g:
- *
- * <pre class="code"><code class="java">
- * InOrder inOrder = inOrder(firstMock, secondMock);
- *
- * inOrder.verify(firstMock).add("was called first");
- * inOrder.verify(secondMock).add("was called second");
- * </code></pre>
- *
- * As of Mockito 1.8.4 you can verifyNoMoreInteractions() in order-sensitive way. Read more: {@link InOrder#verifyNoMoreInteractions()}
- * <p>
- *
- * See examples in javadoc for {@link Mockito} class
- */
-public interface InOrder {
-    /**
-     * Verifies interaction <b>happened once</b> in order.
-     * <p>
-     * Alias to <code>inOrder.verify(mock, times(1))</code>
-     * <p>
-     * Example:
-     * <pre class="code"><code class="java">
-     * InOrder inOrder = inOrder(firstMock, secondMock);
-     *
-     * inOrder.verify(firstMock).someMethod("was called first");
-     * inOrder.verify(secondMock).someMethod("was called second");
-     * </code></pre>
-     *
-     * See examples in javadoc for {@link Mockito} class
-     *
-     * @param mock to be verified
-     *
-     * @return mock object itself
-     */
-    <T> T verify(T mock);
-
-    /**
-     * Verifies interaction in order. E.g:
-     *
-     * <pre class="code"><code class="java">
-     * InOrder inOrder = inOrder(firstMock, secondMock);
-     *
-     * inOrder.verify(firstMock, times(2)).someMethod("was called first two times");
-     * inOrder.verify(secondMock, atLeastOnce()).someMethod("was called second at least once");
-     * </code></pre>
-     *
-     * See examples in javadoc for {@link Mockito} class
-     *
-     * @param mock to be verified
-     * @param mode for example times(x) or atLeastOnce()
-     *
-     * @return mock object itself
-     */
-    <T> T verify(T mock, VerificationMode mode);
-
-
-    /**
-     * Verifies that no more interactions happened <b>in order</b>.
-     * Different from {@link Mockito#verifyNoMoreInteractions(Object...)} because the order of verification matters.
-     * <p>
-     * Example:
-     * <pre class="code"><code class="java">
-     * mock.foo(); //1st
-     * mock.bar(); //2nd
-     * mock.baz(); //3rd
-     *
-     * InOrder inOrder = inOrder(mock);
-     *
-     * inOrder.verify(mock).bar(); //2n
-     * inOrder.verify(mock).baz(); //3rd (last method)
-     *
-     * //passes because there are no more interactions after last method:
-     * inOrder.verifyNoMoreInteractions();
-     *
-     * //however this fails because 1st method was not verified:
-     * Mockito.verifyNoMoreInteractions(mock);
-     * </code></pre>
-     */
-    void verifyNoMoreInteractions();
-}
diff --git a/src/main/java/org/mockito/Matchers.java b/src/main/java/org/mockito/Matchers.java
deleted file mode 100644
index f6d07bc047..0000000000
--- a/src/main/java/org/mockito/Matchers.java
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-/**
- * @deprecated Use {@link ArgumentMatchers}. This class is now deprecated in order to avoid a name clash with Hamcrest
- * <code>org.hamcrest.Matchers</code> class. This class will likely be removed in version 3.0.
- */
-@Deprecated
-public class Matchers extends ArgumentMatchers {
-}
diff --git a/src/main/java/org/mockito/Mock.java b/src/main/java/org/mockito/Mock.java
deleted file mode 100644
index 2473557e56..0000000000
--- a/src/main/java/org/mockito/Mock.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.ElementType.PARAMETER;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.Target;
-
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
-
-/**
- * Mark a field as a mock.
- *
- * <ul>
- * <li>Allows shorthand mock creation.</li>
- * <li>Minimizes repetitive mock creation code.</li>
- * <li>Makes the test class more readable.</li>
- * <li>Makes the verification error easier to read because the <b>field name</b> is used to identify the mock.</li>
- * </ul>
- *
- * <pre class="code"><code class="java">
- *   public class ArticleManagerTest extends SampleBaseTestCase {
- *
- *       &#064;Mock private ArticleCalculator calculator;
- *       &#064;Mock(name = "database") private ArticleDatabase dbMock;
- *       &#064;Mock(answer = RETURNS_MOCKS) private UserProvider userProvider;
- *       &#064;Mock(extraInterfaces = {Queue.class, Observer.class}) private  articleMonitor;
- *       &#064;Mock(stubOnly = true) private Logger logger;
- *
- *       private ArticleManager manager;
- *
- *       &#064;Before public void setup() {
- *           manager = new ArticleManager(userProvider, database, calculator, articleMonitor, logger);
- *       }
- *   }
- *
- *   public class SampleBaseTestCase {
- *
- *       &#064;Before public void initMocks() {
- *           MockitoAnnotations.initMocks(this);
- *       }
- *   }
- * </code></pre>
- *
- * <p>
- * <strong><code>MockitoAnnotations.initMocks(this)</code></strong> method has to be called to initialize annotated objects.
- * In above example, <code>initMocks()</code> is called in &#064;Before (JUnit4) method of test's base class.
- * For JUnit3 <code>initMocks()</code> can go to <code>setup()</code> method of a base class.
- * <strong>Instead</strong> you can also put initMocks() in your JUnit runner (&#064;RunWith) or use the built-in
- * {@link MockitoJUnitRunner}.
- * </p>
- *
- * @see Mockito#mock(Class)
- * @see Spy
- * @see InjectMocks
- * @see MockitoAnnotations#initMocks(Object)
- * @see MockitoJUnitRunner
- */
-@Target({FIELD, PARAMETER})
-@Retention(RUNTIME)
-@Documented
-public @interface Mock {
-
-    /**
-     * Mock will have custom answer, see {@link MockSettings#defaultAnswer(Answer)}.
-     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
-     */
-    Answers answer() default Answers.RETURNS_DEFAULTS;
-
-    /**
-     * Mock will be 'stubOnly', see {@link MockSettings#stubOnly()}.
-     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
-     */
-    boolean stubOnly() default false;
-
-    /**
-     * Mock will have custom name (shown in verification errors), see {@link MockSettings#name(String)}.
-     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
-     */
-    String name() default "";
-
-    /**
-     * Mock will have extra interfaces, see {@link MockSettings#extraInterfaces(Class[])}.
-     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
-     */
-    Class<?>[] extraInterfaces() default {};
-
-    /**
-     * Mock will be serializable, see {@link MockSettings#serializable()}.
-     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
-     */
-    boolean serializable() default false;
-
-    /**
-     * Mock will be lenient, see {@link MockSettings#lenient()}.
-     * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
-     *
-     * @since 2.23.3
-     */
-    boolean lenient() default false;
-}
diff --git a/src/main/java/org/mockito/MockitoAnnotations.java b/src/main/java/org/mockito/MockitoAnnotations.java
deleted file mode 100644
index 9199aaa9af..0000000000
--- a/src/main/java/org/mockito/MockitoAnnotations.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.configuration.GlobalConfiguration;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.plugins.AnnotationEngine;
-
-/**
- * MockitoAnnotations.initMocks(this); initializes fields annotated with Mockito annotations.
- * See also {@link MockitoSession} which not only initializes mocks
- * but also adds extra validation for cleaner tests!
- * <p>
- * <ul>
- * <li>Allows shorthand creation of objects required for testing.</li>
- * <li>Minimizes repetitive mock creation code.</li>
- * <li>Makes the test class more readable.</li>
- * <li>Makes the verification error easier to read because <b>field name</b> is used to identify the mock.</li>
- * </ul>
- *
- * <pre class="code"><code class="java">
- *   public class ArticleManagerTest extends SampleBaseTestCase {
- *
- *       &#064;Mock private ArticleCalculator calculator;
- *       &#064;Mock private ArticleDatabase database;
- *       &#064;Mock private UserProvider userProvider;
- *
- *       private ArticleManager manager;
- *
- *       &#064;Before public void setup() {
- *           manager = new ArticleManager(userProvider, database, calculator);
- *       }
- *   }
- *
- *   public class SampleBaseTestCase {
- *
- *       &#064;Before public void initMocks() {
- *           MockitoAnnotations.initMocks(this);
- *       }
- *   }
- * </code></pre>
- * <p>
- * Read also about other annotations &#064;{@link Spy}, &#064;{@link Captor}, &#064;{@link InjectMocks}
- * <p>
- * <b><code>MockitoAnnotations.initMocks(this)</code></b> method has to be called to initialize annotated fields.
- * <p>
- * In above example, <code>initMocks()</code> is called in &#064;Before (JUnit4) method of test's base class.
- * For JUnit3 <code>initMocks()</code> can go to <code>setup()</code> method of a base class.
- * You can also put initMocks() in your JUnit runner (&#064;RunWith) or use built-in runner: {@link MockitoJUnitRunner}
- */
-public class MockitoAnnotations {
-
-    /**
-     * Initializes objects annotated with Mockito annotations for given testClass:
-     *  &#064;{@link org.mockito.Mock}, &#064;{@link Spy}, &#064;{@link Captor}, &#064;{@link InjectMocks}
-     * <p>
-     * See examples in javadoc for {@link MockitoAnnotations} class.
-     */
-    public static void initMocks(Object testClass) {
-        if (testClass == null) {
-            throw new MockitoException("testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class");
-        }
-
-        AnnotationEngine annotationEngine = new GlobalConfiguration().tryGetPluginAnnotationEngine();
-        annotationEngine.process(testClass.getClass(), testClass);
-    }
-}
diff --git a/src/main/java/org/mockito/MockitoDebugger.java b/src/main/java/org/mockito/MockitoDebugger.java
deleted file mode 100644
index 90c7e9ab4b..0000000000
--- a/src/main/java/org/mockito/MockitoDebugger.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-/**
- * @deprecated - please use {@link MockingDetails#printInvocations()} instead.
- * An instance of {@code MockingDetails} can be retrieved via {@link Mockito#mockingDetails(Object)}.
- */
-@Deprecated
-public interface MockitoDebugger {
-
-    /**
-     * @deprecated - please use {@link MockingDetails#printInvocations()} instead.
-     * An instance of {@code MockingDetails} can be retrieved via {@link Mockito#mockingDetails(Object)}.
-     */
-    @Deprecated
-    String printInvocations(Object ... mocks);
-}
diff --git a/src/main/java/org/mockito/configuration/AnnotationEngine.java b/src/main/java/org/mockito/configuration/AnnotationEngine.java
deleted file mode 100644
index 40ff3526ff..0000000000
--- a/src/main/java/org/mockito/configuration/AnnotationEngine.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.configuration;
-
-import org.mockito.MockitoAnnotations;
-
-/**
- * Configures mock creation logic behind &#064;Mock, &#064;Captor and &#064;Spy annotations
- * <p>
- * If you are interested then see implementations or source code of {@link MockitoAnnotations#initMocks(Object)}
- *
- * <p>This interface can be used to configure a different annotation engine through
- * {@link org.mockito.configuration.IMockitoConfiguration}, however this mechanism is being superseded by the new
- * {@link org.mockito.plugins plugin} system.
- *
- * <p>
- * Note that if it exists on the classpath both a class <code>org.mockito.configuration.MockitoConfiguration</code>
- * and a file <code>mockito-extensions/org.mockito.plugins.AnnotationEngine</code> then the implementation of
- * <code>org.mockito.configuration.MockitoConfiguration</code> will be chosen instead of the one in the file.
-
- * @deprecated Please use {@link org.mockito.plugins.AnnotationEngine} instead,
- *             this interface will probably be removed in mockito 3.
- */
-@Deprecated
-public interface AnnotationEngine extends org.mockito.plugins.AnnotationEngine {
-}
diff --git a/src/main/java/org/mockito/configuration/IMockitoConfiguration.java b/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
deleted file mode 100644
index 2c2da565fb..0000000000
--- a/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.configuration;
-
-import org.mockito.stubbing.Answer;
-
-/**
- * Use it to configure Mockito. For now there are not many configuration options but it may change in future.
- *
- * <p>
- * In most cases you don't really need to configure Mockito. For example in case of working with legacy code,
- * when you might want to have different 'mocking style' this interface might be helpful.
- * A reason of configuring Mockito might be if you disagree with the {@link org.mockito.Answers#RETURNS_DEFAULTS}
- * unstubbed mocks return.
- *
- * <p>
- * To configure Mockito create exactly <b>org.mockito.configuration.MockitoConfiguration</b> class
- * that implements this interface.
- *
- * <p>
- * Configuring Mockito is completely <b>optional</b> - nothing happens if there isn't any
- * <b>org.mockito.configuration.MockitoConfiguration</b> on the classpath.
- *
- * <p>
- * <b>org.mockito.configuration.MockitoConfiguration</b> must implement <code>IMockitoConfiguration</code> or
- * extend {@link DefaultMockitoConfiguration}
- *
- * <p>
- * Mockito will store single instance of <code>org.mockito.configuration.MockitoConfiguration</code>
- * per thread (using <code>ThreadLocal</code>).
- * For sanity of your tests, don't make the implementation stateful.
- *
- * <p>
- * If you have comments on Mockito configuration feature don't hesitate to write to mockito@googlegroups.com.
- */
-public interface IMockitoConfiguration {
-
-    /**
-     * Allows configuring the default answers of unstubbed invocations
-     * <p>
-     * See javadoc for {@link IMockitoConfiguration}
-     */
-    Answer<Object> getDefaultAnswer();
-
-    /**
-     * Configures annotations for mocks.
-     *
-     * <p>
-     * This method will have lower priority that the new extension mechanism.
-     * That is if it exists on the classpath both a class <code>org.mockito.configuration.MockitoConfiguration</code>
-     * and a file <code>mockito-extensions/org.mockito.plugins.AnnotationEngine</code> then the implementation of
-     * <code>org.mockito.configuration.MockitoConfiguration</code> will be chosen instead of the one in the file.
-     *
-     * <p>
-     * See javadoc for {@link IMockitoConfiguration}
-     *
-     * @deprecated Please use the extension mechanism {@link org.mockito.plugins.AnnotationEngine} instead,
-     *             this method will probably be removed in mockito 3.
-     */
-    @Deprecated
-    AnnotationEngine getAnnotationEngine();
-
-    /**
-     * This should be turned on unless you're a Mockito developer and you wish
-     * to have verbose (read: messy) stack traces that only few understand (eg:
-     * Mockito developers)
-     * <p>
-     * See javadoc for {@link IMockitoConfiguration}
-     *
-     * @return if Mockito should clean stack traces
-     */
-    boolean cleansStackTrace();
-
-    /**
-     * Allow objenesis to cache classes. If you're in an environment where classes
-     * are dynamically reloaded, you can disable this to avoid classcast exceptions.
-     */
-    boolean enableClassCache();
-}
diff --git a/src/main/java/org/mockito/creation/instance/InstantiationException.java b/src/main/java/org/mockito/creation/instance/InstantiationException.java
deleted file mode 100644
index 1cfbaba23f..0000000000
--- a/src/main/java/org/mockito/creation/instance/InstantiationException.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.creation.instance;
-
-import org.mockito.exceptions.base.MockitoException;
-
-/**
- * Exception generated when {@link Instantiator#newInstance(Class)} failed.
- *
- * @since 2.15.4
- */
-public class InstantiationException extends MockitoException {
-
-    /**
-     * @since 2.15.4
-     */
-    public InstantiationException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
diff --git a/src/main/java/org/mockito/creation/instance/Instantiator.java b/src/main/java/org/mockito/creation/instance/Instantiator.java
deleted file mode 100644
index 9ce37b5fdd..0000000000
--- a/src/main/java/org/mockito/creation/instance/Instantiator.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.creation.instance;
-
-/**
- * Provides instances of classes.
- * See more information about Mockito plugin {@link org.mockito.plugins.InstantiatorProvider2}
- *
- * @since 2.15.4
- */
-public interface Instantiator {
-
-    /**
-     * Creates instance of given class
-     *
-     * @since 2.15.4
-     */
-    <T> T newInstance(Class<T> cls) throws InstantiationException;
-
-}
diff --git a/src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java b/src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java
deleted file mode 100644
index a3229a8c80..0000000000
--- a/src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.exceptions.stacktrace;
-
-/**
- * Decides if particular StackTraceElement is excluded from the human-readable stack trace output.
- * Mockito stack trace filtering mechanism uses this information.
- * <p>
- * Excluding an element will make it not show in the cleaned stack trace.
- * Not-excluding an element does not guarantee it will be shown (e.g. it depends on the implementation of
- * {@linkplain org.mockito.internal.exceptions.stacktrace.StackTraceFilter Mockito internal cleaner}).
- * <p>
- * The implementations are required to be thread safe ; for example, make them stateless.
- * <p>
- * See also the {@linkplain org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleaner Mockito default implementation}
- */
-public interface StackTraceCleaner {
-
-    /**
-     * Decides if element is included.
-     *
-     * @param candidate element of the actual stack trace
-     * @return whether the element should be excluded from cleaned stack trace.
-     */
-    boolean isIn(StackTraceElement candidate);
-}
diff --git a/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
deleted file mode 100644
index b4cd073523..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.exceptions.verification;
-
-import static org.mockito.internal.util.StringUtil.removeFirstLine;
-
-import org.mockito.exceptions.base.MockitoAssertionError;
-
-public class ArgumentsAreDifferent extends MockitoAssertionError {
-
-    private static final long serialVersionUID = 1L;
-
-    public ArgumentsAreDifferent(String message) {
-        super(message);
-    }
-
-    /**
-     * Three-arg constructor for compatibility with ExceptionFactory's three-arg
-     * create method. This implementation simply ignores the second and third
-     * arguments.
-     *
-     * @param message
-     * @param wanted ignored
-     * @param actual ignored
-     */
-    public ArgumentsAreDifferent(String message, String wanted, String actual) {
-        this(message);
-    }
-
-    @Override
-    public String toString() {
-        return removeFirstLine(super.toString());
-    }
-}
diff --git a/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java
deleted file mode 100644
index 5ffbb2f83b..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.exceptions.verification;
-
-/**
- * @since 2.27.5
- */
-public class TooFewActualInvocations extends TooLittleActualInvocations {
-
-    private static final long serialVersionUID = 1L;
-
-    public TooFewActualInvocations(String message) {
-        super(message);
-    }
-}
diff --git a/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java
deleted file mode 100644
index 39bd30f82c..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * 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;
-
-/**
- * @deprecated as of 2.27.5. Please use {@link TooFewActualInvocations} instead.
- * @see TooFewActualInvocations
- */
-@Deprecated
-public class TooLittleActualInvocations extends MockitoAssertionError {
-
-    private static final long serialVersionUID = 1L;
-
-    public TooLittleActualInvocations(String message) {
-        super(message);
-    }
-}
diff --git a/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
deleted file mode 100644
index 73e364e04a..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.exceptions.verification.junit;
-
-import static org.mockito.internal.util.StringUtil.removeFirstLine;
-
-import junit.framework.ComparisonFailure;
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-
-
-public class ArgumentsAreDifferent extends ComparisonFailure {
-
-    private static final long serialVersionUID = 1L;
-    private final String message;
-    private final StackTraceElement[] unfilteredStackTrace;
-
-    public ArgumentsAreDifferent(String message, String wanted, String actual) {
-        super(message, wanted, actual);
-        this.message = message;
-
-        unfilteredStackTrace = getStackTrace();
-        ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
-        filter.filter(this);
-    }
-
-    @Override
-    public String getMessage() {
-        return message;
-    }
-
-    public StackTraceElement[] getUnfilteredStackTrace() {
-        return unfilteredStackTrace;
-    }
-
-    @Override
-    public String toString() {
-        return removeFirstLine(super.toString());
-    }
-}
diff --git a/src/main/java/org/mockito/exceptions/verification/junit/package-info.java b/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
deleted file mode 100644
index ad4ab7751f..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-/**
- * JUnit integration to provide better support for JUnit 4 and
- * earlier in IDEs.
- *
- * @see org.mockito.exceptions.verification.opentest4j
- */
-package org.mockito.exceptions.verification.junit;
diff --git a/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
deleted file mode 100644
index 989e6eb70d..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.exceptions.verification.opentest4j;
-
-import static org.mockito.internal.util.StringUtil.removeFirstLine;
-
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-import org.opentest4j.AssertionFailedError;
-
-
-public class ArgumentsAreDifferent extends AssertionFailedError {
-
-    private static final long serialVersionUID = 1L;
-    private final String message;
-    private final StackTraceElement[] unfilteredStackTrace;
-
-    public ArgumentsAreDifferent(String message, String wanted, String actual) {
-        super(message, wanted, actual);
-        this.message = message;
-
-        unfilteredStackTrace = getStackTrace();
-        ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
-        filter.filter(this);
-    }
-
-    @Override
-    public String getMessage() {
-        return message;
-    }
-
-    public StackTraceElement[] getUnfilteredStackTrace() {
-        return unfilteredStackTrace;
-    }
-
-    @Override
-    public String toString() {
-        return removeFirstLine(super.toString());
-    }
-}
diff --git a/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java b/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java
deleted file mode 100644
index 2e84ddd662..0000000000
--- a/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-/**
- * Integration to provide better support for IDEs that support OpenTest4J.
- *
- * @see org.mocktio.exceptions.verification.junit
- * @see org.mocktio.exceptions.verification.junit4
- */
-package org.mockito.exceptions.verification.opentest4j;
diff --git a/src/main/java/org/mockito/internal/InOrderImpl.java b/src/main/java/org/mockito/internal/InOrderImpl.java
deleted file mode 100644
index 45aa95aa99..0000000000
--- a/src/main/java/org/mockito/internal/InOrderImpl.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal;
-
-import static org.mockito.internal.exceptions.Reporter.inOrderRequiresFamiliarMock;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.InOrder;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.verification.InOrderContextImpl;
-import org.mockito.internal.verification.InOrderWrapper;
-import org.mockito.internal.verification.VerificationModeFactory;
-import org.mockito.internal.verification.VerificationWrapper;
-import org.mockito.internal.verification.VerificationWrapperInOrderWrapper;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.internal.verification.api.VerificationInOrderMode;
-import org.mockito.invocation.Invocation;
-import org.mockito.verification.VerificationMode;
-
-/**
- * Allows verifying in order. This class should not be exposed, hence default access.
- */
-public class InOrderImpl implements InOrder, InOrderContext {
-
-    private final MockitoCore mockitoCore = new MockitoCore();
-    private final List<Object> mocksToBeVerifiedInOrder = new LinkedList<Object>();
-    private final InOrderContext inOrderContext = new InOrderContextImpl();
-
-    public List<Object> getMocksToBeVerifiedInOrder() {
-        return mocksToBeVerifiedInOrder;
-    }
-
-    public InOrderImpl(List<?> mocksToBeVerifiedInOrder) {
-        this.mocksToBeVerifiedInOrder.addAll(mocksToBeVerifiedInOrder);
-    }
-
-    public <T> T verify(T mock) {
-        return this.verify(mock, VerificationModeFactory.times(1));
-    }
-
-    public <T> T verify(T mock, VerificationMode mode) {
-        if (!mocksToBeVerifiedInOrder.contains(mock)) {
-            throw inOrderRequiresFamiliarMock();
-        }
-        if (mode instanceof VerificationWrapper) {
-            return mockitoCore.verify(mock, new VerificationWrapperInOrderWrapper((VerificationWrapper) mode, this));
-        }  else if (!(mode instanceof VerificationInOrderMode)) {
-            throw new MockitoException(mode.getClass().getSimpleName() + " is not implemented to work with InOrder");
-        }
-        return mockitoCore.verify(mock, new InOrderWrapper((VerificationInOrderMode) mode, this));
-    }
-
-    public boolean isVerified(Invocation i) {
-        return inOrderContext.isVerified(i);
-    }
-
-    public void markVerified(Invocation i) {
-        inOrderContext.markVerified(i);
-    }
-
-    public void verifyNoMoreInteractions() {
-        mockitoCore.verifyNoMoreInteractionsInOrder(mocksToBeVerifiedInOrder, this);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/InternalMockHandler.java b/src/main/java/org/mockito/internal/InternalMockHandler.java
deleted file mode 100644
index 2fd95498ef..0000000000
--- a/src/main/java/org/mockito/internal/InternalMockHandler.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal;
-
-import org.mockito.invocation.MockHandler;
-
-/**
- * Deprecated, please use {@link MockHandler}.
- * <p>
- * This class was changed in Mockito in order to tidy up Mockito API
- * and make it easier for other frameworks to integrate with Mockito.
- * Since this class is internal, e.g. it resides in "org.mockito.internal" package,
- * Mockito team can change it without the need for major version release of Mockito.
- * <p>
- * This interface was deprecated in Mockito 2.10.0 and will be deleted in Mockito 4.0.
- */
-@Deprecated
-public interface InternalMockHandler<T> extends MockHandler {}
diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java
deleted file mode 100644
index d9f6312a1c..0000000000
--- a/src/main/java/org/mockito/internal/MockitoCore.java
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal;
-
-import static org.mockito.internal.exceptions.Reporter.*;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-import static org.mockito.internal.util.MockUtil.createMock;
-import static org.mockito.internal.util.MockUtil.getInvocationContainer;
-import static org.mockito.internal.util.MockUtil.getMockHandler;
-import static org.mockito.internal.util.MockUtil.isMock;
-import static org.mockito.internal.util.MockUtil.resetMock;
-import static org.mockito.internal.util.MockUtil.typeMockabilityOf;
-import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
-import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.mockito.InOrder;
-import org.mockito.MockSettings;
-import org.mockito.MockingDetails;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.internal.creation.MockSettingsImpl;
-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;
-import org.mockito.internal.util.DefaultMockingDetails;
-import org.mockito.internal.verification.MockAwareVerificationMode;
-import org.mockito.internal.verification.VerificationDataImpl;
-import org.mockito.internal.verification.VerificationModeFactory;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.internal.verification.api.VerificationDataInOrder;
-import org.mockito.internal.verification.api.VerificationDataInOrderImpl;
-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;
-
-
-@SuppressWarnings("unchecked")
-public class MockitoCore {
-
-    public boolean isTypeMockable(Class<?> typeToMock) {
-        return typeMockabilityOf(typeToMock).mockable();
-    }
-
-    public <T> T mock(Class<T> typeToMock, MockSettings settings) {
-        if (!MockSettingsImpl.class.isInstance(settings)) {
-            throw new IllegalArgumentException("Unexpected implementation of '" + settings.getClass().getCanonicalName() + "'\n" + "At the moment, you cannot provide your own implementations of that class.");
-        }
-        MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
-        MockCreationSettings<T> creationSettings = impl.build(typeToMock);
-        T mock = createMock(creationSettings);
-        mockingProgress().mockingStarted(mock, creationSettings);
-        return mock;
-    }
-
-    public <T> OngoingStubbing<T> when(T methodCall) {
-        MockingProgress mockingProgress = mockingProgress();
-        mockingProgress.stubbingStarted();
-        @SuppressWarnings("unchecked")
-        OngoingStubbing<T> stubbing = (OngoingStubbing<T>) mockingProgress.pullOngoingStubbing();
-        if (stubbing == null) {
-            mockingProgress.reset();
-            throw missingMethodInvocation();
-        }
-        return stubbing;
-    }
-
-    public <T> T verify(T mock, VerificationMode mode) {
-        if (mock == null) {
-            throw nullPassedToVerify();
-        }
-        MockingDetails mockingDetails = mockingDetails(mock);
-        if (!mockingDetails.isMock()) {
-            throw notAMockPassedToVerify(mock.getClass());
-        }
-        assertNotStubOnlyMock(mock);
-        MockHandler handler = mockingDetails.getMockHandler();
-        mock = (T) VerificationStartedNotifier.notifyVerificationStarted(
-            handler.getMockSettings().getVerificationStartedListeners(), mockingDetails);
-
-        MockingProgress mockingProgress = mockingProgress();
-        VerificationMode actualMode = mockingProgress.maybeVerifyLazily(mode);
-        mockingProgress.verificationStarted(new MockAwareVerificationMode(mock, actualMode, mockingProgress.verificationListeners()));
-        return mock;
-    }
-
-    public <T> void reset(T... mocks) {
-        MockingProgress mockingProgress = mockingProgress();
-        mockingProgress.validateState();
-        mockingProgress.reset();
-        mockingProgress.resetOngoingStubbing();
-
-        for (T m : mocks) {
-            resetMock(m);
-        }
-    }
-
-    public <T> void clearInvocations(T... mocks) {
-        MockingProgress mockingProgress = mockingProgress();
-        mockingProgress.validateState();
-        mockingProgress.reset();
-        mockingProgress.resetOngoingStubbing();
-
-        for (T m : mocks) {
-            getInvocationContainer(m).clearInvocations();
-        }
-    }
-
-    public void verifyNoMoreInteractions(Object... mocks) {
-        assertMocksNotEmpty(mocks);
-        mockingProgress().validateState();
-        for (Object mock : mocks) {
-            try {
-                if (mock == null) {
-                    throw nullPassedToVerifyNoMoreInteractions();
-                }
-                InvocationContainerImpl invocations = getInvocationContainer(mock);
-                assertNotStubOnlyMock(mock);
-                VerificationDataImpl data = new VerificationDataImpl(invocations, null);
-                noMoreInteractions().verify(data);
-            } catch (NotAMockException e) {
-                throw notAMockPassedToVerifyNoMoreInteractions();
-            }
-        }
-    }
-
-    public void verifyNoInteractions(Object... mocks) {
-        assertMocksNotEmpty(mocks);
-        mockingProgress().validateState();
-        for (Object mock : mocks) {
-            try {
-                if (mock == null) {
-                    throw nullPassedToVerifyNoMoreInteractions();
-                }
-                InvocationContainerImpl invocations = getInvocationContainer(mock);
-                assertNotStubOnlyMock(mock);
-                VerificationDataImpl data = new VerificationDataImpl(invocations, null);
-                noInteractions().verify(data);
-            } catch (NotAMockException e) {
-                throw notAMockPassedToVerifyNoMoreInteractions();
-            }
-        }
-    }
-
-    public void verifyNoMoreInteractionsInOrder(List<Object> mocks, InOrderContext inOrderContext) {
-        mockingProgress().validateState();
-        VerificationDataInOrder data = new VerificationDataInOrderImpl(inOrderContext, VerifiableInvocationsFinder.find(mocks), null);
-        VerificationModeFactory.noMoreInteractions().verifyInOrder(data);
-    }
-
-    private void assertMocksNotEmpty(Object[] mocks) {
-        if (mocks == null || mocks.length == 0) {
-            throw mocksHaveToBePassedToVerifyNoMoreInteractions();
-        }
-    }
-
-    private void assertNotStubOnlyMock(Object mock) {
-        if (getMockHandler(mock).getMockSettings().isStubOnly()) {
-            throw stubPassedToVerify(mock);
-        }
-    }
-
-    public InOrder inOrder(Object... mocks) {
-        if (mocks == null || mocks.length == 0) {
-            throw mocksHaveToBePassedWhenCreatingInOrder();
-        }
-        for (Object mock : mocks) {
-            if (mock == null) {
-                throw nullPassedWhenCreatingInOrder();
-            }
-            if (!isMock(mock)) {
-                throw notAMockPassedWhenCreatingInOrder();
-            }
-            assertNotStubOnlyMock(mock);
-        }
-        return new InOrderImpl(Arrays.asList(mocks));
-    }
-
-    public Stubber stubber() {
-        return stubber(null);
-    }
-
-    public Stubber stubber(Strictness strictness) {
-        MockingProgress mockingProgress = mockingProgress();
-        mockingProgress.stubbingStarted();
-        mockingProgress.resetOngoingStubbing();
-        return new StubberImpl(strictness);
-    }
-
-    public void validateMockitoUsage() {
-        mockingProgress().validateState();
-    }
-
-    /**
-     * For testing purposes only. Is not the part of main API.
-     *
-     * @return last invocation
-     */
-    public Invocation getLastInvocation() {
-        OngoingStubbingImpl ongoingStubbing = ((OngoingStubbingImpl) mockingProgress().pullOngoingStubbing());
-        List<Invocation> allInvocations = ongoingStubbing.getRegisteredInvocations();
-        return allInvocations.get(allInvocations.size() - 1);
-    }
-
-    public Object[] ignoreStubs(Object... mocks) {
-        for (Object m : mocks) {
-            InvocationContainerImpl container = getInvocationContainer(m);
-            List<Invocation> ins = container.getInvocations();
-            for (Invocation in : ins) {
-                if (in.stubInfo() != null) {
-                    in.ignoreForVerification();
-                }
-            }
-        }
-        return mocks;
-    }
-
-    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/CaptorAnnotationProcessor.java b/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
deleted file mode 100644
index 578defcce4..0000000000
--- a/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import java.lang.reflect.Field;
-
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.reflection.GenericMaster;
-
-/**
- * Instantiate {@link ArgumentCaptor} a field annotated by &#64;Captor.
- */
-public class CaptorAnnotationProcessor implements FieldAnnotationProcessor<Captor> {
-    public Object process(Captor annotation, Field field) {
-        Class<?> type = field.getType();
-        if (!ArgumentCaptor.class.isAssignableFrom(type)) {
-            throw new MockitoException("@Captor field must be of the type ArgumentCaptor.\n" + "Field: '"
-               + field.getName() + "' has wrong type\n"
-               + "For info how to use @Captor annotations see examples in javadoc for MockitoAnnotations class.");
-        }
-        Class<?> cls = new GenericMaster().getGenericType(field);
-        return ArgumentCaptor.forClass(cls);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java b/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
deleted file mode 100644
index b4312af50c..0000000000
--- a/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import java.io.Serializable;
-
-import org.mockito.configuration.AnnotationEngine;
-import org.mockito.configuration.DefaultMockitoConfiguration;
-import org.mockito.configuration.IMockitoConfiguration;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.stubbing.Answer;
-
-/**
- * Thread-safe wrapper on user-defined org.mockito.configuration.MockitoConfiguration implementation
- */
-public class GlobalConfiguration implements IMockitoConfiguration, Serializable {
-    private static final long serialVersionUID = -2860353062105505938L;
-
-    private static final ThreadLocal<IMockitoConfiguration> GLOBAL_CONFIGURATION = new ThreadLocal<IMockitoConfiguration>();
-
-    //back door for testing
-    IMockitoConfiguration getIt() {
-        return GLOBAL_CONFIGURATION.get();
-    }
-
-    public GlobalConfiguration() {
-        //Configuration should be loaded only once but I cannot really test it
-        if (GLOBAL_CONFIGURATION.get() == null) {
-            GLOBAL_CONFIGURATION.set(createConfig());
-        }
-    }
-
-    private IMockitoConfiguration createConfig() {
-        IMockitoConfiguration defaultConfiguration = new DefaultMockitoConfiguration();
-        IMockitoConfiguration config = new ClassPathLoader().loadConfiguration();
-        if (config != null) {
-            return config;
-        } else {
-            return defaultConfiguration;
-        }
-    }
-
-    public static void validate() {
-        new GlobalConfiguration();
-    }
-
-    public AnnotationEngine getAnnotationEngine() {
-        return GLOBAL_CONFIGURATION.get().getAnnotationEngine();
-    }
-
-    public org.mockito.plugins.AnnotationEngine tryGetPluginAnnotationEngine() {
-        IMockitoConfiguration configuration = GLOBAL_CONFIGURATION.get();
-        if (configuration.getClass() == DefaultMockitoConfiguration.class) {
-            return Plugins.getAnnotationEngine();
-        }
-        return configuration.getAnnotationEngine();
-    }
-
-
-
-    public boolean cleansStackTrace() {
-        return GLOBAL_CONFIGURATION.get().cleansStackTrace();
-    }
-
-    public boolean enableClassCache() {
-        return GLOBAL_CONFIGURATION.get().enableClassCache();
-    }
-
-    public Answer<Object> getDefaultAnswer() {
-        return GLOBAL_CONFIGURATION.get().getDefaultAnswer();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java b/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
deleted file mode 100644
index 5bcc00e384..0000000000
--- a/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import static org.mockito.internal.exceptions.Reporter.moreThanOneAnnotationNotAllowed;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.plugins.AnnotationEngine;
-
-/**
- * Initializes fields annotated with &#64;{@link org.mockito.Mock} or &#64;{@link org.mockito.Captor}.
- *
- * <p>
- * The {@link #process(Class, Object)} method implementation <strong>does not</strong> process super classes!
- *
- * @see MockitoAnnotations
- */
-@SuppressWarnings("unchecked")
-public class IndependentAnnotationEngine implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
-    private final Map<Class<? extends Annotation>, FieldAnnotationProcessor<?>> annotationProcessorMap = new HashMap<Class<? extends Annotation>, FieldAnnotationProcessor<?>>();
-
-    public IndependentAnnotationEngine() {
-        registerAnnotationProcessor(Mock.class, new MockAnnotationProcessor());
-        registerAnnotationProcessor(Captor.class, new CaptorAnnotationProcessor());
-    }
-
-    private Object createMockFor(Annotation annotation, Field field) {
-        return forAnnotation(annotation).process(annotation, field);
-    }
-
-    private <A extends Annotation> FieldAnnotationProcessor<A> forAnnotation(A annotation) {
-        if (annotationProcessorMap.containsKey(annotation.annotationType())) {
-            return (FieldAnnotationProcessor<A>) annotationProcessorMap.get(annotation.annotationType());
-        }
-        return new FieldAnnotationProcessor<A>() {
-            public Object process(A annotation, Field field) {
-                return null;
-            }
-        };
-    }
-
-    private <A extends Annotation> void registerAnnotationProcessor(Class<A> annotationClass, FieldAnnotationProcessor<A> fieldAnnotationProcessor) {
-        annotationProcessorMap.put(annotationClass, fieldAnnotationProcessor);
-    }
-
-    @Override
-    public void process(Class<?> clazz, Object testInstance) {
-        Field[] fields = clazz.getDeclaredFields();
-        for (Field field : fields) {
-            boolean alreadyAssigned = false;
-            for(Annotation annotation : field.getAnnotations()) {
-                Object mock = createMockFor(annotation, field);
-                if (mock != null) {
-                    throwIfAlreadyAssigned(field, alreadyAssigned);
-                    alreadyAssigned = true;
-                    try {
-                        setField(testInstance, field,mock);
-                    } catch (Exception e) {
-                        throw new MockitoException("Problems setting field " + field.getName() + " annotated with "
-                                + annotation, e);
-                    }
-                }
-            }
-        }
-    }
-
-    void throwIfAlreadyAssigned(Field field, boolean alreadyAssigned) {
-        if (alreadyAssigned) {
-            throw moreThanOneAnnotationNotAllowed(field.getName());
-        }
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java b/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
deleted file mode 100644
index 1fba127ef0..0000000000
--- a/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
-
-import java.lang.reflect.Field;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.mockito.MockitoAnnotations;
-import org.mockito.internal.configuration.injection.scanner.InjectMocksScanner;
-import org.mockito.internal.configuration.injection.scanner.MockScanner;
-import org.mockito.plugins.AnnotationEngine;
-
-/**
- * See {@link MockitoAnnotations}
- */
-public class InjectingAnnotationEngine implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
-    private final AnnotationEngine delegate = new IndependentAnnotationEngine();
-    private final AnnotationEngine spyAnnotationEngine = new SpyAnnotationEngine();
-
-    /**
-     * Process the fields of the test instance and create Mocks, Spies, Captors and inject them on fields
-     * annotated &#64;InjectMocks.
-     *
-     * <p>
-     * This code process the test class and the super classes.
-     * <ol>
-     * <li>First create Mocks, Spies, Captors.</li>
-     * <li>Then try to inject them.</li>
-     * </ol>
-     *
-     * @param clazz Not used
-     * @param testInstance The instance of the test, should not be null.
-     *
-     * @see org.mockito.plugins.AnnotationEngine#process(Class, Object)
-     */
-    public void process(Class<?> clazz, Object testInstance) {
-        processIndependentAnnotations(testInstance.getClass(), testInstance);
-        processInjectMocks(testInstance.getClass(), testInstance);
-    }
-
-    private void processInjectMocks(final Class<?> clazz, final Object testInstance) {
-        Class<?> classContext = clazz;
-        while (classContext != Object.class) {
-            injectMocks(testInstance);
-            classContext = classContext.getSuperclass();
-        }
-    }
-
-    private void processIndependentAnnotations(final Class<?> clazz, final Object testInstance) {
-        Class<?> classContext = clazz;
-        while (classContext != Object.class) {
-            //this will create @Mocks, @Captors, etc:
-            delegate.process(classContext, testInstance);
-            //this will create @Spies:
-            spyAnnotationEngine.process(classContext, testInstance);
-
-            classContext = classContext.getSuperclass();
-        }
-    }
-
-
-    /**
-     * Initializes mock/spies dependencies for objects annotated with
-     * &#064;InjectMocks for given testClassInstance.
-     * <p>
-     * See examples in javadoc for {@link MockitoAnnotations} class.
-     *
-     * @param testClassInstance
-     *            Test class, usually <code>this</code>
-     */
-    public void injectMocks(final Object testClassInstance) {
-        Class<?> clazz = testClassInstance.getClass();
-        Set<Field> mockDependentFields = new HashSet<Field>();
-        Set<Object> mocks = newMockSafeHashSet();
-
-        while (clazz != Object.class) {
-            new InjectMocksScanner(clazz).addTo(mockDependentFields);
-            new MockScanner(testClassInstance, clazz).addPreparedMocks(mocks);
-            onInjection(testClassInstance, clazz, mockDependentFields, mocks);
-            clazz = clazz.getSuperclass();
-        }
-
-        new DefaultInjectionEngine().injectMocksOnFields(mockDependentFields, mocks, testClassInstance);
-    }
-
-    protected void onInjection(Object testClassInstance, Class<?> clazz, Set<Field> mockDependentFields, Set<Object> mocks) {
-
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java b/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
deleted file mode 100644
index 60882f95fc..0000000000
--- a/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import java.lang.reflect.Field;
-
-import org.mockito.Mock;
-import org.mockito.MockSettings;
-import org.mockito.Mockito;
-
-/**
- * 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(name);
-        } else {
-            mockSettings.name(annotation.name());
-        }
-        if(annotation.serializable()){
-            mockSettings.serializable();
-        }
-        if(annotation.stubOnly()){
-            mockSettings.stubOnly();
-        }
-        if(annotation.lenient()){
-            mockSettings.lenient();
-        }
-
-        // see @Mock answer default value
-        mockSettings.defaultAnswer(annotation.answer());
-        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
deleted file mode 100644
index 1a9ce04155..0000000000
--- a/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import static org.mockito.Mockito.CALLS_REAL_METHODS;
-import static org.mockito.Mockito.withSettings;
-import static org.mockito.internal.exceptions.Reporter.unsupportedCombinationOfAnnotations;
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Modifier;
-
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockSettings;
-import org.mockito.Mockito;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.plugins.AnnotationEngine;
-
-/**
- * Process fields annotated with &#64;Spy.
- * <p/>
- * <p>
- * Will try transform the field in a spy as with <code>Mockito.spy()</code>.
- * </p>
- * <p/>
- * <p>
- * If the field is not initialized, will try to initialize it, with a no-arg constructor.
- * </p>
- * <p/>
- * <p>
- * If the field is also annotated with the <strong>compatible</strong> &#64;InjectMocks then the field will be ignored,
- * The injection engine will handle this specific case.
- * </p>
- * <p/>
- * <p>This engine will fail, if the field is also annotated with incompatible Mockito annotations.
- */
-@SuppressWarnings({"unchecked"})
-public class SpyAnnotationEngine implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
-
-    @Override
-    public void process(Class<?> context, Object testInstance) {
-        Field[] fields = context.getDeclaredFields();
-        for (Field field : fields) {
-            if (field.isAnnotationPresent(Spy.class) && !field.isAnnotationPresent(InjectMocks.class)) {
-                assertNoIncompatibleAnnotations(Spy.class, field, Mock.class, Captor.class);
-                field.setAccessible(true);
-                Object instance;
-                try {
-                    instance = field.get(testInstance);
-                    if (MockUtil.isMock(instance)) {
-                        // instance has been spied earlier
-                        // for example happens when MockitoAnnotations.initMocks is called two times.
-                        Mockito.reset(instance);
-                    } else if (instance != null) {
-                        field.set(testInstance, spyInstance(field, instance));
-                    } else {
-                        field.set(testInstance, spyNewInstance(testInstance, field));
-                    }
-                } catch (Exception e) {
-                    throw new MockitoException("Unable to initialize @Spy annotated field '" + field.getName() + "'.\n" + e.getMessage(), e);
-                }
-            }
-        }
-    }
-
-    private static Object spyInstance(Field field, Object instance) {
-        return Mockito.mock(instance.getClass(),
-                            withSettings().spiedInstance(instance)
-                                                           .defaultAnswer(CALLS_REAL_METHODS)
-                                                           .name(field.getName()));
-    }
-
-    private static Object spyNewInstance(Object testInstance, Field field)
-            throws InstantiationException, IllegalAccessException, InvocationTargetException {
-        MockSettings settings = withSettings().defaultAnswer(CALLS_REAL_METHODS)
-                                              .name(field.getName());
-        Class<?> type = field.getType();
-        if (type.isInterface()) {
-            return Mockito.mock(type, settings.useConstructor());
-        }
-        int modifiers = type.getModifiers();
-        if (typeIsPrivateAbstractInnerClass(type, modifiers)) {
-            throw new MockitoException(join("@Spy annotation can't initialize private abstract inner classes.",
-                                            "  inner class: '" + type.getSimpleName() + "'",
-                                            "  outer class: '" + type.getEnclosingClass().getSimpleName() + "'",
-                                            "",
-                                            "You should augment the visibility of this inner class"));
-        }
-        if (typeIsNonStaticInnerClass(type, modifiers)) {
-            Class<?> enclosing = type.getEnclosingClass();
-            if (!enclosing.isInstance(testInstance)) {
-                throw new MockitoException(join("@Spy annotation can only initialize inner classes declared in the test.",
-                                                "  inner class: '" + type.getSimpleName() + "'",
-                                                "  outer class: '" + enclosing.getSimpleName() + "'",
-                                                ""));
-            }
-            return Mockito.mock(type, settings.useConstructor()
-                                              .outerInstance(testInstance));
-        }
-
-        Constructor<?> constructor = noArgConstructorOf(type);
-        if (Modifier.isPrivate(constructor.getModifiers())) {
-            constructor.setAccessible(true);
-            return Mockito.mock(type, settings.spiedInstance(constructor.newInstance()));
-        } else {
-            return Mockito.mock(type, settings.useConstructor());
-        }
-    }
-
-    private static Constructor<?> noArgConstructorOf(Class<?> type) {
-        Constructor<?> constructor;
-        try {
-            constructor = type.getDeclaredConstructor();
-        } catch (NoSuchMethodException e) {
-            throw new MockitoException("Please ensure that the type '" + type.getSimpleName() + "' has a no-arg constructor.");
-        }
-        return constructor;
-    }
-
-    private static boolean typeIsNonStaticInnerClass(Class<?> type, int modifiers) {
-        return !Modifier.isStatic(modifiers) && type.getEnclosingClass() != null;
-    }
-
-    private static boolean typeIsPrivateAbstractInnerClass(Class<?> type, int modifiers) {
-        return Modifier.isPrivate(modifiers) && Modifier.isAbstract(modifiers) && type.getEnclosingClass() != null;
-    }
-
-    //TODO duplicated elsewhere
-    private static void assertNoIncompatibleAnnotations(Class<? extends Annotation> annotation,
-                                                        Field field,
-                                                        Class<? extends Annotation>... undesiredAnnotations) {
-        for (Class<? extends Annotation> u : undesiredAnnotations) {
-            if (field.isAnnotationPresent(u)) {
-                throw unsupportedCombinationOfAnnotations(annotation.getSimpleName(),
-                                                          u.getSimpleName());
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
deleted file mode 100644
index 38f5760226..0000000000
--- a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.injection;
-
-import static org.mockito.internal.exceptions.Reporter.cannotInitializeForInjectMocksAnnotation;
-import static org.mockito.internal.exceptions.Reporter.fieldInitialisationThrewException;
-import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
-import static org.mockito.internal.util.reflection.SuperTypesLastSorter.sortSuperTypesLast;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;
-import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;
-import org.mockito.internal.configuration.injection.filter.TerminalMockCandidateFilter;
-import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.reflection.FieldInitializationReport;
-import org.mockito.internal.util.reflection.FieldInitializer;
-
-/**
- * Inject mocks using first setters then fields, if no setters available.
- *
- * <p>
- * <u>Algorithm :<br></u>
- * for each field annotated by @InjectMocks
- *   <ul>
- *   <li>initialize field annotated by @InjectMocks
- *   <li>for each fields of a class in @InjectMocks type hierarchy
- *     <ul>
- *     <li>make a copy of mock candidates
- *     <li>order fields from sub-type to super-type, then by field name
- *     <li>for the list of fields in a class try two passes of :
- *         <ul>
- *             <li>find mock candidate by type
- *             <li>if more than <b>*one*</b> candidate find mock candidate on name
- *             <li>if one mock candidate then
- *                 <ul>
- *                     <li>set mock by property setter if possible
- *                     <li>else set mock by field injection
- *                 </ul>
- *             <li>remove mock from mocks copy (mocks are just injected once in a class)
- *             <li>remove injected field from list of class fields
- *         </ul>
- *     <li>else don't fail, user will then provide dependencies
- *     </ul>
- *   </ul>
- * </p>
- *
- * <p>
- * <u>Note:</u> If the field needing injection is not initialized, the strategy tries
- * to create one using a no-arg constructor of the field type.
- * </p>
- */
-public class PropertyAndSetterInjection extends MockInjectionStrategy {
-
-    private final MockCandidateFilter mockCandidateFilter =
-            new TypeBasedCandidateFilter(
-                    new NameBasedCandidateFilter(
-                            new TerminalMockCandidateFilter()));
-
-    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {
-        public boolean isOut(Field object) {
-            return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());
-        }
-    };
-
-
-    public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {
-        FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);
-
-        // for each field in the class hierarchy
-        boolean injectionOccurred = false;
-        Class<?> fieldClass = report.fieldClass();
-        Object fieldInstanceNeedingInjection = report.fieldInstance();
-        while (fieldClass != Object.class) {
-            injectionOccurred |= injectMockCandidates(fieldClass, fieldInstanceNeedingInjection, newMockSafeHashSet(mockCandidates));
-            fieldClass = fieldClass.getSuperclass();
-        }
-        return injectionOccurred;
-    }
-
-    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {
-        try {
-            return new FieldInitializer(fieldOwner, field).initialize();
-        } catch (MockitoException e) {
-            if(e.getCause() instanceof InvocationTargetException) {
-                Throwable realCause = e.getCause().getCause();
-                throw fieldInitialisationThrewException(field, realCause);
-            }
-            throw cannotInitializeForInjectMocksAnnotation(field.getName(),e.getMessage());
-        }
-    }
-
-
-    private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Object injectee, Set<Object> mocks) {
-        boolean injectionOccurred;
-        List<Field> orderedCandidateInjecteeFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);
-        // pass 1
-        injectionOccurred = injectMockCandidatesOnFields(mocks, injectee, false, orderedCandidateInjecteeFields);
-        // pass 2
-        injectionOccurred |= injectMockCandidatesOnFields(mocks, injectee, injectionOccurred, orderedCandidateInjecteeFields);
-        return injectionOccurred;
-    }
-
-    private boolean injectMockCandidatesOnFields(Set<Object> mocks,
-                                                 Object injectee,
-                                                 boolean injectionOccurred,
-                                                 List<Field> orderedCandidateInjecteeFields) {
-        for (Iterator<Field> it = orderedCandidateInjecteeFields.iterator(); it.hasNext(); ) {
-            Field candidateField = it.next();
-            Object injected = mockCandidateFilter.filterCandidate(mocks, candidateField, orderedCandidateInjecteeFields, injectee)
-                                                 .thenInject();
-            if (injected != null) {
-                injectionOccurred |= true;
-                mocks.remove(injected);
-                it.remove();
-            }
-        }
-        return injectionOccurred;
-    }
-
-    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {
-        List<Field> declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields());
-        declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic);
-
-        return sortSuperTypesLast(declaredFields);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java b/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
deleted file mode 100644
index d44080a341..0000000000
--- a/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.injection;
-
-import static org.mockito.Mockito.withSettings;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
-
-import java.lang.reflect.Field;
-import java.util.Set;
-
-import org.mockito.Mockito;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.internal.util.reflection.FieldReader;
-
-/**
- * Handler for field annotated with &#64;InjectMocks and &#64;Spy.
- *
- * <p>
- * The handler assumes that field initialization AND injection already happened.
- * So if the field is still null, then nothing will happen there.
- * </p>
- */
-public class SpyOnInjectedFieldsHandler extends MockInjectionStrategy {
-
-    @Override
-    protected boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
-        FieldReader fieldReader = new FieldReader(fieldOwner, field);
-
-        // TODO refoctor : code duplicated in SpyAnnotationEngine
-        if(!fieldReader.isNull() && field.isAnnotationPresent(Spy.class)) {
-            try {
-                Object instance = fieldReader.read();
-                if (MockUtil.isMock(instance)) {
-                    // A. instance has been spied earlier
-                    // B. protect against multiple use of MockitoAnnotations.initMocks()
-                    Mockito.reset(instance);
-                } else {
-                    Object mock = Mockito.mock(instance.getClass(), withSettings()
-                        .spiedInstance(instance)
-                        .defaultAnswer(Mockito.CALLS_REAL_METHODS)
-                        .name(field.getName()));
-                    setField(fieldOwner, field, mock);
-                }
-            } catch (Exception e) {
-                throw new MockitoException("Problems initiating spied field " + field.getName(), e);
-            }
-        }
-
-        return false;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
deleted file mode 100644
index dc50e9d8b5..0000000000
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.injection.filter;
-
-import static org.mockito.internal.util.MockUtil.getMockName;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-public class NameBasedCandidateFilter implements MockCandidateFilter {
-    private final MockCandidateFilter next;
-
-    public NameBasedCandidateFilter(MockCandidateFilter next) {
-        this.next = next;
-    }
-
-    public OngoingInjector filterCandidate(final Collection<Object> mocks,
-                                           final Field candidateFieldToBeInjected,
-                                           final List<Field> allRemainingCandidateFields,
-                                           final Object injectee) {
-        if (mocks.size() == 1
-                && anotherCandidateMatchesMockName(mocks, candidateFieldToBeInjected, allRemainingCandidateFields)) {
-            return OngoingInjector.nop;
-        }
-
-        return next.filterCandidate(tooMany(mocks) ? selectMatchingName(mocks, candidateFieldToBeInjected) : mocks,
-                                    candidateFieldToBeInjected,
-                                    allRemainingCandidateFields,
-                                    injectee);
-    }
-
-    private boolean tooMany(Collection<Object> mocks) {
-        return mocks.size() > 1;
-    }
-
-    private List<Object> selectMatchingName(Collection<Object> mocks, Field candidateFieldToBeInjected) {
-        List<Object> mockNameMatches = new ArrayList<Object>();
-        for (Object mock : mocks) {
-            if (candidateFieldToBeInjected.getName().equals(getMockName(mock).toString())) {
-                mockNameMatches.add(mock);
-            }
-        }
-        return mockNameMatches;
-    }
-
-    /*
-     * In this case we have to check whether we have conflicting naming
-     * fields. E.g. 2 fields of the same type, but we have to make sure
-     * we match on the correct name.
-     *
-     * Therefore we have to go through all other fields and make sure
-     * whenever we find a field that does match its name with the mock
-     * name, we should take that field instead.
-     */
-    private boolean anotherCandidateMatchesMockName(final Collection<Object> mocks,
-                                                    final Field candidateFieldToBeInjected,
-                                                    final List<Field> allRemainingCandidateFields) {
-        String mockName = getMockName(mocks.iterator().next()).toString();
-
-        for (Field otherCandidateField : allRemainingCandidateFields) {
-            if (!otherCandidateField.equals(candidateFieldToBeInjected)
-                    && otherCandidateField.getType().equals(candidateFieldToBeInjected.getType())
-                    && otherCandidateField.getName().equals(mockName)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
deleted file mode 100644
index 4644e218aa..0000000000
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.injection.filter;
-
-import static org.mockito.internal.exceptions.Reporter.cannotInjectDependency;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
-
-import java.lang.reflect.Field;
-import java.util.Collection;
-import java.util.List;
-
-import org.mockito.internal.util.reflection.BeanPropertySetter;
-
-/**
- * This node returns an actual injecter which will be either :
- *
- * <ul>
- * <li>an {@link OngoingInjector} that do nothing if a candidate couldn't be found</li>
- * <li>an {@link OngoingInjector} that will try to inject the candidate trying first the property setter then if not possible try the field access</li>
- * </ul>
- */
-public class TerminalMockCandidateFilter implements MockCandidateFilter {
-    public OngoingInjector filterCandidate(final Collection<Object> mocks,
-                                           final Field candidateFieldToBeInjected,
-                                           final List<Field> allRemainingCandidateFields,
-                                           final Object injectee) {
-        if(mocks.size() == 1) {
-            final Object matchingMock = mocks.iterator().next();
-
-            return new OngoingInjector() {
-                public Object thenInject() {
-                    try {
-                        if (!new BeanPropertySetter(injectee, candidateFieldToBeInjected).set(matchingMock)) {
-                            setField(injectee, candidateFieldToBeInjected,matchingMock);
-                        }
-                    } catch (RuntimeException e) {
-                        throw cannotInjectDependency(candidateFieldToBeInjected, matchingMock, e);
-                    }
-                    return matchingMock;
-                }
-            };
-        }
-
-        return OngoingInjector.nop;
-
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
deleted file mode 100644
index 7284399258..0000000000
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.injection.filter;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-public class TypeBasedCandidateFilter implements MockCandidateFilter {
-
-    private final MockCandidateFilter next;
-
-    public TypeBasedCandidateFilter(MockCandidateFilter next) {
-        this.next = next;
-    }
-
-    public OngoingInjector filterCandidate(final Collection<Object> mocks,
-                                           final Field candidateFieldToBeInjected,
-                                           final List<Field> allRemainingCandidateFields,
-                                           final Object injectee) {
-        List<Object> mockTypeMatches = new ArrayList<Object>();
-        for (Object mock : mocks) {
-            if (candidateFieldToBeInjected.getType().isAssignableFrom(mock.getClass())) {
-                mockTypeMatches.add(mock);
-            }
-        }
-
-        return next.filterCandidate(mockTypeMatches, candidateFieldToBeInjected, allRemainingCandidateFields, injectee);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
deleted file mode 100644
index e05fc245b7..0000000000
--- a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.mockito.internal.creation.instance.InstantiatorProvider2Adapter;
-import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.InstantiatorProvider;
-import org.mockito.plugins.InstantiatorProvider2;
-import org.mockito.plugins.MockMaker;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.plugins.MockitoPlugins;
-import org.mockito.plugins.PluginSwitch;
-import org.mockito.plugins.StackTraceCleanerProvider;
-
-class DefaultMockitoPlugins implements MockitoPlugins {
-
-    private final static Map<String, String> DEFAULT_PLUGINS = new HashMap<String, String>();
-    static final String INLINE_ALIAS = "mock-maker-inline";
-
-    static {
-        //Keep the mapping: plugin interface name -> plugin implementation class name
-        DEFAULT_PLUGINS.put(PluginSwitch.class.getName(), DefaultPluginSwitch.class.getName());
-        DEFAULT_PLUGINS.put(MockMaker.class.getName(), "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker");
-        DEFAULT_PLUGINS.put(StackTraceCleanerProvider.class.getName(), "org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleanerProvider");
-        DEFAULT_PLUGINS.put(InstantiatorProvider2.class.getName(), "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
-        DEFAULT_PLUGINS.put(AnnotationEngine.class.getName(), "org.mockito.internal.configuration.InjectingAnnotationEngine");
-        DEFAULT_PLUGINS.put(INLINE_ALIAS, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
-        DEFAULT_PLUGINS.put(MockitoLogger.class.getName(), "org.mockito.internal.util.ConsoleMockitoLogger");
-    }
-
-    @Override
-    public <T> T getDefaultPlugin(Class<T> pluginType) {
-        if (pluginType == InstantiatorProvider.class) {
-            //the implementation class is not configured via map so that we can reduce duplication
-            //(ensure that we are adapting the currently configured default implementation for InstantiatorProvider2)
-            String className = DEFAULT_PLUGINS.get(InstantiatorProvider2.class.getName());
-            return pluginType.cast(new InstantiatorProvider2Adapter(create(InstantiatorProvider2.class, className)));
-        } else {
-            String className = DEFAULT_PLUGINS.get(pluginType.getName());
-            return create(pluginType, className);
-        }
-    }
-
-    String getDefaultPluginClass(String classOrAlias) {
-        return DEFAULT_PLUGINS.get(classOrAlias);
-    }
-
-    /**
-     * Creates an instance of given plugin type, using specific implementation class.
-     */
-    private <T> T create(Class<T> pluginType, String className) {
-        if (className == null) {
-            throw new IllegalStateException(
-                "No default implementation for requested Mockito plugin type: " + pluginType.getName() + "\n"
-                    + "Is this a valid Mockito plugin type? If yes, please report this problem to Mockito team.\n"
-                    + "Otherwise, please check if you are passing valid plugin type.\n"
-                    + "Examples of valid plugin types: MockMaker, StackTraceCleanerProvider.");
-        }
-        try {
-            // Default implementation. Use our own ClassLoader instead of the context
-            // ClassLoader, as the default implementation is assumed to be part of
-            // Mockito and may not be available via the context ClassLoader.
-            return pluginType.cast(Class.forName(className).newInstance());
-        } catch (Exception e) {
-            throw new IllegalStateException("Internal problem occurred, please report it. " +
-                "Mockito is unable to load the default implementation of class that is a part of Mockito distribution. " +
-                "Failed to load " + pluginType, e);
-        }
-    }
-
-    @Override
-    public MockMaker getInlineMockMaker() {
-        return create(MockMaker.class, DEFAULT_PLUGINS.get(INLINE_ALIAS));
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
deleted file mode 100644
index 71528c2a08..0000000000
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import java.io.InputStream;
-import java.net.URL;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.io.IOUtil;
-import org.mockito.plugins.PluginSwitch;
-
-class PluginFinder {
-
-    private final PluginSwitch pluginSwitch;
-
-    public PluginFinder(PluginSwitch pluginSwitch) {
-        this.pluginSwitch = pluginSwitch;
-    }
-
-    String findPluginClass(Iterable<URL> resources) {
-        for (URL resource : resources) {
-            InputStream s = null;
-            try {
-                s = resource.openStream();
-                String pluginClassName = new PluginFileReader().readPluginClass(s);
-                if (pluginClassName == null) {
-                    //For backwards compatibility
-                    //If the resource does not have plugin class name we're ignoring it
-                    continue;
-                }
-                if (!pluginSwitch.isEnabled(pluginClassName)) {
-                    continue;
-                }
-                return pluginClassName;
-            } catch(Exception e) {
-                throw new MockitoException("Problems reading plugin implementation from: " + resource, e);
-            } finally {
-                IOUtil.closeQuietly(s);
-            }
-        }
-        return null;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
deleted file mode 100644
index 355ffa8a5b..0000000000
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import java.io.IOException;
-import java.net.URL;
-import java.util.Enumeration;
-
-import org.mockito.internal.util.collections.Iterables;
-import org.mockito.plugins.PluginSwitch;
-
-class PluginInitializer {
-
-    private final PluginSwitch pluginSwitch;
-    private final String alias;
-    private final DefaultMockitoPlugins plugins;
-
-    PluginInitializer(PluginSwitch pluginSwitch, String alias, DefaultMockitoPlugins plugins) {
-        this.pluginSwitch = pluginSwitch;
-        this.alias = alias;
-        this.plugins = plugins;
-    }
-
-    /**
-     * Equivalent to {@link java.util.ServiceLoader#load} but without requiring
-     * Java 6 / Android 2.3 (Gingerbread).
-     */
-    public <T> T loadImpl(Class<T> service) {
-        ClassLoader loader = Thread.currentThread().getContextClassLoader();
-        if (loader == null) {
-            loader = ClassLoader.getSystemClassLoader();
-        }
-        Enumeration<URL> resources;
-        try {
-            resources = loader.getResources("mockito-extensions/" + service.getName());
-        } catch (IOException e) {
-            throw new IllegalStateException("Failed to load " + service, e);
-        }
-
-        try {
-            String classOrAlias = new PluginFinder(pluginSwitch).findPluginClass(Iterables.toIterable(resources));
-            if (classOrAlias != null) {
-                if (classOrAlias.equals(alias)) {
-                    classOrAlias = plugins.getDefaultPluginClass(alias);
-                }
-                Class<?> pluginClass = loader.loadClass(classOrAlias);
-                Object plugin = pluginClass.newInstance();
-                return service.cast(plugin);
-            }
-            return null;
-        } catch (Exception e) {
-            throw new IllegalStateException(
-                "Failed to load " + service + " implementation declared in " + resources, e);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
deleted file mode 100644
index 464c7a6cb0..0000000000
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-
-import org.mockito.plugins.PluginSwitch;
-
-class PluginLoader {
-
-    private final DefaultMockitoPlugins plugins;
-    private final PluginInitializer initializer;
-
-    PluginLoader(DefaultMockitoPlugins plugins, PluginInitializer initializer) {
-        this.plugins = plugins;
-        this.initializer = initializer;
-    }
-
-    PluginLoader(PluginSwitch pluginSwitch) {
-        this(new DefaultMockitoPlugins(), new PluginInitializer(pluginSwitch, null, new DefaultMockitoPlugins()));
-    }
-
-    /**
-     * @deprecated Let's avoid adding more aliases. It complicates the API.
-     * Instead of an alias, we can use fully qualified class name of the alternative implementation.
-     * <p>
-     * Adds an alias for a class name to this plugin loader. Instead of the fully qualified type name,
-     * the alias can be used as a convenience name for a known plugin.
-     */
-    @Deprecated
-    PluginLoader(PluginSwitch pluginSwitch, String alias) {
-        this(new DefaultMockitoPlugins(), new PluginInitializer(pluginSwitch, alias, new DefaultMockitoPlugins()));
-    }
-
-    /**
-     * Scans the classpath for given pluginType. If not found, default class is used.
-     */
-    @SuppressWarnings("unchecked")
-    <T> T loadPlugin(final Class<T> pluginType) {
-        return (T) loadPlugin(pluginType, null);
-    }
-
-    /**
-     * Scans the classpath for given {@code preferredPluginType}. If not found scan for {@code
-     * alternatePluginType}. If neither a preferred or alternate plugin is found, default to default
-     * class of {@code preferredPluginType}.
-     *
-     * @return An object of either {@code preferredPluginType} or {@code alternatePluginType}
-     */
-    @SuppressWarnings("unchecked")
-    <PreferredType, AlternateType> Object loadPlugin(final Class<PreferredType> preferredPluginType, final Class<AlternateType> alternatePluginType) {
-        try {
-            PreferredType preferredPlugin = initializer.loadImpl(preferredPluginType);
-            if (preferredPlugin != null) {
-                return preferredPlugin;
-            } else if (alternatePluginType != null) {
-                AlternateType alternatePlugin = initializer.loadImpl(alternatePluginType);
-                if (alternatePlugin != null) {
-                    return alternatePlugin;
-                }
-            }
-
-            return plugins.getDefaultPlugin(preferredPluginType);
-        } catch (final Throwable t) {
-            return Proxy.newProxyInstance(preferredPluginType.getClassLoader(),
-                new Class<?>[]{preferredPluginType},
-                new InvocationHandler() {
-                    @Override
-                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-                        throw new IllegalStateException("Could not initialize plugin: " + preferredPluginType + " (alternate: " + alternatePluginType + ")", t);
-                    }
-                });
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
deleted file mode 100644
index 2e5f069e62..0000000000
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import org.mockito.internal.creation.instance.InstantiatorProviderAdapter;
-import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.InstantiatorProvider;
-import org.mockito.plugins.InstantiatorProvider2;
-import org.mockito.plugins.MockMaker;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.plugins.PluginSwitch;
-import org.mockito.plugins.StackTraceCleanerProvider;
-
-class PluginRegistry {
-
-    private final PluginSwitch pluginSwitch = new PluginLoader(new DefaultPluginSwitch())
-            .loadPlugin(PluginSwitch.class);
-
-    private final MockMaker mockMaker = new PluginLoader(pluginSwitch, DefaultMockitoPlugins.INLINE_ALIAS)
-            .loadPlugin(MockMaker.class);
-
-    private final StackTraceCleanerProvider stackTraceCleanerProvider = new PluginLoader(pluginSwitch)
-            .loadPlugin(StackTraceCleanerProvider.class);
-
-    private final InstantiatorProvider2 instantiatorProvider;
-
-    private final AnnotationEngine annotationEngine = new PluginLoader(pluginSwitch)
-            .loadPlugin(AnnotationEngine.class);
-
-    private final MockitoLogger mockitoLogger = new PluginLoader(pluginSwitch)
-            .loadPlugin(MockitoLogger.class);
-
-    PluginRegistry() {
-        Object impl = new PluginLoader(pluginSwitch).loadPlugin(InstantiatorProvider2.class, InstantiatorProvider.class);
-        if (impl instanceof InstantiatorProvider) {
-            instantiatorProvider = new InstantiatorProviderAdapter((InstantiatorProvider) impl);
-        } else {
-            instantiatorProvider = (InstantiatorProvider2) impl;
-        }
-    }
-
-    /**
-     * The implementation of the stack trace cleaner
-     */
-    StackTraceCleanerProvider getStackTraceCleanerProvider() {
-        //TODO we should throw some sensible exception if this is null.
-        return stackTraceCleanerProvider;
-    }
-
-    /**
-     * Returns the implementation of the mock maker available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker} if no
-     * {@link org.mockito.plugins.MockMaker} extension exists or is visible in the current classpath.</p>
-     */
-    MockMaker getMockMaker() {
-        return mockMaker;
-    }
-
-    /**
-     * Returns the instantiator provider available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
-     * {@link org.mockito.plugins.InstantiatorProvider2} extension exists or is visible in the
-     * current classpath.</p>
-     */
-    InstantiatorProvider2 getInstantiatorProvider() {
-        return instantiatorProvider;
-    }
-
-    /**
-     * Returns the annotation engine available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.configuration.InjectingAnnotationEngine} if no
-     * {@link org.mockito.plugins.AnnotationEngine} extension exists or is visible in the current classpath.</p>
-     */
-    AnnotationEngine getAnnotationEngine() {
-        return annotationEngine;
-    }
-
-    /**
-     * Returns the logger available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.util.ConsoleMockitoLogger} if no
-     * {@link org.mockito.plugins.MockitoLogger} extension exists or is visible in the current classpath.</p>
-     */
-    MockitoLogger getMockitoLogger() {
-        return mockitoLogger;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
deleted file mode 100644
index 0cdc54f78d..0000000000
--- a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.InstantiatorProvider2;
-import org.mockito.plugins.MockMaker;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.plugins.MockitoPlugins;
-import org.mockito.plugins.StackTraceCleanerProvider;
-
-/**
- * Access to Mockito behavior that can be reconfigured by plugins
- */
-public class Plugins {
-
-    private static final PluginRegistry registry = new PluginRegistry();
-
-    /**
-     * The implementation of the stack trace cleaner
-     */
-    public static StackTraceCleanerProvider getStackTraceCleanerProvider() {
-        return registry.getStackTraceCleanerProvider();
-    }
-
-    /**
-     * Returns the implementation of the mock maker available for the current runtime.
-     *
-     * <p>Returns default mock maker if no
-     * {@link org.mockito.plugins.MockMaker} extension exists or is visible in the current classpath.</p>
-     */
-    public static MockMaker getMockMaker() {
-        return registry.getMockMaker();
-    }
-
-    /**
-     * Returns the instantiator provider available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
-     * {@link org.mockito.plugins.InstantiatorProvider2} extension exists or is visible in the
-     * current classpath.</p>
-     */
-    public static InstantiatorProvider2 getInstantiatorProvider() {
-      return registry.getInstantiatorProvider();
-    }
-
-    /**
-     * Returns the annotation engine available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.configuration.InjectingAnnotationEngine} if no
-     * {@link org.mockito.plugins.AnnotationEngine} extension exists or is visible in the current classpath.</p>
-     */
-    public static AnnotationEngine getAnnotationEngine() {
-        return registry.getAnnotationEngine();
-    }
-
-    /**
-     * Returns the logger available for the current runtime.
-     *
-     * <p>Returns {@link org.mockito.internal.util.ConsoleMockitoLogger} if no
-     * {@link org.mockito.plugins.MockitoLogger} extension exists or is visible in the current classpath.</p>
-     */
-    public static MockitoLogger getMockitoLogger() {
-        return registry.getMockitoLogger();
-    }
-
-    /**
-     * @return instance of mockito plugins type
-     */
-    public static MockitoPlugins getPlugins() {
-        return new DefaultMockitoPlugins();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
deleted file mode 100644
index c73fe794cc..0000000000
--- a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation;
-
-import static java.util.Arrays.asList;
-
-import static org.mockito.internal.exceptions.Reporter.defaultAnswerDoesNotAcceptNullParameter;
-import static org.mockito.internal.exceptions.Reporter.extraInterfacesAcceptsOnlyInterfaces;
-import static org.mockito.internal.exceptions.Reporter.extraInterfacesDoesNotAcceptNullParameters;
-import static org.mockito.internal.exceptions.Reporter.extraInterfacesRequiresAtLeastOneInterface;
-import static org.mockito.internal.exceptions.Reporter.methodDoesNotAcceptParameter;
-import static org.mockito.internal.exceptions.Reporter.requiresAtLeastOneListener;
-import static org.mockito.internal.util.collections.Sets.newSet;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.mockito.MockSettings;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.debugging.VerboseMockInvocationLogger;
-import org.mockito.internal.util.Checks;
-import org.mockito.internal.util.MockCreationValidator;
-import org.mockito.internal.util.MockNameImpl;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.StubbingLookupListener;
-import org.mockito.listeners.VerificationStartedListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.MockName;
-import org.mockito.mock.SerializableMode;
-import org.mockito.stubbing.Answer;
-
-@SuppressWarnings("unchecked")
-public class MockSettingsImpl<T> extends CreationSettings<T> implements MockSettings, MockCreationSettings<T> {
-
-    private static final long serialVersionUID = 4475297236197939569L;
-    private boolean useConstructor;
-    private Object outerClassInstance;
-    private Object[] constructorArgs;
-
-    @Override
-    public MockSettings serializable() {
-        return serializable(SerializableMode.BASIC);
-    }
-
-    @Override
-    public MockSettings serializable(SerializableMode mode) {
-        this.serializableMode = mode;
-        return this;
-    }
-
-    @Override
-    public MockSettings extraInterfaces(Class<?>... extraInterfaces) {
-        if (extraInterfaces == null || extraInterfaces.length == 0) {
-            throw extraInterfacesRequiresAtLeastOneInterface();
-        }
-
-        for (Class<?> i : extraInterfaces) {
-            if (i == null) {
-                throw extraInterfacesDoesNotAcceptNullParameters();
-            } else if (!i.isInterface()) {
-                throw extraInterfacesAcceptsOnlyInterfaces(i);
-            }
-        }
-        this.extraInterfaces = newSet(extraInterfaces);
-        return this;
-    }
-
-    @Override
-    public MockName getMockName() {
-        return mockName;
-    }
-
-    @Override
-    public Set<Class<?>> getExtraInterfaces() {
-        return extraInterfaces;
-    }
-
-    @Override
-    public Object getSpiedInstance() {
-        return spiedInstance;
-    }
-
-    @Override
-    public MockSettings name(String name) {
-        this.name = name;
-        return this;
-    }
-
-    @Override
-    public MockSettings spiedInstance(Object spiedInstance) {
-        this.spiedInstance = spiedInstance;
-        return this;
-    }
-
-    @Override
-    public MockSettings defaultAnswer(Answer defaultAnswer) {
-        this.defaultAnswer = defaultAnswer;
-        if (defaultAnswer == null) {
-            throw defaultAnswerDoesNotAcceptNullParameter();
-        }
-        return this;
-    }
-
-    @Override
-    public Answer<Object> getDefaultAnswer() {
-        return defaultAnswer;
-    }
-
-    @Override
-    public MockSettingsImpl<T> stubOnly() {
-        this.stubOnly = true;
-        return this;
-    }
-
-    @Override
-    public MockSettings useConstructor(Object... constructorArgs) {
-        Checks.checkNotNull(constructorArgs,
-            "constructorArgs",
-            "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
-        this.useConstructor = true;
-        this.constructorArgs = constructorArgs;
-        return this;
-    }
-
-    @Override
-    public MockSettings outerInstance(Object outerClassInstance) {
-        this.outerClassInstance = outerClassInstance;
-        return this;
-    }
-
-    @Override
-    public MockSettings withoutAnnotations() {
-        stripAnnotations = true;
-        return this;
-    }
-
-    @Override
-    public boolean isUsingConstructor() {
-        return useConstructor;
-    }
-
-    @Override
-    public Object getOuterClassInstance() {
-        return outerClassInstance;
-    }
-
-    @Override
-    public Object[] getConstructorArgs() {
-        if (outerClassInstance == null) {
-            return constructorArgs;
-        }
-        List<Object> resultArgs = new ArrayList<Object>(constructorArgs.length + 1);
-        resultArgs.add(outerClassInstance);
-        resultArgs.addAll(asList(constructorArgs));
-        return resultArgs.toArray(new Object[constructorArgs.length + 1]);
-    }
-
-    @Override
-    public boolean isStubOnly() {
-        return this.stubOnly;
-    }
-
-    @Override
-    public MockSettings verboseLogging() {
-        if (!invocationListenersContainsType(VerboseMockInvocationLogger.class)) {
-            invocationListeners(new VerboseMockInvocationLogger());
-        }
-        return this;
-    }
-
-    @Override
-    public MockSettings invocationListeners(InvocationListener... listeners) {
-        addListeners(listeners, invocationListeners, "invocationListeners");
-        return this;
-    }
-
-    @Override
-    public MockSettings stubbingLookupListeners(StubbingLookupListener... listeners) {
-        addListeners(listeners, stubbingLookupListeners, "stubbingLookupListeners");
-        return this;
-    }
-
-    static <T> void addListeners(T[] listeners, List<T> container, String method) {
-        if (listeners == null) {
-            throw methodDoesNotAcceptParameter(method, "null vararg array.");
-        }
-        if (listeners.length == 0) {
-            throw requiresAtLeastOneListener(method);
-        }
-        for (T listener : listeners) {
-            if (listener == null) {
-                throw methodDoesNotAcceptParameter(method, "null listeners.");
-            }
-            container.add(listener);
-        }
-    }
-
-    @Override
-    public MockSettings verificationStartedListeners(VerificationStartedListener... listeners) {
-        addListeners(listeners, this.verificationStartedListeners, "verificationStartedListeners");
-        return this;
-    }
-
-    private boolean invocationListenersContainsType(Class<?> clazz) {
-        for (InvocationListener listener : invocationListeners) {
-            if (listener.getClass().equals(clazz)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public boolean hasInvocationListeners() {
-        return !getInvocationListeners().isEmpty();
-    }
-
-    @Override
-    public Class<T> getTypeToMock() {
-        return typeToMock;
-    }
-
-    @Override
-    public <T> MockCreationSettings<T> build(Class<T> typeToMock) {
-        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();
-
-        validator.validateType(typeToMock);
-        validator.validateExtraInterfaces(typeToMock, source.getExtraInterfaces());
-        validator.validateMockedType(typeToMock, source.getSpiedInstance());
-
-        //TODO SF - add this validation and also add missing coverage
-//        validator.validateDelegatedInstance(classToMock, settings.getDelegatedInstance());
-
-        validator.validateConstructorUse(source.isUsingConstructor(), source.getSerializableMode());
-
-        //TODO SF - I don't think we really need CreationSettings type
-        //TODO do we really need to copy the entire settings every time we create mock object? it does not seem necessary.
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), typeToMock));
-        settings.setTypeToMock(typeToMock);
-        settings.setExtraInterfaces(prepareExtraInterfaces(source));
-        return settings;
-    }
-
-    private static Set<Class<?>> prepareExtraInterfaces(CreationSettings settings) {
-        Set<Class<?>> interfaces = new HashSet<Class<?>>(settings.getExtraInterfaces());
-        if(settings.isSerializable()) {
-            interfaces.add(Serializable.class);
-        }
-        return interfaces;
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
deleted file mode 100644
index 3b124dcaab..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import org.mockito.Incubating;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * ByteBuddy MockMaker.
- *
- * This class will serve as the programmatic entry point to all mockito internal MockMakers.
- * Currently the default and only mock maker is the subclassing engine, but with enough feedback we can later
- * promote the inlining engine for features like final class/methods mocks.
- *
- * The programmatic API could look like {@code mock(Final.class, withSettings().finalClasses())}.
- */
-public class ByteBuddyMockMaker implements ClassCreatingMockMaker {
-    private ClassCreatingMockMaker defaultByteBuddyMockMaker = new SubclassByteBuddyMockMaker();
-
-    @Override
-    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
-        return defaultByteBuddyMockMaker.createMock(settings, handler);
-    }
-
-    @Override
-    public <T> Class<? extends T> createMockType(MockCreationSettings<T> creationSettings) {
-        return defaultByteBuddyMockMaker.createMockType(creationSettings);
-    }
-
-    @Override
-    public MockHandler getHandler(Object mock) {
-        return defaultByteBuddyMockMaker.getHandler(mock);
-    }
-
-    @Override
-    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
-        defaultByteBuddyMockMaker.resetMock(mock, newHandler, settings);
-    }
-
-    @Override
-    @Incubating
-    public TypeMockability isTypeMockable(Class<?> type) {
-        return defaultByteBuddyMockMaker.isTypeMockable(type);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
deleted file mode 100644
index a131c04bc7..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-public interface BytecodeGenerator {
-
-    <T> Class<? extends T> mockClass(MockFeatures<T> features);
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
deleted file mode 100644
index cd46ac0ae6..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.EXCLUDES;
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.instrument.Instrumentation;
-import java.lang.reflect.Modifier;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.jar.JarOutputStream;
-
-import javax.tools.ToolProvider;
-
-import net.bytebuddy.agent.ByteBuddyAgent;
-import org.mockito.Incubating;
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.base.MockitoInitializationException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.util.Platform;
-import org.mockito.internal.util.concurrent.WeakConcurrentMap;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InlineMockMaker;
-
-/**
- * Agent and subclass based mock maker.
- * <p>
- * This mock maker which uses a combination of the Java instrumentation API and sub-classing rather than creating
- * a new sub-class to create a mock. This way, it becomes possible to mock final types and methods. This mock
- * maker <strong>must to be activated explicitly</strong> for supporting mocking final types and methods:
- * <p>
- * <p>
- * This mock maker can be activated by creating the file <code>/mockito-extensions/org.mockito.plugins.MockMaker</code>
- * containing the text <code>mock-maker-inline</code> or <code>org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker</code>.
- * <p>
- * <p>
- * This mock maker will make a best effort to avoid subclass creation when creating a mock. Otherwise it will use the
- * <code>org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker</code> to create the mock class. That means
- * that the following condition is true
- * <p>
- * <pre class="code"><code class="java">
- * class Foo { }
- * assert mock(Foo.class).getClass() == Foo.class;
- * </pre></code>
- * <p>
- * unless any of the following conditions is met, in such case the mock maker <em>fall backs</em> to the
- * the creation of a subclass.
- * <p>
- * <ul>
- * <li>the type to mock is an abstract class.</li>
- * <li>the mock is set to require additional interfaces.</li>
- * <li>the mock is <a href="#20">explicitly set to support serialization</a>.</li>
- * </ul>
- * <p>
- * <p>
- * Some type of the JDK cannot be mocked, this includes <code>Class</code>, <code>String</code>, and wrapper types.
- * <p>
- * <p>
- * Nevertheless, final methods of such types are mocked when using the inlining mock maker. Mocking final types and enums
- * does however remain impossible when explicitly requiring serialization support or when adding ancillary interfaces.
- * <p>
- * <p>
- * Important behavioral changes when using inline-mocks:
- * <ul>
- * <li>Mockito is capable of mocking package-private methods even if they are defined in different packages than
- * the mocked type. Mockito voluntarily never mocks package-visible methods within <code>java.*</code> packages.</li>
- * <li>Additionally to final types, Mockito can now mock types that are not visible for extension; such types
- * include private types in a protected package.</li>
- * <li>Mockito can no longer mock <code>native</code> methods. Inline mocks require byte code manipulation of a
- * method where native methods do not offer any byte code to manipulate.</li>
- * <li>Mockito cannot longer strip <code>synchronized</code> modifiers from mocked instances.</li>
- * </ul>
- * <p>
- * <p>
- * Note that inline mocks require a Java agent to be attached. Mockito will attempt an attachment of a Java agent upon
- * loading the mock maker for creating inline mocks. Such runtime attachment is only possible when using a JVM that
- * is part of a JDK or when using a Java 9 VM. When running on a non-JDK VM prior to Java 9, it is however possible to
- * manually add the <a href="http://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
- * parameter upon starting the JVM. Furthermore, the inlining mock maker requires the VM to support class retransformation
- * (also known as HotSwap). All major VM distributions such as HotSpot (OpenJDK), J9 (IBM/Websphere) or Zing (Azul)
- * support this feature.
- */
-@Incubating
-public class InlineByteBuddyMockMaker implements ClassCreatingMockMaker, InlineMockMaker {
-
-    private static final Instrumentation INSTRUMENTATION;
-
-    private static final Throwable INITIALIZATION_ERROR;
-
-    static {
-        Instrumentation instrumentation;
-        Throwable initializationError = null;
-        try {
-            try {
-                instrumentation = ByteBuddyAgent.install();
-                if (!instrumentation.isRetransformClassesSupported()) {
-                    throw new IllegalStateException(join(
-                            "Byte Buddy requires retransformation for creating inline mocks. This feature is unavailable on the current VM.",
-                            "",
-                            "You cannot use this mock maker on this VM"));
-                }
-                File boot = File.createTempFile("mockitoboot", ".jar");
-                boot.deleteOnExit();
-                JarOutputStream outputStream = new JarOutputStream(new FileOutputStream(boot));
-                try {
-                    String source = "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher";
-                    InputStream inputStream = InlineByteBuddyMockMaker.class.getClassLoader().getResourceAsStream(source + ".raw");
-                    if (inputStream == null) {
-                        throw new IllegalStateException(join(
-                                "The MockMethodDispatcher class file is not locatable: " + source + ".raw",
-                                "",
-                                "The class loader responsible for looking up the resource: " + InlineByteBuddyMockMaker.class.getClassLoader()
-                        ));
-                    }
-                    outputStream.putNextEntry(new JarEntry(source + ".class"));
-                    try {
-                        int length;
-                        byte[] buffer = new byte[1024];
-                        while ((length = inputStream.read(buffer)) != -1) {
-                            outputStream.write(buffer, 0, length);
-                        }
-                    } finally {
-                        inputStream.close();
-                    }
-                    outputStream.closeEntry();
-                } finally {
-                    outputStream.close();
-                }
-                try (JarFile jarfile = new JarFile(boot)) {
-                    instrumentation.appendToBootstrapClassLoaderSearch(jarfile);
-                }
-                try {
-                    Class.forName("org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher", false, null);
-                } catch (ClassNotFoundException cnfe) {
-                    throw new IllegalStateException(join(
-                            "Mockito failed to inject the MockMethodDispatcher class into the bootstrap class loader",
-                            "",
-                            "It seems like your current VM does not support the instrumentation API correctly."), cnfe);
-                }
-            } catch (IOException ioe) {
-                throw new IllegalStateException(join(
-                        "Mockito could not self-attach a Java agent to the current VM. This feature is required for inline mocking.",
-                        "This error occured due to an I/O error during the creation of this agent: " + ioe,
-                        "",
-                        "Potentially, the current VM does not support the instrumentation API correctly"), ioe);
-            }
-        } catch (Throwable throwable) {
-            instrumentation = null;
-            initializationError = throwable;
-        }
-        INSTRUMENTATION = instrumentation;
-        INITIALIZATION_ERROR = initializationError;
-    }
-
-    private final BytecodeGenerator bytecodeGenerator;
-
-    private final WeakConcurrentMap<Object, MockMethodInterceptor> mocks = new WeakConcurrentMap.WithInlinedExpunction<Object, MockMethodInterceptor>();
-
-    public InlineByteBuddyMockMaker() {
-        if (INITIALIZATION_ERROR != null) {
-            throw new MockitoInitializationException(join(
-                    "Could not initialize inline Byte Buddy mock maker. (This mock maker is not supported on Android.)",
-                    ToolProvider.getSystemJavaCompiler() == null ? "Are you running a JRE instead of a JDK? The inline mock maker needs to be run on a JDK.\n" : "",
-                    Platform.describe()), INITIALIZATION_ERROR);
-        }
-        bytecodeGenerator = new TypeCachingBytecodeGenerator(new InlineBytecodeGenerator(INSTRUMENTATION, mocks), true);
-    }
-
-    @Override
-    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
-        Class<? extends T> type = createMockType(settings);
-
-        Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(settings);
-        try {
-            T instance = instantiator.newInstance(type);
-            MockMethodInterceptor mockMethodInterceptor = new MockMethodInterceptor(handler, settings);
-            mocks.put(instance, mockMethodInterceptor);
-            if (instance instanceof MockAccess) {
-                ((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);
-            }
-            return instance;
-        } catch (org.mockito.creation.instance.InstantiationException e) {
-            throw new MockitoException("Unable to create mock instance of type '" + type.getSimpleName() + "'", e);
-        }
-    }
-
-    @Override
-    public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
-        try {
-            return bytecodeGenerator.mockClass(MockFeatures.withMockFeatures(
-                    settings.getTypeToMock(),
-                    settings.getExtraInterfaces(),
-                    settings.getSerializableMode(),
-                    settings.isStripAnnotations()
-            ));
-        } catch (Exception bytecodeGenerationFailed) {
-            throw prettifyFailure(settings, bytecodeGenerationFailed);
-        }
-    }
-
-    private <T> RuntimeException prettifyFailure(MockCreationSettings<T> mockFeatures, Exception generationFailed) {
-        if (mockFeatures.getTypeToMock().isArray()) {
-            throw new MockitoException(join(
-                    "Arrays cannot be mocked: " + mockFeatures.getTypeToMock() + ".",
-                    ""
-            ), generationFailed);
-        }
-        if (Modifier.isFinal(mockFeatures.getTypeToMock().getModifiers())) {
-            throw new MockitoException(join(
-                    "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
-                    "Can not mock final classes with the following settings :",
-                    " - explicit serialization (e.g. withSettings().serializable())",
-                    " - extra interfaces (e.g. withSettings().extraInterfaces(...))",
-                    "",
-                    "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
-                    "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
-                    "",
-                    "Underlying exception : " + generationFailed
-            ), generationFailed);
-        }
-        if (Modifier.isPrivate(mockFeatures.getTypeToMock().getModifiers())) {
-            throw new MockitoException(join(
-                    "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
-                    "Most likely it is a private class that is not visible by Mockito",
-                    "",
-                    "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
-                    "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
-                    ""
-            ), generationFailed);
-        }
-        throw new MockitoException(join(
-                "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
-                "",
-                "If you're not sure why you're getting this error, please report to the mailing list.",
-                "",
-                Platform.warnForVM(
-                        "IBM J9 VM", "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
-                        "Hotspot", Platform.isJava8BelowUpdate45() ? "Java 8 early builds have bugs that were addressed in Java 1.8.0_45, please update your JDK!\n" : ""
-                ),
-                Platform.describe(),
-                "",
-                "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
-                "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
-                "",
-                "Underlying exception : " + generationFailed
-        ), generationFailed);
-    }
-
-    @Override
-    public MockHandler getHandler(Object mock) {
-        MockMethodInterceptor interceptor = mocks.get(mock);
-        if (interceptor == null) {
-            return null;
-        } else {
-            return interceptor.handler;
-        }
-    }
-
-    @Override
-    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
-        MockMethodInterceptor mockMethodInterceptor = new MockMethodInterceptor(newHandler, settings);
-        mocks.put(mock, mockMethodInterceptor);
-        if (mock instanceof MockAccess) {
-            ((MockAccess) mock).setMockitoInterceptor(mockMethodInterceptor);
-        }
-    }
-
-    @Override
-    public void clearMock(Object mock) {
-        mocks.remove(mock);
-    }
-
-    @Override
-    public void clearAllMocks() {
-        mocks.clear();
-    }
-
-    @Override
-    public TypeMockability isTypeMockable(final Class<?> type) {
-        return new TypeMockability() {
-            @Override
-            public boolean mockable() {
-                return INSTRUMENTATION.isModifiableClass(type) && !EXCLUDES.contains(type);
-            }
-
-            @Override
-            public String nonMockableReason() {
-                if (mockable()) {
-                    return "";
-                }
-                if (type.isPrimitive()) {
-                    return "primitive type";
-                }
-                if (EXCLUDES.contains(type)) {
-                    return "Cannot mock wrapper types, String.class or Class.class";
-                }
-                return "VM does not support modification of given type";
-            }
-        };
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
deleted file mode 100644
index eaa61a3d71..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
+++ /dev/null
@@ -1,322 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static net.bytebuddy.implementation.MethodDelegation.withDefaultConfiguration;
-import static net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant.of;
-import static net.bytebuddy.matcher.ElementMatchers.*;
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.instrument.ClassFileTransformer;
-import java.lang.instrument.Instrumentation;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.security.ProtectionDomain;
-import java.util.*;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.ClassFileVersion;
-import net.bytebuddy.asm.Advice;
-import net.bytebuddy.asm.AsmVisitorWrapper;
-import net.bytebuddy.description.field.FieldDescription;
-import net.bytebuddy.description.field.FieldList;
-import net.bytebuddy.description.method.MethodDescription;
-import net.bytebuddy.description.method.MethodList;
-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;
-import net.bytebuddy.jar.asm.MethodVisitor;
-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.creation.bytebuddy.inject.MockMethodDispatcher;
-import org.mockito.internal.util.concurrent.WeakConcurrentMap;
-import org.mockito.internal.util.concurrent.WeakConcurrentSet;
-import org.mockito.mock.SerializableMode;
-
-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,
-            Byte.class,
-            Short.class,
-            Character.class,
-            Integer.class,
-            Long.class,
-            Float.class,
-            Double.class,
-            String.class));
-
-    private final Instrumentation instrumentation;
-    private final ByteBuddy byteBuddy;
-    private final WeakConcurrentSet<Class<?>> mocked;
-    private final BytecodeGenerator subclassEngine;
-    private final AsmVisitorWrapper mockTransformer;
-
-    private final Method getModule, canRead, redefineModule;
-
-    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(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE);
-        mocked = new WeakConcurrentSet<Class<?>>(WeakConcurrentSet.Cleaner.INLINE);
-        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);
-        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));
-        Method getModule, canRead, redefineModule;
-        try {
-            getModule = Class.class.getMethod("getModule");
-            canRead = getModule.getReturnType().getMethod("canRead", getModule.getReturnType());
-            redefineModule = Instrumentation.class.getMethod("redefineModule",
-                getModule.getReturnType(), Set.class, Map.class, Map.class, Set.class, Map.class);
-        } catch (Exception ignored) {
-            getModule = null;
-            canRead = null;
-            redefineModule = null;
-        }
-        this.getModule = getModule;
-        this.canRead = canRead;
-        this.redefineModule = redefineModule;
-        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());
-
-        checkSupportedCombination(subclassingRequired, features);
-
-        synchronized (this) {
-            triggerRetransformation(features);
-        }
-
-        return subclassingRequired ?
-                subclassEngine.mockClass(features) :
-                features.mockedType;
-    }
-
-    private <T> void triggerRetransformation(MockFeatures<T> features) {
-        Set<Class<?>> types = new HashSet<Class<?>>();
-        Class<?> type = features.mockedType;
-        do {
-            if (mocked.add(type)) {
-                types.add(type);
-                addInterfaces(types, type.getInterfaces());
-            }
-            type = type.getSuperclass();
-        } while (type != null);
-        if (!types.isEmpty()) {
-            try {
-                assureCanReadMockito(types);
-                instrumentation.retransformClasses(types.toArray(new Class<?>[types.size()]));
-                Throwable throwable = lastException;
-                if (throwable != null) {
-                    throw new IllegalStateException(join("Byte Buddy could not instrument all classes within the mock's type hierarchy",
-                        "",
-                        "This problem should never occur for javac-compiled classes. This problem has been observed for classes that are:",
-                        " - Compiled by older versions of scalac",
-                        " - Classes that are part of the Android distribution"), throwable);
-                }
-            } catch (Exception exception) {
-                for (Class<?> failed : types) {
-                    mocked.remove(failed);
-                }
-                throw new MockitoException("Could not modify all classes " + types, exception);
-            } finally {
-                lastException = null;
-            }
-        }
-    }
-
-    private void assureCanReadMockito(Set<Class<?>> types) {
-        if (redefineModule == null) {
-            return;
-        }
-        Set<Object> modules = new HashSet<Object>();
-        try {
-            Object target = getModule.invoke(Class.forName("org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher", false, null));
-            for (Class<?> type : types) {
-                Object module = getModule.invoke(type);
-                if (!modules.contains(module) && !(Boolean) canRead.invoke(module, target)) {
-                    modules.add(module);
-                }
-            }
-            for (Object module : modules) {
-                redefineModule.invoke(instrumentation, module, Collections.singleton(target),
-                    Collections.emptyMap(), Collections.emptyMap(), Collections.emptySet(), Collections.emptyMap());
-            }
-        } catch (Exception e) {
-            throw new IllegalStateException(join("Could not adjust module graph to make the mock instance dispatcher visible to some classes",
-                "",
-                "At least one of those modules: " + modules + " is not reading the unnamed module of the bootstrap loader",
-                "Without such a read edge, the classes that are redefined to become mocks cannot access the mock dispatcher.",
-                "To circumvent this, Mockito attempted to add a read edge to this module what failed for an unexpected reason"), e);
-        }
-    }
-
-    private <T> void checkSupportedCombination(boolean subclassingRequired, MockFeatures<T> features) {
-        if (subclassingRequired
-                && !features.mockedType.isArray()
-                && !features.mockedType.isPrimitive()
-                && Modifier.isFinal(features.mockedType.getModifiers())) {
-            throw new MockitoException("Unsupported settings with this type '" + features.mockedType.getName() + "'");
-        }
-    }
-
-    private void addInterfaces(Set<Class<?>> types, Class<?>[] interfaces) {
-        for (Class<?> type : interfaces) {
-            if (mocked.add(type)) {
-                types.add(type);
-                addInterfaces(types, type.getInterfaces());
-            }
-        }
-    }
-
-    @Override
-    public byte[] transform(ClassLoader loader,
-                            String className,
-                            Class<?> classBeingRedefined,
-                            ProtectionDomain protectionDomain,
-                            byte[] classfileBuffer) {
-        if (classBeingRedefined == null
-            || !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(mockTransformer)
-                    .make()
-                    .getBytes();
-            } catch (Throwable throwable) {
-                lastException = throwable;
-                return null;
-            }
-        }
-    }
-
-    private static class ParameterWritingVisitorWrapper extends AsmVisitorWrapper.AbstractBase {
-
-        private final Class<?> type;
-
-        private ParameterWritingVisitorWrapper(Class<?> type) {
-            this.type = type;
-        }
-
-        @Override
-        public ClassVisitor wrap(TypeDescription instrumentedType,
-                                 ClassVisitor classVisitor,
-                                 Implementation.Context implementationContext,
-                                 TypePool typePool,
-                                 FieldList<FieldDescription.InDefinedShape> fields,
-                                 MethodList<?> methods,
-                                 int writerFlags,
-                                 int readerFlags) {
-            return implementationContext.getClassFileVersion().isAtLeast(ClassFileVersion.JAVA_V8)
-                    ? new ParameterAddingClassVisitor(classVisitor, new TypeDescription.ForLoadedType(type))
-                    : classVisitor;
-        }
-
-        private static class ParameterAddingClassVisitor extends ClassVisitor {
-
-            private final TypeDescription typeDescription;
-
-            private ParameterAddingClassVisitor(ClassVisitor cv, TypeDescription typeDescription) {
-                super(OpenedClassReader.ASM_API, cv);
-                this.typeDescription = typeDescription;
-            }
-
-            @Override
-            public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
-                MethodVisitor methodVisitor = super.visitMethod(access, name, desc, signature, exceptions);
-                MethodList<?> methodList = typeDescription.getDeclaredMethods().filter((name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME)
-                        ? isConstructor()
-                        : ElementMatchers.<MethodDescription>named(name)).and(hasDescriptor(desc)));
-                if (methodList.size() == 1 && methodList.getOnly().getParameters().hasExplicitMetaData()) {
-                    for (ParameterDescription parameterDescription : methodList.getOnly().getParameters()) {
-                        methodVisitor.visitParameter(parameterDescription.getName(), parameterDescription.getModifiers());
-                    }
-                    return new MethodParameterStrippingMethodVisitor(methodVisitor);
-                } else {
-                    return methodVisitor;
-                }
-            }
-        }
-
-        private static class MethodParameterStrippingMethodVisitor extends MethodVisitor {
-
-            public MethodParameterStrippingMethodVisitor(MethodVisitor mv) {
-                super(OpenedClassReader.ASM_API, mv);
-            }
-
-            @Override
-            public void visitParameter(String name, int access) {
-                // suppress to avoid additional writing of the parameter if retained.
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
deleted file mode 100644
index 2f0ee4dc4f..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import java.util.Collections;
-import java.util.Set;
-
-import org.mockito.mock.SerializableMode;
-
-class MockFeatures<T> {
-
-    final Class<T> mockedType;
-    final Set<Class<?>> interfaces;
-    final SerializableMode serializableMode;
-    final boolean stripAnnotations;
-
-    private MockFeatures(Class<T> mockedType, Set<Class<?>> interfaces, SerializableMode serializableMode, boolean stripAnnotations) {
-        this.mockedType = mockedType;
-        this.interfaces = Collections.unmodifiableSet(interfaces);
-        this.serializableMode = serializableMode;
-        this.stripAnnotations = stripAnnotations;
-    }
-
-    public static <T> MockFeatures<T> withMockFeatures(Class<T> mockedType,
-                                                       Set<Class<?>> interfaces,
-                                                       SerializableMode serializableMode,
-                                                       boolean stripAnnotations) {
-        return new MockFeatures<T>(mockedType, interfaces, serializableMode, stripAnnotations);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
deleted file mode 100644
index 4887ee1f10..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.ref.SoftReference;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.concurrent.Callable;
-
-import net.bytebuddy.asm.Advice;
-import net.bytebuddy.description.method.MethodDescription;
-import net.bytebuddy.description.type.TypeDescription;
-import net.bytebuddy.dynamic.scaffold.MethodGraph;
-import net.bytebuddy.implementation.bind.annotation.Argument;
-import net.bytebuddy.implementation.bind.annotation.This;
-import net.bytebuddy.implementation.bytecode.assign.Assigner;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-import org.mockito.internal.invocation.RealMethod;
-import org.mockito.internal.invocation.SerializableMethod;
-import org.mockito.internal.invocation.mockref.MockReference;
-import org.mockito.internal.invocation.mockref.MockWeakReference;
-import org.mockito.internal.util.concurrent.WeakConcurrentMap;
-
-public class MockMethodAdvice extends MockMethodDispatcher {
-
-    private final WeakConcurrentMap<Object, MockMethodInterceptor> interceptors;
-
-    private final String identifier;
-
-    private final SelfCallInfo selfCallInfo = new SelfCallInfo();
-    private final MethodGraph.Compiler compiler = MethodGraph.Compiler.Default.forJavaHierarchy();
-    private final WeakConcurrentMap<Class<?>, SoftReference<MethodGraph>> graphs
-        = new WeakConcurrentMap.WithInlinedExpunction<Class<?>, SoftReference<MethodGraph>>();
-
-    public MockMethodAdvice(WeakConcurrentMap<Object, MockMethodInterceptor> interceptors, String identifier) {
-        this.interceptors = interceptors;
-        this.identifier = identifier;
-    }
-
-    @SuppressWarnings("unused")
-    @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
-    private static Callable<?> enter(@Identifier String identifier,
-                                     @Advice.This Object mock,
-                                     @Advice.Origin Method origin,
-                                     @Advice.AllArguments Object[] arguments) throws Throwable {
-        MockMethodDispatcher dispatcher = MockMethodDispatcher.get(identifier, mock);
-        if (dispatcher == null || !dispatcher.isMocked(mock) || dispatcher.isOverridden(mock, origin)) {
-            return null;
-        } else {
-            return dispatcher.handle(mock, origin, arguments);
-        }
-    }
-
-    @SuppressWarnings({"unused", "UnusedAssignment"})
-    @Advice.OnMethodExit
-    private static void exit(@Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object returned,
-                             @Advice.Enter Callable<?> mocked) throws Throwable {
-        if (mocked != null) {
-            returned = mocked.call();
-        }
-    }
-
-    static Throwable hideRecursiveCall(Throwable throwable, int current, Class<?> targetType) {
-        try {
-            StackTraceElement[] stack = throwable.getStackTrace();
-            int skip = 0;
-            StackTraceElement next;
-            do {
-                next = stack[stack.length - current - ++skip];
-            } while (!next.getClassName().equals(targetType.getName()));
-            int top = stack.length - current - skip;
-            StackTraceElement[] cleared = new StackTraceElement[stack.length - skip];
-            System.arraycopy(stack, 0, cleared, 0, top);
-            System.arraycopy(stack, top + skip, cleared, top, current);
-            throwable.setStackTrace(cleared);
-            return throwable;
-        } catch (RuntimeException ignored) {
-            // This should not happen unless someone instrumented or manipulated exception stack traces.
-            return throwable;
-        }
-    }
-
-    @Override
-    public Callable<?> handle(Object instance, Method origin, Object[] arguments) throws Throwable {
-        MockMethodInterceptor interceptor = interceptors.get(instance);
-        if (interceptor == null) {
-            return null;
-        }
-        RealMethod realMethod;
-        if (instance instanceof Serializable) {
-            realMethod = new SerializableRealMethodCall(identifier, origin, instance, arguments);
-        } else {
-            realMethod = new RealMethodCall(selfCallInfo, origin, instance, arguments);
-        }
-        return new ReturnValueWrapper(interceptor.doIntercept(instance,
-                origin,
-                arguments,
-                realMethod,
-                new LocationImpl(new Throwable(), true)));
-    }
-
-    @Override
-    public boolean isMock(Object instance) {
-        // We need to exclude 'interceptors.target' explicitly to avoid a recursive check on whether
-        // the map is a mock object what requires reading from the map.
-        return instance != interceptors.target && interceptors.containsKey(instance);
-    }
-
-    @Override
-    public boolean isMocked(Object instance) {
-        return selfCallInfo.checkSuperCall(instance) && isMock(instance);
-    }
-
-    @Override
-    public boolean isOverridden(Object instance, Method origin) {
-        SoftReference<MethodGraph> reference = graphs.get(instance.getClass());
-        MethodGraph methodGraph = reference == null ? null : reference.get();
-        if (methodGraph == null) {
-            methodGraph = compiler.compile(new TypeDescription.ForLoadedType(instance.getClass()));
-            graphs.put(instance.getClass(), new SoftReference<MethodGraph>(methodGraph));
-        }
-        MethodGraph.Node node = methodGraph.locate(new MethodDescription.ForLoadedMethod(origin).asSignatureToken());
-        return !node.getSort().isResolved() || !node.getRepresentative().asDefined().getDeclaringType().represents(origin.getDeclaringClass());
-    }
-
-    private static class RealMethodCall implements RealMethod {
-
-        private final SelfCallInfo selfCallInfo;
-
-        private final Method origin;
-
-        private final MockWeakReference<Object> instanceRef;
-
-        private final Object[] arguments;
-
-        private RealMethodCall(SelfCallInfo selfCallInfo, Method origin, Object instance, Object[] arguments) {
-            this.selfCallInfo = selfCallInfo;
-            this.origin = origin;
-            this.instanceRef = new MockWeakReference<Object>(instance);
-            this.arguments = arguments;
-        }
-
-        @Override
-        public boolean isInvokable() {
-            return true;
-        }
-
-        @Override
-        public Object invoke() throws Throwable {
-            if (!Modifier.isPublic(origin.getDeclaringClass().getModifiers() & origin.getModifiers())) {
-                origin.setAccessible(true);
-            }
-            selfCallInfo.set(instanceRef.get());
-            return tryInvoke(origin, instanceRef.get(), arguments);
-        }
-
-    }
-
-    private static class SerializableRealMethodCall implements RealMethod {
-
-        private final String identifier;
-
-        private final SerializableMethod origin;
-
-        private final MockReference<Object> instanceRef;
-
-        private final Object[] arguments;
-
-        private SerializableRealMethodCall(String identifier, Method origin, Object instance, Object[] arguments) {
-            this.origin = new SerializableMethod(origin);
-            this.identifier = identifier;
-            this.instanceRef = new MockWeakReference<Object>(instance);
-            this.arguments = arguments;
-        }
-
-        @Override
-        public boolean isInvokable() {
-            return true;
-        }
-
-        @Override
-        public Object invoke() throws Throwable {
-            Method method = origin.getJavaMethod();
-            if (!Modifier.isPublic(method.getDeclaringClass().getModifiers() & method.getModifiers())) {
-                method.setAccessible(true);
-            }
-            MockMethodDispatcher mockMethodDispatcher = MockMethodDispatcher.get(identifier, instanceRef.get());
-            if (!(mockMethodDispatcher instanceof MockMethodAdvice)) {
-                throw new MockitoException("Unexpected dispatcher for advice-based super call");
-            }
-            Object previous = ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.replace(instanceRef.get());
-            try {
-                return tryInvoke(method, instanceRef.get(), arguments);
-            } finally {
-                ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.set(previous);
-            }
-        }
-    }
-
-    private static Object tryInvoke(Method origin, Object instance, Object[] arguments) throws Throwable {
-        try {
-            return origin.invoke(instance, arguments);
-        } catch (InvocationTargetException exception) {
-            Throwable cause = exception.getCause();
-            new ConditionalStackTraceFilter().filter(hideRecursiveCall(cause, new Throwable().getStackTrace().length, origin.getDeclaringClass()));
-            throw cause;
-        }
-    }
-
-    private static class ReturnValueWrapper implements Callable<Object> {
-
-        private final Object returned;
-
-        private ReturnValueWrapper(Object returned) {
-            this.returned = returned;
-        }
-
-        @Override
-        public Object call() {
-            return returned;
-        }
-    }
-
-    private static class SelfCallInfo extends ThreadLocal<Object> {
-
-        Object replace(Object value) {
-            Object current = get();
-            set(value);
-            return current;
-        }
-
-        boolean checkSuperCall(Object value) {
-            if (value == get()) {
-                set(null);
-                return false;
-            } else {
-                return true;
-            }
-        }
-    }
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @interface Identifier {
-
-    }
-
-    static class ForHashCode {
-
-        @SuppressWarnings("unused")
-        @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
-        private static boolean enter(@Identifier String id,
-                                     @Advice.This Object self) {
-            MockMethodDispatcher dispatcher = MockMethodDispatcher.get(id, self);
-            return dispatcher != null && dispatcher.isMock(self);
-        }
-
-        @SuppressWarnings({"unused", "UnusedAssignment"})
-        @Advice.OnMethodExit
-        private static void enter(@Advice.This Object self,
-                                  @Advice.Return(readOnly = false) int hashCode,
-                                  @Advice.Enter boolean skipped) {
-            if (skipped) {
-                hashCode = System.identityHashCode(self);
-            }
-        }
-    }
-
-    static class ForEquals {
-
-        @SuppressWarnings("unused")
-        @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
-        private static boolean enter(@Identifier String identifier,
-                                     @Advice.This Object self) {
-            MockMethodDispatcher dispatcher = MockMethodDispatcher.get(identifier, self);
-            return dispatcher != null && dispatcher.isMock(self);
-        }
-
-        @SuppressWarnings({"unused", "UnusedAssignment"})
-        @Advice.OnMethodExit
-        private static void enter(@Advice.This Object self,
-                                  @Advice.Argument(0) Object other,
-                                  @Advice.Return(readOnly = false) boolean equals,
-                                  @Advice.Enter boolean skipped) {
-            if (skipped) {
-                equals = self == other;
-            }
-        }
-    }
-
-    public static class ForReadObject {
-
-        @SuppressWarnings("unused")
-        public static void doReadObject(@Identifier String identifier,
-                                        @This MockAccess thiz,
-                                        @Argument(0) ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
-            objectInputStream.defaultReadObject();
-            MockMethodAdvice mockMethodAdvice = (MockMethodAdvice) MockMethodDispatcher.get(identifier, thiz);
-            if (mockMethodAdvice != null) {
-                mockMethodAdvice.interceptors.put(thiz, thiz.getMockitoInterceptor());
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
deleted file mode 100644
index fdb706b882..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
-
-import java.io.ObjectStreamException;
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-
-import net.bytebuddy.implementation.bind.annotation.AllArguments;
-import net.bytebuddy.implementation.bind.annotation.Argument;
-import net.bytebuddy.implementation.bind.annotation.BindingPriority;
-import net.bytebuddy.implementation.bind.annotation.FieldValue;
-import net.bytebuddy.implementation.bind.annotation.Origin;
-import net.bytebuddy.implementation.bind.annotation.RuntimeType;
-import net.bytebuddy.implementation.bind.annotation.StubValue;
-import net.bytebuddy.implementation.bind.annotation.SuperCall;
-import net.bytebuddy.implementation.bind.annotation.This;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.invocation.RealMethod;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-
-public class MockMethodInterceptor implements Serializable {
-
-    private static final long serialVersionUID = 7152947254057253027L;
-
-    final MockHandler handler;
-
-    private final MockCreationSettings mockCreationSettings;
-
-    private final ByteBuddyCrossClassLoaderSerializationSupport serializationSupport;
-
-    public MockMethodInterceptor(MockHandler handler, MockCreationSettings mockCreationSettings) {
-        this.handler = handler;
-        this.mockCreationSettings = mockCreationSettings;
-        serializationSupport = new ByteBuddyCrossClassLoaderSerializationSupport();
-    }
-
-    Object doIntercept(Object mock,
-                       Method invokedMethod,
-                       Object[] arguments,
-                       RealMethod realMethod) throws Throwable {
-        return doIntercept(mock,
-                           invokedMethod,
-                           arguments,
-                           realMethod,
-                           new LocationImpl());
-    }
-
-    Object doIntercept(Object mock,
-                       Method invokedMethod,
-                       Object[] arguments,
-                       RealMethod realMethod,
-                       Location location) throws Throwable {
-        return handler.handle(createInvocation(mock, invokedMethod, arguments, realMethod, mockCreationSettings, location));
-    }
-
-    public MockHandler getMockHandler() {
-        return handler;
-    }
-
-    public ByteBuddyCrossClassLoaderSerializationSupport getSerializationSupport() {
-        return serializationSupport;
-    }
-
-    public static class ForHashCode {
-
-        @SuppressWarnings("unused")
-        public static int doIdentityHashCode(@This Object thiz) {
-            return System.identityHashCode(thiz);
-        }
-    }
-
-    public static class ForEquals {
-
-        @SuppressWarnings("unused")
-        public static boolean doIdentityEquals(@This Object thiz, @Argument(0) Object other) {
-            return thiz == other;
-        }
-    }
-
-    public static class ForWriteReplace {
-
-        public static Object doWriteReplace(@This MockAccess thiz) throws ObjectStreamException {
-            return thiz.getMockitoInterceptor().getSerializationSupport().writeReplace(thiz);
-        }
-    }
-
-    public static class DispatcherDefaultingToRealMethod {
-
-        @SuppressWarnings("unused")
-        @RuntimeType
-        @BindingPriority(BindingPriority.DEFAULT * 2)
-        public static Object interceptSuperCallable(@This Object mock,
-                                                    @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
-                                                    @Origin Method invokedMethod,
-                                                    @AllArguments Object[] arguments,
-                                                    @SuperCall(serializableProxy = true) Callable<?> superCall) throws Throwable {
-            if (interceptor == null) {
-                return superCall.call();
-            }
-            return interceptor.doIntercept(
-                mock,
-                invokedMethod,
-                arguments,
-                new RealMethod.FromCallable(superCall)
-                                          );
-        }
-
-        @SuppressWarnings("unused")
-        @RuntimeType
-        public static Object interceptAbstract(@This Object mock,
-                                               @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
-                                               @StubValue Object stubValue,
-                                               @Origin Method invokedMethod,
-                                               @AllArguments Object[] arguments) throws Throwable {
-            if (interceptor == null) {
-                return stubValue;
-            }
-            return interceptor.doIntercept(
-                mock,
-                invokedMethod,
-                arguments,
-                RealMethod.IsIllegal.INSTANCE
-                                          );
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java b/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java
deleted file mode 100644
index 1aa9cdc07e..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static net.bytebuddy.matcher.ElementMatchers.isTypeInitializer;
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Random;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.description.modifier.Ownership;
-import net.bytebuddy.description.modifier.Visibility;
-import net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy;
-import net.bytebuddy.implementation.Implementation;
-import net.bytebuddy.implementation.MethodCall;
-import net.bytebuddy.implementation.StubMethod;
-import org.mockito.codegen.InjectionBase;
-import org.mockito.exceptions.base.MockitoException;
-
-abstract class ModuleHandler {
-
-    abstract boolean isOpened(Class<?> source, Class<?> target);
-
-    abstract boolean canRead(Class<?> source, Class<?> target);
-
-    abstract boolean isExported(Class<?> source);
-
-    abstract boolean isExported(Class<?> source, Class<?> target);
-
-    abstract Class<?> injectionBase(ClassLoader classLoader, String tyoeName);
-
-    abstract void adjustModuleGraph(Class<?> source, Class<?> target, boolean export, boolean read);
-
-    static ModuleHandler make(ByteBuddy byteBuddy, SubclassLoader loader, Random random) {
-        try {
-            return new ModuleSystemFound(
-                byteBuddy, loader, random
-            );
-        } catch (Exception ignored) {
-            return new NoModuleSystemFound();
-        }
-    }
-
-    private static class ModuleSystemFound extends ModuleHandler {
-
-        private final ByteBuddy byteBuddy;
-        private final SubclassLoader loader;
-        private final Random random;
-
-        private final int injectonBaseSuffix;
-
-        private final Method getModule, isOpen, isExported, isExportedUnqualified, canRead, addExports, addReads, addOpens, forName;
-
-        private ModuleSystemFound(ByteBuddy byteBuddy, SubclassLoader loader, Random random) throws Exception {
-            this.byteBuddy = byteBuddy;
-            this.loader = loader;
-            this.random = random;
-            injectonBaseSuffix = Math.abs(random.nextInt());
-            Class<?> moduleType = Class.forName("java.lang.Module");
-            getModule = Class.class.getMethod("getModule");
-            isOpen = moduleType.getMethod("isOpen", String.class, moduleType);
-            isExported = moduleType.getMethod("isExported", String.class, moduleType);
-            isExportedUnqualified = moduleType.getMethod("isExported", String.class);
-            canRead = moduleType.getMethod("canRead", moduleType);
-            addExports = moduleType.getMethod("addExports", String.class, moduleType);
-            addReads = moduleType.getMethod("addReads", moduleType);
-            addOpens = moduleType.getMethod("addOpens", String.class, moduleType);
-            forName = Class.class.getMethod("forName", String.class);
-        }
-
-        @Override
-        boolean isOpened(Class<?> source, Class<?> target) {
-            if (source.getPackage() == null) {
-                return true;
-            }
-            return (Boolean) invoke(isOpen, invoke(getModule, source), source.getPackage().getName(), invoke(getModule, target));
-        }
-
-        @Override
-        boolean canRead(Class<?> source, Class<?> target) {
-            return (Boolean) invoke(canRead, invoke(getModule, source), invoke(getModule, target));
-        }
-
-        @Override
-        boolean isExported(Class<?> source) {
-            if (source.getPackage() == null) {
-                return true;
-            }
-            return (Boolean) invoke(isExportedUnqualified, invoke(getModule, source), source.getPackage().getName());
-        }
-
-        @Override
-        boolean isExported(Class<?> source, Class<?> target) {
-            if (source.getPackage() == null) {
-                return true;
-            }
-            return (Boolean) invoke(isExported, invoke(getModule, source), source.getPackage().getName(), invoke(getModule, target));
-        }
-
-        @Override
-        Class<?> injectionBase(ClassLoader classLoader, String typeName) {
-            String packageName = typeName.substring(0, typeName.lastIndexOf('.'));
-            if (classLoader == InjectionBase.class.getClassLoader() && InjectionBase.class.getPackage().getName().equals(packageName)) {
-                return InjectionBase.class;
-            } else {
-                synchronized (this) {
-                    String name;
-                    int suffix = injectonBaseSuffix;
-                    do {
-                        name = packageName + "." + InjectionBase.class.getSimpleName() + "$" + suffix++;
-                        try {
-                            Class<?> type = Class.forName(name, false, classLoader);
-                            // The injected type must be defined in the class loader that is target of the injection. Otherwise,
-                            // the class's unnamed module would differ from the intended module. To avoid conflicts, we increment
-                            // the suffix until we hit a class with a known name and generate one if it does not exist.
-                            if (type.getClassLoader() == classLoader) {
-                                return type;
-                            }
-                        } catch (ClassNotFoundException ignored) {
-                            break;
-                        }
-                    } while (true);
-                    return byteBuddy.subclass(Object.class, ConstructorStrategy.Default.NO_CONSTRUCTORS)
-                        .name(name)
-                        .make()
-                        .load(classLoader, loader.resolveStrategy(InjectionBase.class, classLoader, false))
-                        .getLoaded();
-                }
-            }
-        }
-
-        @Override
-        void adjustModuleGraph(Class<?> source, Class<?> target, boolean export, boolean read) {
-            boolean needsExport = export && !isExported(source, target);
-            boolean needsRead = read && !canRead(source, target);
-            if (!needsExport && !needsRead) {
-                return;
-            }
-            ClassLoader classLoader = source.getClassLoader();
-            if (classLoader == null) {
-                throw new MockitoException(join("Cannot adjust module graph for modules in the bootstrap loader",
-                    "",
-                    source + " is declared by the bootstrap loader and cannot be adjusted",
-                    "Requires package export to " + target + ": " + needsExport,
-                    "Requires adjusted reading of " + target + ": " + needsRead));
-            }
-            boolean targetVisible = classLoader == target.getClassLoader();
-            while (!targetVisible && classLoader != null) {
-                classLoader = classLoader.getParent();
-                targetVisible = classLoader == target.getClassLoader();
-            }
-            MethodCall targetLookup;
-            Implementation.Composable implementation;
-            if (targetVisible) {
-                targetLookup = MethodCall.invoke(getModule).onMethodCall(MethodCall.invoke(forName).with(target.getName()));
-                implementation = StubMethod.INSTANCE;
-            } else {
-                Class<?> intermediate;
-                Field field;
-                try {
-                    intermediate = byteBuddy.subclass(Object.class, ConstructorStrategy.Default.NO_CONSTRUCTORS)
-                        .name(String.format("%s$%d", "org.mockito.codegen.MockitoTypeCarrier", Math.abs(random.nextInt())))
-                        .defineField("mockitoType", Class.class, Visibility.PUBLIC, Ownership.STATIC)
-                        .make()
-                        .load(source.getClassLoader(), loader.resolveStrategy(source, source.getClassLoader(), false))
-                        .getLoaded();
-                    field = intermediate.getField("mockitoType");
-                    field.set(null, target);
-                } catch (Exception e) {
-                    throw new MockitoException(join("Could not create a carrier for making the Mockito type visible to " + source,
-                        "",
-                        "This is required to adjust the module graph to enable mock creation"), e);
-                }
-                targetLookup = MethodCall.invoke(getModule).onField(field);
-                implementation = MethodCall.invoke(getModule).onMethodCall(MethodCall.invoke(forName).with(intermediate.getName()));
-            }
-            MethodCall sourceLookup = MethodCall.invoke(getModule).onMethodCall(MethodCall.invoke(forName).with(source.getName()));
-            if (needsExport) {
-                implementation = implementation.andThen(MethodCall.invoke(addExports)
-                    .onMethodCall(sourceLookup)
-                    .with(target.getPackage().getName())
-                    .withMethodCall(targetLookup));
-            }
-            if (needsRead) {
-                implementation = implementation.andThen(MethodCall.invoke(addReads)
-                    .onMethodCall(sourceLookup)
-                    .withMethodCall(targetLookup));
-            }
-            try {
-                Class.forName(byteBuddy.subclass(Object.class)
-                    .name(String.format("%s$%s$%d", source.getName(), "MockitoModuleProbe", Math.abs(random.nextInt())))
-                    .invokable(isTypeInitializer()).intercept(implementation)
-                    .make()
-                    .load(source.getClassLoader(), loader.resolveStrategy(source, source.getClassLoader(), false))
-                    .getLoaded()
-                    .getName(), true, source.getClassLoader());
-            } catch (Exception e) {
-                throw new MockitoException(join("Could not force module adjustment of the module of " + source,
-                    "",
-                    "This is required to adjust the module graph to enable mock creation"), e);
-            }
-        }
-
-        private static Object invoke(Method method, Object target, Object... args) {
-            try {
-                return method.invoke(target, args);
-            } catch (Exception e) {
-                throw new MockitoException(join("Could not invoke " + method + " using reflection",
-                    "",
-                    "Mockito attempted to interact with the Java module system but an unexpected method behavior was encountered"), e);
-            }
-        }
-    }
-
-    private static class NoModuleSystemFound extends ModuleHandler {
-
-        @Override
-        boolean isOpened(Class<?> source, Class<?> target) {
-            return true;
-        }
-
-        @Override
-        boolean canRead(Class<?> source, Class<?> target) {
-            return true;
-        }
-
-        @Override
-        boolean isExported(Class<?> source) {
-            return true;
-        }
-
-        @Override
-        boolean isExported(Class<?> source, Class<?> target) {
-            return true;
-        }
-
-        @Override
-        Class<?> injectionBase(ClassLoader classLoader, String tyoeName) {
-            return InjectionBase.class;
-        }
-
-        @Override
-        void adjustModuleGraph(Class<?> source, Class<?> target, boolean export, boolean read) {
-            // empty
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
deleted file mode 100644
index e264a82572..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.reflect.Modifier;
-
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.util.Platform;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * Subclass based mock maker.
- *
- * This mock maker tries to create a subclass to represent a mock. It uses the given mock settings, that contains
- * the type to mock, extra interfaces, and serialization support.
- *
- * <p>
- * The type to mock has to be not final and not part of the JDK. THe created mock will implement extra interfaces
- * if any. And will implement <code>Serializable</code> if this settings is explicitly set.
- */
-public class SubclassByteBuddyMockMaker implements ClassCreatingMockMaker {
-
-    private final BytecodeGenerator cachingMockBytecodeGenerator;
-
-    public SubclassByteBuddyMockMaker() {
-        this(new SubclassInjectionLoader());
-    }
-
-    public SubclassByteBuddyMockMaker(SubclassLoader loader) {
-        cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(loader), false);
-    }
-
-    @Override
-    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
-        Class<? extends T> mockedProxyType = createMockType(settings);
-
-        Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(settings);
-        T mockInstance = null;
-        try {
-            mockInstance = instantiator.newInstance(mockedProxyType);
-            MockAccess mockAccess = (MockAccess) mockInstance;
-            mockAccess.setMockitoInterceptor(new MockMethodInterceptor(handler, settings));
-
-            return ensureMockIsAssignableToMockedType(settings, mockInstance);
-        } catch (ClassCastException cce) {
-            throw new MockitoException(join(
-                    "ClassCastException occurred while creating the mockito mock :",
-                    "  class to mock : " + describeClass(settings.getTypeToMock()),
-                    "  created class : " + describeClass(mockedProxyType),
-                    "  proxy instance class : " + describeClass(mockInstance),
-                    "  instance creation by : " + instantiator.getClass().getSimpleName(),
-                    "",
-                    "You might experience classloading issues, please ask the mockito mailing-list.",
-                    ""
-            ), cce);
-        } catch (org.mockito.creation.instance.InstantiationException e) {
-            throw new MockitoException("Unable to create mock instance of type '" + mockedProxyType.getSuperclass().getSimpleName() + "'", e);
-        }
-    }
-
-    @Override
-    public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
-        try {
-            return cachingMockBytecodeGenerator.mockClass(MockFeatures.withMockFeatures(
-                    settings.getTypeToMock(),
-                    settings.getExtraInterfaces(),
-                    settings.getSerializableMode(),
-                    settings.isStripAnnotations()
-            ));
-        } catch (Exception bytecodeGenerationFailed) {
-            throw prettifyFailure(settings, bytecodeGenerationFailed);
-        }
-    }
-
-    private static <T> T ensureMockIsAssignableToMockedType(MockCreationSettings<T> settings, T mock) {
-        // Force explicit cast to mocked type here, instead of
-        // relying on the JVM to implicitly cast on the client call site.
-        // This allows us to catch earlier the ClassCastException earlier
-        Class<T> typeToMock = settings.getTypeToMock();
-        return typeToMock.cast(mock);
-    }
-
-    private <T> RuntimeException prettifyFailure(MockCreationSettings<T> mockFeatures, Exception generationFailed) {
-        if (mockFeatures.getTypeToMock().isArray()) {
-            throw new MockitoException(join(
-                    "Mockito cannot mock arrays: " + mockFeatures.getTypeToMock() + ".",
-                    ""
-                    ), generationFailed);
-        }
-        if (Modifier.isPrivate(mockFeatures.getTypeToMock().getModifiers())) {
-            throw new MockitoException(join(
-                    "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
-                    "Most likely it is due to mocking a private class that is not visible to Mockito",
-                    ""
-            ), generationFailed);
-        }
-        throw new MockitoException(join(
-                "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
-                "",
-                "Mockito can only mock non-private & non-final classes.",
-                "If you're not sure why you're getting this error, please report to the mailing list.",
-                "",
-                Platform.warnForVM(
-                        "IBM J9 VM", "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
-                        "Hotspot", Platform.isJava8BelowUpdate45() ? "Java 8 early builds have bugs that were addressed in Java 1.8.0_45, please update your JDK!\n" : ""
-                ),
-                Platform.describe(),
-                "",
-                "Underlying exception : " + generationFailed
-        ), generationFailed);
-    }
-
-    private static String describeClass(Class<?> type) {
-        return type == null ? "null" : "'" + type.getCanonicalName() + "', loaded by classloader : '" + type.getClassLoader() + "'";
-    }
-
-    private static String describeClass(Object instance) {
-        return instance == null ? "null" : describeClass(instance.getClass());
-    }
-
-    @Override
-    public MockHandler getHandler(Object mock) {
-        if (!(mock instanceof MockAccess)) {
-            return null;
-        }
-        return ((MockAccess) mock).getMockitoInterceptor().getMockHandler();
-    }
-
-    @Override
-    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
-        ((MockAccess) mock).setMockitoInterceptor(
-                new MockMethodInterceptor(newHandler, settings)
-        );
-    }
-
-    @Override
-    public TypeMockability isTypeMockable(final Class<?> type) {
-        return new TypeMockability() {
-            @Override
-            public boolean mockable() {
-                return !type.isPrimitive() && !Modifier.isFinal(type.getModifiers());
-            }
-
-            @Override
-            public String nonMockableReason() {
-                if(mockable()) {
-                    return "";
-                }
-                if (type.isPrimitive()) {
-                    return "primitive type";
-                }
-                if (Modifier.isFinal(type.getModifiers())) {
-                    return "final class";
-                }
-                return join("not handled type");
-            }
-        };
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
deleted file mode 100644
index 0a56186579..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static java.lang.Thread.currentThread;
-
-import static net.bytebuddy.description.modifier.Visibility.PRIVATE;
-import static net.bytebuddy.dynamic.Transformer.ForMethod.withModifiers;
-import static net.bytebuddy.implementation.MethodDelegation.to;
-import static net.bytebuddy.implementation.attribute.MethodAttributeAppender.ForInstrumentedMethod.INCLUDING_RECEIVER;
-import static net.bytebuddy.matcher.ElementMatchers.*;
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Random;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.description.method.MethodDescription;
-import net.bytebuddy.description.modifier.SynchronizationState;
-import net.bytebuddy.description.modifier.Visibility;
-import net.bytebuddy.dynamic.DynamicType;
-import net.bytebuddy.dynamic.loading.MultipleParentClassLoader;
-import net.bytebuddy.dynamic.scaffold.TypeValidation;
-import net.bytebuddy.implementation.FieldAccessor;
-import net.bytebuddy.implementation.Implementation;
-import net.bytebuddy.implementation.attribute.MethodAttributeAppender;
-import net.bytebuddy.matcher.ElementMatcher;
-import org.mockito.codegen.InjectionBase;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport.CrossClassLoaderSerializableMock;
-import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod;
-import org.mockito.mock.SerializableMode;
-
-class SubclassBytecodeGenerator implements BytecodeGenerator {
-
-    private static final String CODEGEN_PACKAGE = "org.mockito.codegen.";
-
-    private final SubclassLoader loader;
-    private final ModuleHandler handler;
-    private final ByteBuddy byteBuddy;
-    private final Random random;
-    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());
-    }
-
-    public SubclassBytecodeGenerator(SubclassLoader loader) {
-        this(loader, null, any());
-    }
-
-    public SubclassBytecodeGenerator(Implementation readReplace, ElementMatcher<? super MethodDescription> matcher) {
-        this(new SubclassInjectionLoader(), readReplace, matcher);
-    }
-
-    protected SubclassBytecodeGenerator(SubclassLoader loader, Implementation readReplace, ElementMatcher<? super MethodDescription> matcher) {
-        this.loader = loader;
-        this.readReplace = readReplace;
-        this.matcher = matcher;
-        byteBuddy = new ByteBuddy().with(TypeValidation.DISABLED);
-        random = new Random();
-        handler = ModuleHandler.make(byteBuddy, loader, random);
-    }
-
-    @Override
-    public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
-        ClassLoader classLoader = new MultipleParentClassLoader.Builder()
-            .appendMostSpecific(getAllTypes(features.mockedType))
-            .appendMostSpecific(features.interfaces)
-            .appendMostSpecific(currentThread().getContextClassLoader())
-            .appendMostSpecific(MockAccess.class)
-            .build();
-
-        // If Mockito does not need to create a new class loader and if a mock is not based on a JDK type, we attempt
-        // to define the mock class in the user runtime package to allow for mocking package private types and methods.
-        // This also requires that we are able to access the package of the mocked class either by override or explicit
-        // privilege given by the target package being opened to Mockito.
-        boolean localMock = classLoader == features.mockedType.getClassLoader()
-            && features.serializableMode != SerializableMode.ACROSS_CLASSLOADERS
-            && !isComingFromJDK(features.mockedType)
-            && (loader.isDisrespectingOpenness() || handler.isOpened(features.mockedType, MockAccess.class));
-        String typeName;
-        if (localMock || loader instanceof MultipleParentClassLoader && !isComingFromJDK(features.mockedType)) {
-            typeName = features.mockedType.getName();
-        } else {
-            typeName = InjectionBase.class.getPackage().getName() + "." + features.mockedType.getSimpleName();
-        }
-        String name = String.format("%s$%s$%d", typeName, "MockitoMock", Math.abs(random.nextInt()));
-
-        if (localMock) {
-            handler.adjustModuleGraph(features.mockedType, MockAccess.class, false, true);
-            for (Class<?> iFace : features.interfaces) {
-                handler.adjustModuleGraph(iFace, features.mockedType, true, false);
-                handler.adjustModuleGraph(features.mockedType, iFace, false, true);
-            }
-        } else {
-            boolean exported = handler.isExported(features.mockedType);
-            Iterator<Class<?>> it = features.interfaces.iterator();
-            while (exported && it.hasNext()) {
-                exported = handler.isExported(it.next());
-            }
-            // We check if all mocked types are exported without qualification to avoid generating a hook type.
-            // unless this is necessary. We expect this to be the case for most mocked types what makes this a
-            // worthy performance optimization.
-            if (exported) {
-                assertVisibility(features.mockedType);
-                for (Class<?> iFace : features.interfaces) {
-                    assertVisibility(iFace);
-                }
-            } else {
-                Class<?> hook = handler.injectionBase(classLoader, typeName);
-                assertVisibility(features.mockedType);
-                handler.adjustModuleGraph(features.mockedType, hook, true, false);
-                for (Class<?> iFace : features.interfaces) {
-                    assertVisibility(iFace);
-                    handler.adjustModuleGraph(iFace, hook, true, false);
-                }
-            }
-        }
-
-        DynamicType.Builder<T> builder = byteBuddy.subclass(features.mockedType)
-            .name(name)
-            .ignoreAlso(isGroovyMethod())
-            .annotateType(features.stripAnnotations
-                ? new Annotation[0]
-                : features.mockedType.getAnnotations())
-            .implement(new ArrayList<Type>(features.interfaces))
-            .method(matcher)
-            .intercept(dispatcher)
-            .transform(withModifiers(SynchronizationState.PLAIN))
-            .attribute(features.stripAnnotations
-                ? MethodAttributeAppender.NoOp.INSTANCE
-                : INCLUDING_RECEIVER)
-            .method(isHashCode())
-            .intercept(hashCode)
-            .method(isEquals())
-            .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(writeReplace);
-        }
-        if (readReplace != null) {
-            builder = builder.defineMethod("readObject", void.class, Visibility.PRIVATE)
-                .withParameters(ObjectInputStream.class)
-                .throwing(ClassNotFoundException.class, IOException.class)
-                .intercept(readReplace);
-        }
-        if (name.startsWith(CODEGEN_PACKAGE) || classLoader instanceof MultipleParentClassLoader) {
-            builder = builder.ignoreAlso(isPackagePrivate()
-                .or(returns(isPackagePrivate()))
-                .or(hasParameters(whereAny(hasType(isPackagePrivate())))));
-        }
-        return builder.make()
-            .load(classLoader, loader.resolveStrategy(features.mockedType, classLoader, localMock))
-            .getLoaded();
-    }
-
-    private <T> Collection<Class<? super T>> getAllTypes(Class<T> type) {
-        Collection<Class<? super T>> supertypes = new LinkedList<Class<? super T>>();
-        supertypes.add(type);
-        Class<? super T> superType = type;
-        while (superType != null) {
-            supertypes.add(superType);
-            superType = superType.getSuperclass();
-        }
-        return supertypes;
-    }
-
-    private static ElementMatcher<MethodDescription> isGroovyMethod() {
-        return isDeclaredBy(named("groovy.lang.GroovyObjectSupport"));
-    }
-
-    private boolean isComingFromJDK(Class<?> type) {
-        // Comes from the manifest entry :
-        // Implementation-Title: Java Runtime Environment
-        // This entry is not necessarily present in every jar of the JDK
-        return type.getPackage() != null && "Java Runtime Environment".equalsIgnoreCase(type.getPackage().getImplementationTitle())
-            || type.getName().startsWith("java.")
-            || type.getName().startsWith("javax.");
-    }
-
-    private static void assertVisibility(Class<?> type) {
-        if (!Modifier.isPublic(type.getModifiers())) {
-            throw new MockitoException(join("Cannot create mock for " + type,
-                "",
-                "The type is not public and its mock class is loaded by a different class loader.",
-                "This can have multiple reasons:",
-                " - You are mocking a class with additional interfaces of another class loader",
-                " - Mockito is loaded by a different class loader than the mocked type (e.g. with OSGi)",
-                " - The thread's context class loader is different than the mock's class loader"));
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
deleted file mode 100644
index a2b34ed706..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-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;
-
-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.noUnsafeInjection") && 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 boolean isDisrespectingOpenness() {
-            return true;
-        }
-
-        @Override
-        public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
-            return ClassLoadingStrategy.Default.INJECTION.with(localMock ? mockedType.getProtectionDomain() : InjectionBase.class.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 boolean isDisrespectingOpenness() {
-            return false;
-        }
-
-        @Override
-        public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
-            if (localMock) {
-                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
-                    ));
-                }
-            } else if (classLoader == InjectionBase.class.getClassLoader()) {
-                return ClassLoadingStrategy.UsingLookup.of(codegenLookup);
-            } else {
-                return ClassLoadingStrategy.Default.WRAPPER.with(mockedType.getProtectionDomain());
-            }
-        }
-    }
-
-    @Override
-    public boolean isDisrespectingOpenness() {
-        return loader.isDisrespectingOpenness();
-    }
-
-    @Override
-    public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
-        return loader.resolveStrategy(mockedType, classLoader, localMock);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
deleted file mode 100644
index 011504ea17..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-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 {
-
-    /**
-     * Checks if this loader does not require a module to be open.
-     *
-     * @return {@code true} if this loader is not constraint to a target module being opened for loading a class.
-     */
-    boolean isDisrespectingOpenness();
-
-    /**
-     * Resolves a class loading strategy.
-     *
-     * @param mockedType  The type being mocked.
-     * @param classLoader The class loader being used.
-     * @param localMock   {@code true} if the mock is loaded within the runtime package of the mocked type.
-     * @return An appropriate class loading strategy.
-     */
-    ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean localMock);
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
deleted file mode 100644
index 25fabe5849..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import java.lang.ref.ReferenceQueue;
-import java.util.Set;
-import java.util.concurrent.Callable;
-
-import net.bytebuddy.TypeCache;
-import org.mockito.mock.SerializableMode;
-
-class TypeCachingBytecodeGenerator extends ReferenceQueue<ClassLoader> implements BytecodeGenerator {
-
-    private final Object BOOTSTRAP_LOCK = new Object();
-
-    private final BytecodeGenerator bytecodeGenerator;
-
-    private final TypeCache<MockitoMockKey> typeCache;
-
-    public TypeCachingBytecodeGenerator(BytecodeGenerator bytecodeGenerator, boolean weak) {
-        this.bytecodeGenerator = bytecodeGenerator;
-        typeCache = new TypeCache.WithInlineExpunction<MockitoMockKey>(weak ? TypeCache.Sort.WEAK : TypeCache.Sort.SOFT);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <T> Class<T> mockClass(final MockFeatures<T> params) {
-        try {
-            ClassLoader classLoader = params.mockedType.getClassLoader();
-            return (Class<T>) typeCache.findOrInsert(classLoader,
-                    new MockitoMockKey(params.mockedType, params.interfaces, params.serializableMode, params.stripAnnotations),
-                    new Callable<Class<?>>() {
-                        @Override
-                        public Class<?> call() throws Exception {
-                            return bytecodeGenerator.mockClass(params);
-                        }
-                    }, BOOTSTRAP_LOCK);
-        } catch (IllegalArgumentException exception) {
-            Throwable cause = exception.getCause();
-            if (cause instanceof RuntimeException) {
-                throw (RuntimeException) cause;
-            } else {
-                throw exception;
-            }
-        }
-    }
-
-    private static class MockitoMockKey extends TypeCache.SimpleKey {
-
-        private final SerializableMode serializableMode;
-        private final boolean stripAnnotations;
-
-        private MockitoMockKey(Class<?> type,
-                               Set<Class<?>> additionalType,
-                               SerializableMode serializableMode,
-                               boolean stripAnnotations) {
-            super(type, additionalType);
-            this.serializableMode = serializableMode;
-            this.stripAnnotations = stripAnnotations;
-        }
-
-        @Override
-        public boolean equals(Object object) {
-            if (this == object) return true;
-            if (object == null || getClass() != object.getClass()) return false;
-            if (!super.equals(object)) return false;
-            MockitoMockKey that = (MockitoMockKey) object;
-            return stripAnnotations == that.stripAnnotations
-                && serializableMode.equals(that.serializableMode);
-        }
-
-        @Override
-        public int hashCode() {
-            int result = super.hashCode();
-            result = 31 * result + (stripAnnotations ? 1 : 0);
-            result = 31 * result + serializableMode.hashCode();
-            return result;
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java b/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java
deleted file mode 100644
index 12e30db9b3..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy.inject;
-
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-public abstract class MockMethodDispatcher {
-
-    private static final ConcurrentMap<String, MockMethodDispatcher> INSTANCE = new ConcurrentHashMap<String, MockMethodDispatcher>();
-
-    public static MockMethodDispatcher get(String identifier, Object mock) {
-        if (mock == INSTANCE) { // Avoid endless loop if ConcurrentHashMap was redefined to check for being a mock.
-            return null;
-        } else {
-            return INSTANCE.get(identifier);
-        }
-    }
-
-    public static void set(String identifier, MockMethodDispatcher dispatcher) {
-        INSTANCE.putIfAbsent(identifier, dispatcher);
-    }
-
-    public abstract Callable<?> handle(Object instance, Method origin, Object[] arguments) throws Throwable;
-
-    public abstract boolean isMock(Object instance);
-
-    public abstract boolean isMocked(Object instance);
-
-    public abstract boolean isOverridden(Object instance, Method origin);
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java b/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java
deleted file mode 100644
index 5abed05fbe..0000000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-/**
- * Internal classes, not to be used by clients. Intended for injection into the bootstrap class loader.
- *
- * Subject to change at any time without notice.
- */
-package org.mockito.internal.creation.bytebuddy.inject;
diff --git a/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java b/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
deleted file mode 100644
index c3022c7d3b..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.creation.instance.InstantiationException;
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.internal.util.Primitives;
-import org.mockito.internal.util.reflection.AccessibilityChanger;
-
-public class ConstructorInstantiator implements Instantiator {
-
-    /**
-     * Whether or not the constructors used for creating an object refer to an outer instance or not.
-     * This member is only used to for constructing error messages.
-     * If an outer inject exists, it would be the first ([0]) element of the {@link #constructorArgs} array.
-     */
-    private final boolean hasOuterClassInstance;
-    private final Object[] constructorArgs;
-
-    public ConstructorInstantiator(boolean hasOuterClassInstance, Object... constructorArgs) {
-        this.hasOuterClassInstance = hasOuterClassInstance;
-        this.constructorArgs = constructorArgs;
-    }
-
-    public <T> T newInstance(Class<T> cls) {
-        return withParams(cls, constructorArgs);
-    }
-
-    private <T> T withParams(Class<T> cls, Object... params) {
-        List<Constructor<?>> matchingConstructors = new LinkedList<Constructor<?>>();
-        try {
-            for (Constructor<?> constructor : cls.getDeclaredConstructors()) {
-                Class<?>[] types = constructor.getParameterTypes();
-                if (paramsMatch(types, params)) {
-                    evaluateConstructor(matchingConstructors, constructor);
-                }
-            }
-
-            if (matchingConstructors.size() == 1) {
-                return invokeConstructor(matchingConstructors.get(0), params);
-            }
-        } catch (Exception e) {
-            throw paramsException(cls, e);
-        }
-        if (matchingConstructors.size() == 0) {
-            throw noMatchingConstructor(cls);
-        } else {
-            throw multipleMatchingConstructors(cls, matchingConstructors);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static <T> T invokeConstructor(Constructor<?> constructor, Object... params) throws java.lang.InstantiationException, IllegalAccessException, InvocationTargetException {
-        AccessibilityChanger accessibility = new AccessibilityChanger();
-        accessibility.enableAccess(constructor);
-        return (T) constructor.newInstance(params);
-    }
-
-    private InstantiationException paramsException(Class<?> cls, Exception e) {
-        return new InstantiationException(join(
-                "Unable to create instance of '" + cls.getSimpleName() + "'.",
-                "Please ensure the target class has " + constructorArgsString() + " and executes cleanly.")
-                , e);
-    }
-
-    private String constructorArgTypes() {
-        int argPos = 0;
-        if (hasOuterClassInstance) {
-            ++argPos;
-        }
-        String[] constructorArgTypes = new String[constructorArgs.length - argPos];
-        for (int i = argPos; i < constructorArgs.length; ++i) {
-            constructorArgTypes[i - argPos] = constructorArgs[i] == null ? null : constructorArgs[i].getClass().getName();
-        }
-        return Arrays.toString(constructorArgTypes);
-    }
-
-    private InstantiationException noMatchingConstructor(Class<?> cls) {
-        String constructorString = constructorArgsString();
-        String outerInstanceHint = "";
-        if (hasOuterClassInstance) {
-            outerInstanceHint = " and provided outer instance is correct";
-        }
-        return new InstantiationException(join("Unable to create instance of '" + cls.getSimpleName() + "'.",
-                "Please ensure that the target class has " + constructorString + outerInstanceHint + ".")
-                , null);
-    }
-
-    private String constructorArgsString() {
-        String constructorString;
-        if (constructorArgs.length == 0 || (hasOuterClassInstance && constructorArgs.length == 1)) {
-            constructorString = "a 0-arg constructor";
-        } else {
-            constructorString = "a constructor that matches these argument types: " + constructorArgTypes();
-        }
-        return constructorString;
-    }
-
-    private InstantiationException multipleMatchingConstructors(Class<?> cls, List<Constructor<?>> constructors) {
-        return new InstantiationException(join("Unable to create instance of '" + cls.getSimpleName() + "'.",
-                "Multiple constructors could be matched to arguments of types " + constructorArgTypes() + ":",
-                join("", " - ", constructors),
-                "If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.",
-                "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.",
-                "See https://github.com/mockito/mockito/issues/685"
-            ), null);
-    }
-
-    private static boolean paramsMatch(Class<?>[] types, Object[] params) {
-        if (params.length != types.length) {
-            return false;
-        }
-        for (int i = 0; i < params.length; i++) {
-            if (params[i] == null) {
-                if (types[i].isPrimitive()) {
-                    return false;
-                }
-            } else if ((!types[i].isPrimitive() && !types[i].isInstance(params[i])) ||
-                    (types[i].isPrimitive() && !types[i].equals(Primitives.primitiveTypeOf(params[i].getClass())))) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Evalutes {@code constructor} against the currently found {@code matchingConstructors} and determines if
-     * it's a better match to the given arguments, a worse match, or an equivalently good match.
-     * <p>
-     * This method tries to emulate the behavior specified in
-     * <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.12.2">JLS 15.12.2. Compile-Time
-     * Step 2: Determine Method Signature</a>. A constructor X is deemed to be a better match than constructor Y to the
-     * given argument list if they are both applicable, constructor X has at least one parameter than is more specific
-     * than the corresponding parameter of constructor Y, and constructor Y has no parameter than is more specific than
-     * the corresponding parameter in constructor X.
-     * </p>
-     * <p>
-     * If {@code constructor} is a better match than the constructors in the {@code matchingConstructors} list, the list
-     * is cleared, and it's added to the list as a singular best matching constructor (so far).<br/>
-     * If {@code constructor} is an equivalently good of a match as the constructors in the {@code matchingConstructors}
-     * list, it's added to the list.<br/>
-     * If {@code constructor} is a worse match than the constructors in the {@code matchingConstructors} list, the list
-     * will remain unchanged.
-     * </p>
-     *
-     * @param matchingConstructors A list of equivalently best matching constructors found so far
-     * @param constructor The constructor to be evaluated against this list
-     */
-    private void evaluateConstructor(List<Constructor<?>> matchingConstructors, Constructor<?> constructor) {
-        boolean newHasBetterParam = false;
-        boolean existingHasBetterParam = false;
-
-        Class<?>[] paramTypes = constructor.getParameterTypes();
-        for (int i = 0; i < paramTypes.length; ++i) {
-            Class<?> paramType = paramTypes[i];
-            if (!paramType.isPrimitive()) {
-                for (Constructor<?> existingCtor : matchingConstructors) {
-                    Class<?> existingParamType = existingCtor.getParameterTypes()[i];
-                    if (paramType != existingParamType) {
-                        if (paramType.isAssignableFrom(existingParamType)) {
-                            existingHasBetterParam = true;
-                        } else {
-                            newHasBetterParam = true;
-                        }
-                    }
-                }
-            }
-        }
-        if (!existingHasBetterParam) {
-            matchingConstructors.clear();
-        }
-        if (newHasBetterParam || !existingHasBetterParam) {
-            matchingConstructors.add(constructor);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java b/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
deleted file mode 100644
index 9c414f3f91..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InstantiatorProvider2;
-
-public class DefaultInstantiatorProvider implements InstantiatorProvider2 {
-
-    private final static Instantiator INSTANCE = new ObjenesisInstantiator();
-
-    public Instantiator getInstantiator(MockCreationSettings<?> settings) {
-        if (settings != null && settings.getConstructorArgs() != null) {
-            return new ConstructorInstantiator(settings.getOuterClassInstance() != null, settings.getConstructorArgs());
-        } else {
-            return INSTANCE;
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java b/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java
deleted file mode 100644
index 86b54630af..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/InstantiationException.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-import org.mockito.exceptions.base.MockitoException;
-
-/**
- * @deprecated since 2.15.4 because this internal class was leaking from the public API.
- * For information why deprecated, see {@link org.mockito.plugins.InstantiatorProvider2}.
- * Use {@link org.mockito.creation.instance.Instantiator} and {@link org.mockito.creation.instance.InstantiationException} types instead.
- * <p>
- * Exception generated when {@link Instantiator#newInstance(Class)} failed.
- */
-@Deprecated
-public class InstantiationException extends MockitoException {
-
-    public InstantiationException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/instance/Instantiator.java b/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
deleted file mode 100644
index 85b6b3dcdf..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-/**
- * @deprecated since 2.15.4 because this internal class was leaking from the public API.
- * For more information why deprecated, see {@link org.mockito.plugins.InstantiatorProvider2}.
- * Use {@link org.mockito.creation.instance.Instantiator} instead.
- * <p>
- * Provides instances of classes.
- */
-@Deprecated
-public interface Instantiator {
-
-    /**
-     * Creates instance of given class
-     */
-    <T> T newInstance(Class<T> cls) throws InstantiationException;
-
-}
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
deleted file mode 100644
index a1ab5d5dad..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InstantiatorProvider;
-import org.mockito.plugins.InstantiatorProvider2;
-
-/**
- * Adapts new public API {@link InstantiatorProvider2} onto old, deprecated API {@link InstantiatorProvider}
- */
-public class InstantiatorProvider2Adapter implements InstantiatorProvider {
-    private final InstantiatorProvider2 provider;
-
-    public InstantiatorProvider2Adapter(InstantiatorProvider2 provider) {
-        this.provider = provider;
-    }
-
-    @Override
-    public Instantiator getInstantiator(final MockCreationSettings<?> settings) {
-        return new Instantiator() {
-            @Override
-            public <T> T newInstance(Class<T> cls) throws InstantiationException {
-                try {
-                    return provider.getInstantiator(settings).newInstance(cls);
-                } catch (org.mockito.creation.instance.InstantiationException e) {
-                    throw new InstantiationException(e.getMessage(), e.getCause());
-                }
-            }
-        };
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
deleted file mode 100644
index c807925a3c..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-import org.mockito.creation.instance.InstantiationException;
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InstantiatorProvider;
-import org.mockito.plugins.InstantiatorProvider2;
-
-/**
- * Adapts old, deprecated {@link InstantiatorProvider} onto a new public {@link InstantiatorProvider2} API.
- */
-public class InstantiatorProviderAdapter implements InstantiatorProvider2 {
-    private final InstantiatorProvider provider;
-
-    public InstantiatorProviderAdapter(InstantiatorProvider provider) {
-        this.provider = provider;
-    }
-
-    @Override
-    public Instantiator getInstantiator(final MockCreationSettings<?> settings) {
-        return new Instantiator() {
-            @Override
-            public <T> T newInstance(Class<T> cls) throws InstantiationException {
-                try {
-                    return provider.getInstantiator(settings).newInstance(cls);
-                } catch (org.mockito.internal.creation.instance.InstantiationException e) {
-                    throw new InstantiationException(e.getMessage(), e.getCause());
-                }
-            }
-        };
-    }
-}
diff --git a/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java b/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
deleted file mode 100644
index 7e41f683ac..0000000000
--- a/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.instance;
-
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.internal.configuration.GlobalConfiguration;
-import org.objenesis.ObjenesisStd;
-
-class ObjenesisInstantiator implements Instantiator {
-
-    //TODO: in order to provide decent exception message when objenesis is not found,
-    //have a constructor in this class that tries to instantiate ObjenesisStd and if it fails then show decent exception that dependency is missing
-    //TODO: for the same reason catch and give better feedback when hamcrest core is not found.
-    private final ObjenesisStd objenesis = new ObjenesisStd(new GlobalConfiguration().enableClassCache());
-
-    public <T> T newInstance(Class<T> cls) {
-        return objenesis.newInstance(cls);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/debugging/LocationImpl.java b/src/main/java/org/mockito/internal/debugging/LocationImpl.java
deleted file mode 100644
index 399ecbcf4f..0000000000
--- a/src/main/java/org/mockito/internal/debugging/LocationImpl.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-import java.io.Serializable;
-
-import org.mockito.internal.exceptions.stacktrace.StackTraceFilter;
-import org.mockito.invocation.Location;
-
-public class LocationImpl implements Location, Serializable {
-
-    private static final long serialVersionUID = -9054861157390980624L;
-    // Limit the amount of objects being created, as this class is heavily instantiated:
-    private static final StackTraceFilter stackTraceFilter = new StackTraceFilter();
-
-    private String stackTraceLine;
-    private String sourceFile;
-
-    public LocationImpl() {
-        this(new Throwable(), false);
-    }
-
-    public LocationImpl(Throwable stackTraceHolder, boolean isInline) {
-        this(stackTraceFilter, stackTraceHolder, isInline);
-    }
-
-    public LocationImpl(StackTraceFilter stackTraceFilter) {
-        this(stackTraceFilter, new Throwable(), false);
-    }
-
-    private LocationImpl(StackTraceFilter stackTraceFilter, Throwable stackTraceHolder, boolean isInline) {
-        computeStackTraceInformation(stackTraceFilter, stackTraceHolder, isInline);
-    }
-
-    @Override
-    public String toString() {
-        return stackTraceLine;
-    }
-
-    /**
-     * Eagerly compute the stacktrace line from the stackTraceHolder. Storing the Throwable is
-     * memory-intensive for tests that have large stacktraces and have a lot of invocations on
-     * mocks.
-     */
-    private void computeStackTraceInformation(
-        StackTraceFilter stackTraceFilter, Throwable stackTraceHolder, boolean isInline) {
-        StackTraceElement filtered = stackTraceFilter.filterFirst(stackTraceHolder, isInline);
-
-        // there are corner cases where exception can have a null or empty stack trace
-        // for example, a custom exception can override getStackTrace() method
-        if (filtered == null) {
-            this.stackTraceLine = "-> at <<unknown line>>";
-            this.sourceFile = "<unknown source file>";
-        } else {
-            this.stackTraceLine = "-> at " + filtered.toString();
-            this.sourceFile = filtered.getFileName();
-        }
-    }
-
-    @Override
-    public String getSourceFile() {
-        return sourceFile;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/debugging/LoggingListener.java b/src/main/java/org/mockito/internal/debugging/LoggingListener.java
deleted file mode 100644
index 4a21a863aa..0000000000
--- a/src/main/java/org/mockito/internal/debugging/LoggingListener.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.Invocation;
-
-public class LoggingListener implements FindingsListener {
-    private final boolean warnAboutUnstubbed;
-
-    private final List<String> argMismatchStubs = new LinkedList<String>();
-    private final List<String> unusedStubs = new LinkedList<String>();
-    private final List<String> unstubbedCalls = new LinkedList<String>();
-
-    public LoggingListener(boolean warnAboutUnstubbed) {
-        this.warnAboutUnstubbed = warnAboutUnstubbed;
-    }
-
-    public void foundStubCalledWithDifferentArgs(Invocation unused, InvocationMatcher unstubbed) {
-        //TODO there is not good reason we should get Invocation and InvocationMatcher here
-        // we should pass 2 InvocationMatchers and testing is easier
-        // it's also confusing that unstubbed invocation is passed as InvocationMatcher (should be rather Invocation)
-
-        //this information comes in pairs
-        String index = Integer.toString(indexOfNextPair(argMismatchStubs.size()));
-        //making sure indentation is correct
-        String padding = index.replaceAll("\\d", " ");
-        argMismatchStubs.add(index +   ". Stubbed " + unused.getLocation());
-        argMismatchStubs.add(padding + "  Invoked " + unstubbed.getInvocation().getLocation());
-    }
-
-    static int indexOfNextPair(int collectionSize) {
-        return (collectionSize / 2) + 1;
-    }
-
-    public void foundUnusedStub(Invocation unused) {
-        unusedStubs.add((unusedStubs.size() + 1) + ". " + unused.getLocation());
-    }
-
-    public void foundUnstubbed(InvocationMatcher unstubbed) {
-        if (warnAboutUnstubbed) {
-            unstubbedCalls.add((unstubbedCalls.size() + 1) + ". " + unstubbed.getInvocation().getLocation());
-        }
-    }
-
-    public String getStubbingInfo() {
-        if (argMismatchStubs.isEmpty() && unusedStubs.isEmpty() && unstubbedCalls.isEmpty()) {
-            return "";
-        }
-
-        List<String> lines = new LinkedList<String>();
-        lines.add("[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):");
-
-        if (!argMismatchStubs.isEmpty()) {
-            lines.add("[Mockito]");
-            lines.add("[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):");
-            lines.add("[Mockito]");
-            addOrderedList(lines, argMismatchStubs);
-        }
-
-        if (!unusedStubs.isEmpty()) {
-            lines.add("[Mockito]");
-            lines.add("[Mockito] Unused stubbing (perhaps can be removed from the test?):");
-            lines.add("[Mockito]");
-            addOrderedList(lines, unusedStubs);
-        }
-
-        if (!unstubbedCalls.isEmpty()) {
-            lines.add("[Mockito]");
-            lines.add("[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):");
-            lines.add("[Mockito]");
-            addOrderedList(lines, unstubbedCalls);
-        }
-        return join("", lines);
-    }
-
-    private void addOrderedList(List<String> target, List<String> additions) {
-        for (String a : additions) {
-            target.add("[Mockito] " + a);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java b/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java
deleted file mode 100644
index 00e278af4f..0000000000
--- a/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-import static java.util.Arrays.asList;
-
-import java.util.List;
-
-import org.mockito.MockitoDebugger;
-import org.mockito.internal.invocation.UnusedStubsFinder;
-import org.mockito.internal.invocation.finder.AllInvocationsFinder;
-import org.mockito.invocation.Invocation;
-
-public class MockitoDebuggerImpl implements MockitoDebugger {
-
-    private final UnusedStubsFinder unusedStubsFinder = new UnusedStubsFinder();
-
-    /**
-     * TODO: when MockitoDebugger is deleted, delete this implementation, too
-     */
-    @Deprecated
-    public String printInvocations(Object ... mocks) {
-        String out = "";
-        List<Invocation> invocations = AllInvocationsFinder.find(asList(mocks));
-        out += line("********************************");
-        out += line("*** Mockito interactions log ***");
-        out += line("********************************");
-        for(Invocation i:invocations) {
-            out += line(i.toString());
-            out += line(" invoked: " + i.getLocation());
-            if (i.stubInfo() != null) {
-                out += line(" stubbed: " + i.stubInfo().stubbedAt().toString());
-            }
-        }
-
-        invocations = unusedStubsFinder.find(asList(mocks));
-        if (invocations.isEmpty()) {
-            return print(out);
-        }
-        out += line("********************************");
-        out += line("***       Unused stubs       ***");
-        out += line("********************************");
-
-        for(Invocation i:invocations) {
-            out += line(i.toString());
-            out += line(" stubbed: " + i.getLocation());
-        }
-        return print(out);
-    }
-
-    private String line(String text) {
-        return text + "\n";
-    }
-
-    private String print(String out) {
-        System.out.println(out);
-        return out;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java b/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
deleted file mode 100644
index b4f63de0d4..0000000000
--- a/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-import java.io.PrintStream;
-
-import org.mockito.invocation.DescribedInvocation;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.MethodInvocationReport;
-
-/**
- * Logs all invocations to standard output.
- *
- * Used for debugging interactions with a mock.
- */
-public class VerboseMockInvocationLogger implements InvocationListener {
-
-    // visible for testing
-    final PrintStream printStream;
-
-    private int mockInvocationsCounter = 0;
-
-    public VerboseMockInvocationLogger() {
-        this(System.out);
-    }
-
-    public VerboseMockInvocationLogger(PrintStream printStream) {
-        this.printStream = printStream;
-    }
-
-    public void reportInvocation(MethodInvocationReport methodInvocationReport) {
-        printHeader();
-        printStubInfo(methodInvocationReport);
-        printInvocation(methodInvocationReport.getInvocation());
-        printReturnedValueOrThrowable(methodInvocationReport);
-        printFooter();
-    }
-
-    private void printReturnedValueOrThrowable(MethodInvocationReport methodInvocationReport) {
-        if (methodInvocationReport.threwException()) {
-            String message = methodInvocationReport.getThrowable().getMessage() == null ? "" : " with message " + methodInvocationReport.getThrowable().getMessage();
-            printlnIndented("has thrown: " + methodInvocationReport.getThrowable().getClass() + message);
-        } else {
-            String type = (methodInvocationReport.getReturnedValue() == null) ? "" : " (" + methodInvocationReport.getReturnedValue().getClass().getName() + ")";
-            printlnIndented("has returned: \"" + methodInvocationReport.getReturnedValue() + "\"" + type);
-        }
-    }
-
-    private void printStubInfo(MethodInvocationReport methodInvocationReport) {
-        if (methodInvocationReport.getLocationOfStubbing() != null) {
-            printlnIndented("stubbed: " + methodInvocationReport.getLocationOfStubbing());
-        }
-    }
-
-    private void printHeader() {
-        mockInvocationsCounter++;
-        printStream.println("############ Logging method invocation #" + mockInvocationsCounter + " on mock/spy ########");
-    }
-
-    private void printInvocation(DescribedInvocation invocation) {
-        printStream.println(invocation.toString());
-//        printStream.println("Handling method call on a mock/spy.");
-        printlnIndented("invoked: " + invocation.getLocation().toString());
-    }
-
-    private void printFooter() {
-        printStream.println("");
-    }
-
-    private void printlnIndented(String message) {
-        printStream.println("   " + message);
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/debugging/WarningsCollector.java b/src/main/java/org/mockito/internal/debugging/WarningsCollector.java
deleted file mode 100644
index 369c55920e..0000000000
--- a/src/main/java/org/mockito/internal/debugging/WarningsCollector.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.invocation.UnusedStubsFinder;
-import org.mockito.internal.invocation.finder.AllInvocationsFinder;
-import org.mockito.invocation.Invocation;
-
-@Deprecated
-public class WarningsCollector {
-
-    private final List<Object> createdMocks;
-
-    public WarningsCollector() {
-        createdMocks = new LinkedList<Object>();
-    }
-
-    public String getWarnings() {
-        List<Invocation> unused = new UnusedStubsFinder().find(createdMocks);
-        List<Invocation> all = AllInvocationsFinder.find(createdMocks);
-        List<InvocationMatcher> allInvocationMatchers = InvocationMatcher.createFrom(all);
-
-        return new WarningsPrinterImpl(unused, allInvocationMatchers, false).print();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java
deleted file mode 100644
index ab94fd1551..0000000000
--- a/src/main/java/org/mockito/internal/exceptions/Reporter.java
+++ /dev/null
@@ -1,949 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.exceptions;
-
-import static org.mockito.internal.reporting.Pluralizer.pluralize;
-import static org.mockito.internal.reporting.Pluralizer.stubbings;
-import static org.mockito.internal.reporting.Pluralizer.were_exactly_x_interactions;
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-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;
-import org.mockito.exceptions.verification.TooFewActualInvocations;
-import org.mockito.exceptions.verification.TooManyActualInvocations;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.exceptions.util.ScenarioPrinter;
-import org.mockito.internal.junit.ExceptionFactory;
-import org.mockito.internal.matchers.LocalizedMatcher;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.invocation.DescribedInvocation;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.invocation.Location;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.mock.SerializableMode;
-
-/**
- * Reports verification and misusing errors.
- * <p>
- * One of the key points of mocking library is proper verification/exception
- * messages. All messages in one place makes it easier to tune and amend them.
- * <p>
- * Reporter can be injected and therefore is easily testable.
- * <p>
- * Generally, exception messages are full of line breaks to make them easy to
- * read (xunit plugins take only fraction of screen on modern IDEs).
- */
-public class Reporter {
-
-    private final static String NON_PUBLIC_PARENT = "Mocking methods declared on non-public parent classes is not supported.";
-
-    private Reporter() {
-    }
-
-    public static MockitoException checkedExceptionInvalid(Throwable t) {
-        return new MockitoException(join(
-                "Checked exception is invalid for this method!",
-                "Invalid: " + t
-        ));
-    }
-
-    public static MockitoException cannotStubWithNullThrowable() {
-        return new MockitoException(join(
-                "Cannot stub with null throwable!"
-        ));
-
-    }
-
-    public static MockitoException unfinishedStubbing(Location location) {
-        return new UnfinishedStubbingException(join(
-                "Unfinished stubbing detected here:",
-                location,
-                "",
-                "E.g. thenReturn() may be missing.",
-                "Examples of correct stubbing:",
-                "    when(mock.isOk()).thenReturn(true);",
-                "    when(mock.isOk()).thenThrow(exception);",
-                "    doThrow(exception).when(mock).someVoidMethod();",
-                "Hints:",
-                " 1. missing thenReturn()",
-                " 2. you are trying to stub a final method, which is not supported",
-                " 3. you are stubbing the behaviour of another mock inside before 'thenReturn' instruction is completed",
-                ""
-        ));
-    }
-
-    public static MockitoException incorrectUseOfApi() {
-        return new MockitoException(join(
-                "Incorrect use of API detected here:",
-                new LocationImpl(),
-                "",
-                "You probably stored a reference to OngoingStubbing returned by when() and called stubbing methods like thenReturn() on this reference more than once.",
-                "Examples of correct usage:",
-                "    when(mock.isOk()).thenReturn(true).thenReturn(false).thenThrow(exception);",
-                "    when(mock.isOk()).thenReturn(true, false).thenThrow(exception);",
-                ""
-        ));
-    }
-
-    public static MockitoException missingMethodInvocation() {
-        return new MissingMethodInvocationException(join(
-                "when() requires an argument which has to be 'a method call on a mock'.",
-                "For example:",
-                "    when(mock.getArticles()).thenReturn(articles);",
-                "",
-                "Also, this error might show up because:",
-                "1. you stub either of: final/private/equals()/hashCode() methods.",
-                "   Those methods *cannot* be stubbed/verified.",
-                "   " + NON_PUBLIC_PARENT,
-                "2. inside when() you don't call method on mock but on some other object.",
-                ""
-        ));
-    }
-
-    public static MockitoException unfinishedVerificationException(Location location) {
-        return new UnfinishedVerificationException(join(
-                "Missing method call for verify(mock) here:",
-                location,
-                "",
-                "Example of correct verification:",
-                "    verify(mock).doSomething()",
-                "",
-                "Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.",
-                "Those methods *cannot* be stubbed/verified.",
-                NON_PUBLIC_PARENT,
-                ""
-        ));
-    }
-
-    public static MockitoException notAMockPassedToVerify(Class<?> type) {
-        return new NotAMockException(join(
-                "Argument passed to verify() is of type " + type.getSimpleName() + " and is not a mock!",
-                "Make sure you place the parenthesis correctly!",
-                "See the examples of correct verifications:",
-                "    verify(mock).someMethod();",
-                "    verify(mock, times(10)).someMethod();",
-                "    verify(mock, atLeastOnce()).someMethod();"
-        ));
-    }
-
-    public static MockitoException nullPassedToVerify() {
-        return new NullInsteadOfMockException(join(
-                "Argument passed to verify() should be a mock but is null!",
-                "Examples of correct verifications:",
-                "    verify(mock).someMethod();",
-                "    verify(mock, times(10)).someMethod();",
-                "    verify(mock, atLeastOnce()).someMethod();",
-                "    not: verify(mock.someMethod());",
-                "Also, if you use @Mock annotation don't miss initMocks()"
-        ));
-    }
-
-    public static MockitoException notAMockPassedToWhenMethod() {
-        return new NotAMockException(join(
-                "Argument passed to when() is not a mock!",
-                "Example of correct stubbing:",
-                "    doThrow(new RuntimeException()).when(mock).someMethod();"
-        ));
-    }
-
-    public static MockitoException nullPassedToWhenMethod() {
-        return new NullInsteadOfMockException(join(
-                "Argument passed to when() is null!",
-                "Example of correct stubbing:",
-                "    doThrow(new RuntimeException()).when(mock).someMethod();",
-                "Also, if you use @Mock annotation don't miss initMocks()"
-        ));
-    }
-
-    public static MockitoException mocksHaveToBePassedToVerifyNoMoreInteractions() {
-        return new MockitoException(join(
-                "Method requires argument(s)!",
-                "Pass mocks that should be verified, e.g:",
-                "    verifyNoMoreInteractions(mockOne, mockTwo);",
-                "    verifyNoInteractions(mockOne, mockTwo);",
-                ""
-        ));
-    }
-
-    public static MockitoException notAMockPassedToVerifyNoMoreInteractions() {
-        return new NotAMockException(join(
-                "Argument(s) passed is not a mock!",
-                "Examples of correct verifications:",
-                "    verifyNoMoreInteractions(mockOne, mockTwo);",
-                "    verifyNoInteractions(mockOne, mockTwo);",
-                ""
-        ));
-    }
-
-    public static MockitoException nullPassedToVerifyNoMoreInteractions() {
-        return new NullInsteadOfMockException(join(
-                "Argument(s) passed is null!",
-                "Examples of correct verifications:",
-                "    verifyNoMoreInteractions(mockOne, mockTwo);",
-                "    verifyNoInteractions(mockOne, mockTwo);"
-        ));
-    }
-
-    public static MockitoException notAMockPassedWhenCreatingInOrder() {
-        return new NotAMockException(join(
-                "Argument(s) passed is not a mock!",
-                "Pass mocks that require verification in order.",
-                "For example:",
-                "    InOrder inOrder = inOrder(mockOne, mockTwo);"
-        ));
-    }
-
-    public static MockitoException nullPassedWhenCreatingInOrder() {
-        return new NullInsteadOfMockException(join(
-                "Argument(s) passed is null!",
-                "Pass mocks that require verification in order.",
-                "For example:",
-                "    InOrder inOrder = inOrder(mockOne, mockTwo);"
-        ));
-    }
-
-    public static MockitoException mocksHaveToBePassedWhenCreatingInOrder() {
-        return new MockitoException(join(
-                "Method requires argument(s)!",
-                "Pass mocks that require verification in order.",
-                "For example:",
-                "    InOrder inOrder = inOrder(mockOne, mockTwo);"
-        ));
-    }
-
-    public static MockitoException inOrderRequiresFamiliarMock() {
-        return new MockitoException(join(
-                "InOrder can only verify mocks that were passed in during creation of InOrder.",
-                "For example:",
-                "    InOrder inOrder = inOrder(mockOne);",
-                "    inOrder.verify(mockOne).doStuff();"
-        ));
-    }
-
-    public static MockitoException invalidUseOfMatchers(int expectedMatchersCount, List<LocalizedMatcher> recordedMatchers) {
-        return new InvalidUseOfMatchersException(join(
-                "Invalid use of argument matchers!",
-                expectedMatchersCount + " matchers expected, " + recordedMatchers.size() + " recorded:" +
-                        locationsOf(recordedMatchers),
-                "",
-                "This exception may occur if matchers are combined with raw values:",
-                "    //incorrect:",
-                "    someMethod(anyObject(), \"raw String\");",
-                "When using matchers, all arguments have to be provided by matchers.",
-                "For example:",
-                "    //correct:",
-                "    someMethod(anyObject(), eq(\"String by matcher\"));",
-                "",
-                "For more info see javadoc for Matchers class.",
-                ""
-        ));
-    }
-
-    public static MockitoException incorrectUseOfAdditionalMatchers(String additionalMatcherName, int expectedSubMatchersCount, Collection<LocalizedMatcher> matcherStack) {
-        return new InvalidUseOfMatchersException(join(
-                "Invalid use of argument matchers inside additional matcher " + additionalMatcherName + " !",
-                new LocationImpl(),
-                "",
-                expectedSubMatchersCount + " sub matchers expected, " + matcherStack.size() + " recorded:",
-                locationsOf(matcherStack),
-                "",
-                "This exception may occur if matchers are combined with raw values:",
-                "    //incorrect:",
-                "    someMethod(AdditionalMatchers.and(isNotNull(), \"raw String\");",
-                "When using matchers, all arguments have to be provided by matchers.",
-                "For example:",
-                "    //correct:",
-                "    someMethod(AdditionalMatchers.and(isNotNull(), eq(\"raw String\"));",
-                "",
-                "For more info see javadoc for Matchers and AdditionalMatchers classes.",
-                ""
-        ));
-    }
-
-    public static MockitoException stubPassedToVerify(Object mock) {
-        return new CannotVerifyStubOnlyMock(join(
-                "Argument \"" + MockUtil.getMockName(mock) + "\" passed to verify is a stubOnly() mock which cannot be verified.",
-                "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings."
-        ));
-    }
-
-    public static MockitoException reportNoSubMatchersFound(String additionalMatcherName) {
-        return new InvalidUseOfMatchersException(join(
-                "No matchers found for additional matcher " + additionalMatcherName,
-                new LocationImpl(),
-                ""
-        ));
-    }
-
-
-    private static Object locationsOf(Collection<LocalizedMatcher> matchers) {
-        List<String> description = new ArrayList<String>();
-        for (LocalizedMatcher matcher : matchers)
-            description.add(matcher.getLocation().toString());
-        return join(description.toArray());
-    }
-
-    public static AssertionError argumentsAreDifferent(String wanted, List<String> actualCalls, List<Location> actualLocations) {
-        if (actualCalls == null || actualLocations == null || actualCalls.size() != actualLocations.size()) {
-            throw new IllegalArgumentException("actualCalls and actualLocations list must match");
-        }
-
-
-        StringBuilder actualBuilder = new StringBuilder();
-        StringBuilder messageBuilder = new StringBuilder();
-        messageBuilder.append("\n")
-            .append("Argument(s) are different! Wanted:\n")
-            .append(wanted)
-            .append("\n")
-            .append(new LocationImpl())
-            .append("\n")
-            .append("Actual invocations have different arguments:\n");
-
-        for (int i = 0; i < actualCalls.size(); i++) {
-            actualBuilder.append(actualCalls.get(i))
-                .append("\n");
-
-            messageBuilder.append(actualCalls.get(i))
-                .append("\n")
-                .append(actualLocations.get(i))
-                .append("\n");
-        }
-
-        return ExceptionFactory.createArgumentsAreDifferentException(messageBuilder.toString(), wanted, actualBuilder.toString());
-    }
-
-    public static MockitoAssertionError wantedButNotInvoked(DescribedInvocation wanted) {
-        return new WantedButNotInvoked(createWantedButNotInvokedMessage(wanted));
-    }
-
-    public static MockitoAssertionError wantedButNotInvoked(DescribedInvocation wanted, List<? extends DescribedInvocation> invocations) {
-        String allInvocations;
-        if (invocations.isEmpty()) {
-            allInvocations = "Actually, there were zero interactions with this mock.\n";
-        } else {
-            StringBuilder sb = new StringBuilder(
-                    "\nHowever, there " + were_exactly_x_interactions(invocations.size()) + " with this mock:\n");
-            for (DescribedInvocation i : invocations) {
-                sb.append(i.toString())
-                  .append("\n")
-                  .append(i.getLocation())
-                  .append("\n\n");
-            }
-            allInvocations = sb.toString();
-        }
-
-        String message = createWantedButNotInvokedMessage(wanted);
-        return new WantedButNotInvoked(message + allInvocations);
-    }
-
-    private static String createWantedButNotInvokedMessage(DescribedInvocation wanted) {
-        return join(
-                "Wanted but not invoked:",
-                wanted.toString(),
-                new LocationImpl(),
-                ""
-        );
-    }
-
-    public static MockitoAssertionError wantedButNotInvokedInOrder(DescribedInvocation wanted, DescribedInvocation previous) {
-        return new VerificationInOrderFailure(join(
-                "Verification in order failure",
-                "Wanted but not invoked:",
-                wanted.toString(),
-                new LocationImpl(),
-                "Wanted anywhere AFTER following interaction:",
-                previous.toString(),
-                previous.getLocation(),
-                ""
-        ));
-    }
-
-    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,
-                                                          List<Location> invocations) {
-        return join(
-                wanted.toString(),
-                "Wanted " + pluralize(wantedCount) + ":",
-                new LocationImpl(),
-                "But was " + pluralize(actualCount) + ":",
-                createAllLocationsMessage(invocations),
-                ""
-        );
-    }
-
-    public static MockitoAssertionError neverWantedButInvoked(DescribedInvocation wanted, List<Location> invocations) {
-        return new NeverWantedButInvoked(join(
-                wanted.toString(),
-                "Never wanted here:",
-                new LocationImpl(),
-                "But invoked here:",
-                createAllLocationsMessage(invocations)
-        ));
-    }
-
-    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 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 createTooFewInvocationsMessage(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 ? "." : ":"),
-                createAllLocationsMessage(locations)
-        );
-    }
-
-    public static MockitoAssertionError tooFewActualInvocations(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, List<Location> allLocations) {
-        String message = createTooFewInvocationsMessage(discrepancy, wanted, allLocations);
-
-        return new TooFewActualInvocations(message);
-    }
-
-    public static MockitoAssertionError tooFewActualInvocationsInOrder(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, List<Location> locations) {
-        String message = createTooFewInvocationsMessage(discrepancy, wanted, locations);
-
-        return new VerificationInOrderFailure(join(
-                "Verification in order failure:" + message
-        ));
-    }
-
-    public static MockitoAssertionError noMoreInteractionsWanted(Invocation undesired, List<VerificationAwareInvocation> invocations) {
-        ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
-        String scenario = scenarioPrinter.print(invocations);
-
-        return new NoInteractionsWanted(join(
-                "No interactions wanted here:",
-                new LocationImpl(),
-                "But found this interaction on mock '" + MockUtil.getMockName(undesired.getMock()) + "':",
-                undesired.getLocation(),
-                scenario
-        ));
-    }
-
-    public static MockitoAssertionError noMoreInteractionsWantedInOrder(Invocation undesired) {
-        return new VerificationInOrderFailure(join(
-                "No interactions wanted here:",
-                new LocationImpl(),
-                "But found this interaction on mock '" + MockUtil.getMockName(undesired.getMock()) + "':",
-                undesired.getLocation()
-        ));
-    }
-
-    public static MockitoAssertionError noInteractionsWanted(Object mock, List<VerificationAwareInvocation> invocations) {
-        ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
-        String scenario = scenarioPrinter.print(invocations);
-
-        List<Location> locations = new ArrayList<Location>();
-        for (VerificationAwareInvocation invocation : invocations) {
-            locations.add(invocation.getLocation());
-        }
-        return new NoInteractionsWanted(join(
-            "No interactions wanted here:",
-            new LocationImpl(),
-            "But found these interactions on mock '" + MockUtil.getMockName(mock) + "':",
-            join("", locations),
-            scenario
-        ));
-    }
-
-    public static MockitoException cannotMockClass(Class<?> clazz, String reason) {
-        return new MockitoException(join(
-                "Cannot mock/spy " + clazz.toString(),
-                "Mockito cannot mock/spy because :",
-                " - " + reason
-        ));
-    }
-
-    public static MockitoException cannotStubVoidMethodWithAReturnValue(String methodName) {
-        return new CannotStubVoidMethodWithReturnValue(join(
-                "'" + methodName + "' is a *void method* and it *cannot* be stubbed with a *return value*!",
-                "Voids are usually stubbed with Throwables:",
-                "    doThrow(exception).when(mock).someVoidMethod();",
-                "If you need to set the void method to do nothing you can use:",
-                "    doNothing().when(mock).someVoidMethod();",
-                "For more information, check out the javadocs for Mockito.doNothing().",
-                "***",
-                "If you're unsure why you're getting above error read on.",
-                "Due to the nature of the syntax above problem might occur because:",
-                "1. The method you are trying to stub is *overloaded*. Make sure you are calling the right overloaded version.",
-                "2. Somewhere in your test you are stubbing *final methods*. Sorry, Mockito does not verify/stub final methods.",
-                "3. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
-                "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
-                "4. " + NON_PUBLIC_PARENT,
-                ""
-        ));
-    }
-
-    public static MockitoException onlyVoidMethodsCanBeSetToDoNothing() {
-        return new MockitoException(join(
-                "Only void methods can doNothing()!",
-                "Example of correct use of doNothing():",
-                "    doNothing().",
-                "    doThrow(new RuntimeException())",
-                "    .when(mock).someVoidMethod();",
-                "Above means:",
-                "someVoidMethod() does nothing the 1st time but throws an exception the 2nd time is called"
-        ));
-    }
-
-    public static MockitoException wrongTypeOfReturnValue(String expectedType, String actualType, String methodName) {
-        return new WrongTypeOfReturnValue(join(
-                actualType + " cannot be returned by " + methodName + "()",
-                methodName + "() should return " + expectedType,
-                "***",
-                "If you're unsure why you're getting above error read on.",
-                "Due to the nature of the syntax above problem might occur because:",
-                "1. This exception *might* occur in wrongly written multi-threaded tests.",
-                "   Please refer to Mockito FAQ on limitations of concurrency testing.",
-                "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
-                "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
-                ""
-        ));
-    }
-
-    public static MockitoException wrongTypeReturnedByDefaultAnswer(Object mock, String expectedType, String actualType, String methodName) {
-        return new WrongTypeOfReturnValue(join(
-                "Default answer returned a result with the wrong type:",
-                actualType + " cannot be returned by " + methodName + "()",
-                methodName + "() should return " + expectedType,
-                "",
-                "The default answer of " + MockUtil.getMockName(mock) + " that was configured on the mock is probably incorrectly implemented.",
-                ""
-        ));
-    }
-
-    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) {
-        return new InvalidUseOfMatchersException(join(
-                "Misplaced or misused argument matcher detected here:",
-                locationsOf(lastMatchers),
-                "",
-                "You cannot use argument matchers outside of verification or stubbing.",
-                "Examples of correct usage of argument matchers:",
-                "    when(mock.get(anyInt())).thenReturn(null);",
-                "    doThrow(new RuntimeException()).when(mock).someVoidMethod(anyObject());",
-                "    verify(mock).someMethod(contains(\"foo\"))",
-                "",
-                "This message may appear after an NullPointerException if the last matcher is returning an object ",
-                "like any() but the stubbed method signature expect a primitive argument, in this case,",
-                "use primitive alternatives.",
-                "    when(mock.get(any())); // bad use, will raise NPE",
-                "    when(mock.get(anyInt())); // correct usage use",
-                "",
-                "Also, this error might show up because you use argument matchers with methods that cannot be mocked.",
-                "Following methods *cannot* be stubbed/verified: final/private/equals()/hashCode().",
-                NON_PUBLIC_PARENT,
-                ""
-        ));
-    }
-
-    public static MockitoException smartNullPointerException(String invocation, Location location) {
-        return new SmartNullPointerException(join(
-                "You have a NullPointerException here:",
-                new LocationImpl(),
-                "because this method call was *not* stubbed correctly:",
-                location,
-                invocation,
-                ""
-        ));
-    }
-
-    public static MockitoException noArgumentValueWasCaptured() {
-        return new MockitoException(join(
-                "No argument value was captured!",
-                "You might have forgotten to use argument.capture() in verify()...",
-                "...or you used capture() in stubbing but stubbed method was not called.",
-                "Be aware that it is recommended to use capture() only with verify()",
-                "",
-                "Examples of correct argument capturing:",
-                "    ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);",
-                "    verify(mock).doSomething(argument.capture());",
-                "    assertEquals(\"John\", argument.getValue().getName());",
-                ""
-        ));
-    }
-
-    public static MockitoException extraInterfacesDoesNotAcceptNullParameters() {
-        return new MockitoException(join(
-                "extraInterfaces() does not accept null parameters."
-        ));
-    }
-
-    public static MockitoException extraInterfacesAcceptsOnlyInterfaces(Class<?> wrongType) {
-        return new MockitoException(join(
-                "extraInterfaces() accepts only interfaces.",
-                "You passed following type: " + wrongType.getSimpleName() + " which is not an interface."
-        ));
-    }
-
-    public static MockitoException extraInterfacesCannotContainMockedType(Class<?> wrongType) {
-        return new MockitoException(join(
-                "extraInterfaces() does not accept the same type as the mocked type.",
-                "You mocked following type: " + wrongType.getSimpleName(),
-                "and you passed the same very interface to the extraInterfaces()"
-        ));
-    }
-
-    public static MockitoException extraInterfacesRequiresAtLeastOneInterface() {
-        return new MockitoException(join(
-                "extraInterfaces() requires at least one interface."
-        ));
-    }
-
-    public static MockitoException mockedTypeIsInconsistentWithSpiedInstanceType(Class<?> mockedType, Object spiedInstance) {
-        return new MockitoException(join(
-                "Mocked type must be the same as the type of your spied instance.",
-                "Mocked type must be: " + spiedInstance.getClass().getSimpleName() + ", but is: " + mockedType.getSimpleName(),
-                "  //correct spying:",
-                "  spy = mock( ->ArrayList.class<- , withSettings().spiedInstance( ->new ArrayList()<- );",
-                "  //incorrect - types don't match:",
-                "  spy = mock( ->List.class<- , withSettings().spiedInstance( ->new ArrayList()<- );"
-        ));
-    }
-
-    public static MockitoException cannotCallAbstractRealMethod() {
-        return new MockitoException(join(
-                "Cannot call abstract real method on java object!",
-                "Calling real methods is only possible when mocking non abstract method.",
-                "  //correct example:",
-                "  when(mockOfConcreteClass.nonAbstractMethod()).thenCallRealMethod();"
-        ));
-    }
-
-    public static MockitoException cannotVerifyToString() {
-        return new MockitoException(join(
-                "Mockito cannot verify toString()",
-                "toString() is too often used behind of scenes  (i.e. during String concatenation, in IDE debugging views). " +
-                        "Verifying it may give inconsistent or hard to understand results. " +
-                        "Not to mention that verifying toString() most likely hints awkward design (hard to explain in a short exception message. Trust me...)",
-                "However, it is possible to stub toString(). Stubbing toString() smells a bit funny but there are rare, legitimate use cases."
-        ));
-    }
-
-    public static MockitoException moreThanOneAnnotationNotAllowed(String fieldName) {
-        return new MockitoException("You cannot have more than one Mockito annotation on a field!\n" +
-                                            "The field '" + fieldName + "' has multiple Mockito annotations.\n" +
-                                            "For info how to use annotations see examples in javadoc for MockitoAnnotations class.");
-    }
-
-    public static MockitoException unsupportedCombinationOfAnnotations(String undesiredAnnotationOne, String undesiredAnnotationTwo) {
-        return new MockitoException("This combination of annotations is not permitted on a single field:\n" +
-                                            "@" + undesiredAnnotationOne + " and @" + undesiredAnnotationTwo);
-    }
-
-    public static MockitoException cannotInitializeForSpyAnnotation(String fieldName, Exception details) {
-        return new MockitoException(join("Cannot instantiate a @Spy for '" + fieldName + "' field.",
-                                         "You haven't provided the instance for spying at field declaration so I tried to construct the instance.",
-                                         "However, I failed because: " + details.getMessage(),
-                                         "Examples of correct usage of @Spy:",
-                                         "   @Spy List mock = new LinkedList();",
-                                         "   @Spy Foo foo; //only if Foo has parameterless constructor",
-                                         "   //also, don't forget about MockitoAnnotations.initMocks();",
-                                         ""), details);
-    }
-
-    public static MockitoException cannotInitializeForInjectMocksAnnotation(String fieldName, String causeMessage) {
-        return new MockitoException(join("Cannot instantiate @InjectMocks field named '" + fieldName + "'! Cause: "+causeMessage,
-                                         "You haven't provided the instance at field declaration so I tried to construct the instance.",
-                                         "Examples of correct usage of @InjectMocks:",
-                                         "   @InjectMocks Service service = new Service();",
-                                         "   @InjectMocks Service service;",
-                                         "   //and... don't forget about some @Mocks for injection :)",
-                                         ""));
-    }
-
-    public static MockitoException atMostAndNeverShouldNotBeUsedWithTimeout() {
-        return new FriendlyReminderException(join("",
-                                                  "Don't panic! I'm just a friendly reminder!",
-                                                  "timeout() should not be used with atMost() or never() because...",
-                                                  "...it does not make much sense - the test would have passed immediately in concurrency",
-                                                  "We kept this method only to avoid compilation errors when upgrading Mockito.",
-                                                  "In future release we will remove timeout(x).atMost(y) from the API.",
-                                                  "If you want to find out more please refer to issue 235",
-                                                  ""));
-    }
-
-    public static MockitoException fieldInitialisationThrewException(Field field, Throwable details) {
-        return new InjectMocksException(join(
-                "Cannot instantiate @InjectMocks field named '" + field.getName() + "' of type '" + field.getType() + "'.",
-                "You haven't provided the instance at field declaration so I tried to construct the instance.",
-                "However the constructor or the initialization block threw an exception : " + details.getMessage(),
-                ""), details);
-
-    }
-
-    public static MockitoException methodDoesNotAcceptParameter(String method, String parameter) {
-        return new MockitoException(method + "() does not accept " + parameter + " See the Javadoc.");
-    }
-
-    public static MockitoException requiresAtLeastOneListener(String method) {
-        return new MockitoException(method + "() requires at least one listener");
-    }
-
-    public static MockitoException invocationListenerThrewException(InvocationListener listener, Throwable listenerThrowable) {
-        return new MockitoException(join(
-                "The invocation listener with type " + listener.getClass().getName(),
-                "threw an exception : " + listenerThrowable.getClass().getName() + listenerThrowable.getMessage()), listenerThrowable);
-    }
-
-    public static MockitoException cannotInjectDependency(Field field, Object matchingMock, Exception details) {
-        return new MockitoException(join(
-                "Mockito couldn't inject mock dependency '" + MockUtil.getMockName(matchingMock) + "' on field ",
-                "'" + field + "'",
-                "whose type '" + field.getDeclaringClass().getCanonicalName() + "' was annotated by @InjectMocks in your test.",
-                "Also I failed because: " + exceptionCauseMessageIfAvailable(details),
-                ""
-        ), details);
-    }
-
-    private static String exceptionCauseMessageIfAvailable(Exception details) {
-        if (details.getCause() == null) {
-            return details.getMessage();
-        }
-        return details.getCause().getMessage();
-    }
-
-    public static MockitoException mockedTypeIsInconsistentWithDelegatedInstanceType(Class<?> mockedType, Object delegatedInstance) {
-        return new MockitoException(join(
-                "Mocked type must be the same as the type of your delegated instance.",
-                "Mocked type must be: " + delegatedInstance.getClass().getSimpleName() + ", but is: " + mockedType.getSimpleName(),
-                "  //correct delegate:",
-                "  spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new ArrayList()<- );",
-                "  //incorrect - types don't match:",
-                "  spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new HashSet()<- );"
-        ));
-    }
-
-    public static MockitoException spyAndDelegateAreMutuallyExclusive() {
-        return new MockitoException(join(
-                "Settings should not define a spy instance and a delegated instance at the same time."
-        ));
-    }
-
-    public static MockitoException invalidArgumentRangeAtIdentityAnswerCreationTime() {
-        return new MockitoException(join(
-                "Invalid argument index.",
-                "The index need to be a positive number that indicates the position of the argument to return.",
-                "However it is possible to use the -1 value to indicates that the last argument should be",
-                "returned."));
-    }
-
-    public static MockitoException invalidArgumentPositionRangeAtInvocationTime(InvocationOnMock invocation, boolean willReturnLastParameter, int argumentIndex) {
-        return new MockitoException(join(
-                "Invalid argument index for the current invocation of method : ",
-                " -> " + MockUtil.getMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()",
-                "",
-                (willReturnLastParameter ?
-                        "Last parameter wanted" :
-                        "Wanted parameter at position " + argumentIndex) + " but " + possibleArgumentTypesOf(invocation),
-                "The index need to be a positive number that indicates a valid position of the argument in the invocation.",
-                "However it is possible to use the -1 value to indicates that the last argument should be returned.",
-                ""
-        ));
-    }
-
-    private static StringBuilder possibleArgumentTypesOf(InvocationOnMock invocation) {
-        Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
-        if (parameterTypes.length == 0) {
-            return new StringBuilder("the method has no arguments.\n");
-        }
-
-        StringBuilder stringBuilder = new StringBuilder("the possible argument indexes for this method are :\n");
-        for (int i = 0, parameterTypesLength = parameterTypes.length; i < parameterTypesLength; i++) {
-            stringBuilder.append("    [").append(i);
-
-            if (invocation.getMethod().isVarArgs() && i == parameterTypesLength - 1) {
-                stringBuilder.append("+] ").append(parameterTypes[i].getComponentType().getSimpleName()).append("  <- Vararg").append("\n");
-            } else {
-                stringBuilder.append("] ").append(parameterTypes[i].getSimpleName()).append("\n");
-            }
-        }
-        return stringBuilder;
-    }
-
-    public static MockitoException wrongTypeOfArgumentToReturn(InvocationOnMock invocation, String expectedType, Class<?> actualType, int argumentIndex) {
-        return new WrongTypeOfReturnValue(join(
-                "The argument of type '" + actualType.getSimpleName() + "' cannot be returned because the following ",
-                "method should return the type '" + expectedType + "'",
-                " -> " + MockUtil.getMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()",
-                "",
-                "The reason for this error can be :",
-                "1. The wanted argument position is incorrect.",
-                "2. The answer is used on the wrong interaction.",
-                "",
-                "Position of the wanted argument is " + argumentIndex + " and " + possibleArgumentTypesOf(invocation),
-                "***",
-                "However if you're still unsure why you're getting above error read on.",
-                "Due to the nature of the syntax above problem might occur because:",
-                "1. This exception *might* occur in wrongly written multi-threaded tests.",
-                "   Please refer to Mockito FAQ on limitations of concurrency testing.",
-                "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
-                "   - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
-                ""
-        ));
-    }
-
-    public static MockitoException defaultAnswerDoesNotAcceptNullParameter() {
-        return new MockitoException("defaultAnswer() does not accept null parameter");
-    }
-
-    public static MockitoException serializableWontWorkForObjectsThatDontImplementSerializable(Class<?> classToMock) {
-        return new MockitoException(join(
-                "You are using the setting 'withSettings().serializable()' however the type you are trying to mock '" + classToMock.getSimpleName() + "'",
-                "do not implement Serializable AND do not have a no-arg constructor.",
-                "This combination is requested, otherwise you will get an 'java.io.InvalidClassException' when the mock will be serialized",
-                "",
-                "Also note that as requested by the Java serialization specification, the whole hierarchy need to implements Serializable,",
-                "i.e. the top-most superclass has to implements Serializable.",
-                ""
-        ));
-    }
-
-    public static MockitoException delegatedMethodHasWrongReturnType(Method mockMethod, Method delegateMethod, Object mock, Object delegate) {
-        return new MockitoException(join(
-                "Methods called on delegated instance must have compatible return types with the mock.",
-                "When calling: " + mockMethod + " on mock: " + MockUtil.getMockName(mock),
-                "return type should be: " + mockMethod.getReturnType().getSimpleName() + ", but was: " + delegateMethod.getReturnType().getSimpleName(),
-                "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
-                "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")"
-        ));
-    }
-
-    public static MockitoException delegatedMethodDoesNotExistOnDelegate(Method mockMethod, Object mock, Object delegate) {
-        return new MockitoException(join(
-                "Methods called on mock must exist in delegated instance.",
-                "When calling: " + mockMethod + " on mock: " + MockUtil.getMockName(mock),
-                "no such method was found.",
-                "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
-                "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")"
-        ));
-    }
-
-    public static MockitoException usingConstructorWithFancySerializable(SerializableMode mode) {
-        return new MockitoException("Mocks instantiated with constructor cannot be combined with " + mode + " serialization mode.");
-    }
-
-    public static MockitoException cannotCreateTimerWithNegativeDurationTime(long durationMillis) {
-        return new FriendlyReminderException(join(
-                "",
-                "Don't panic! I'm just a friendly reminder!",
-                "It is impossible for time to go backward, therefore...",
-                "You cannot put negative value of duration: (" + durationMillis + ")",
-                "as argument of timer methods (after(), timeout())",
-                ""
-        ));
-    }
-
-    public static MockitoException notAnException() {
-        return new MockitoException(join(
-                "Exception type cannot be null.",
-                "This may happen with doThrow(Class)|thenThrow(Class) family of methods if passing null parameter."));
-    }
-
-    public static UnnecessaryStubbingException formatUnncessaryStubbingException(Class<?> testClass, Collection<Invocation> unnecessaryStubbings) {
-        StringBuilder stubbings = new StringBuilder();
-        int count = 0;
-        for (Invocation u : unnecessaryStubbings) {
-            stubbings.append("\n  ").append(++count).append(". ").append(u.getLocation());
-        }
-        String heading = (testClass != null)?
-                "Unnecessary stubbings detected in test class: " + testClass.getSimpleName() :
-                "Unnecessary stubbings detected.";
-
-        return new UnnecessaryStubbingException(join(
-                heading,
-                "Clean & maintainable test code requires zero unnecessary code.",
-                "There are " + count + " unnecessary " + stubbings(count) + " (click to navigate to relevant line of code):" + stubbings,
-                "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."
-        ));
-    }
-
-    public static void unncessaryStubbingException(List<Invocation> unused) {
-        throw formatUnncessaryStubbingException(null, unused);
-    }
-
-    public static void potentialStubbingProblem(
-            Invocation actualInvocation, Collection<Invocation> argMismatchStubbings) {
-        StringBuilder stubbings = new StringBuilder();
-        int count = 1;
-        for (Invocation s : argMismatchStubbings) {
-            stubbings.append("    ").append(count++).append(". ").append(s);
-            stubbings.append("\n      ").append(s.getLocation()).append("\n");
-        }
-        stubbings.deleteCharAt(stubbings.length()-1); //remove trailing end of line
-
-        throw new PotentialStubbingProblem(join(
-                "Strict stubbing argument mismatch. Please check:",
-                " - this invocation of '" + actualInvocation.getMethod().getName() + "' method:",
-                "    " + actualInvocation,
-                "    " + actualInvocation.getLocation(),
-                " - has following stubbing(s) with different arguments:",
-                stubbings,
-                "Typically, stubbing argument mismatch indicates user mistake when writing tests.",
-                "Mockito fails early so that you can debug potential problem easily.",
-                "However, there are legit scenarios when this exception generates false negative signal:",
-                "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API",
-                "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.",
-                "  - stubbed method is intentionally invoked with different arguments by code under test",
-                "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).",
-                "For more information see javadoc for PotentialStubbingProblem class."));
-    }
-
-    public static void redundantMockitoListener(String listenerType) {
-        throw new RedundantListenerException(join(
-            "Problems adding Mockito listener.",
-            "Listener of type '" + listenerType + "' has already been added and not removed.",
-            "It indicates that previous listener was not removed according to the API.",
-            "When you add a listener, don't forget to remove the listener afterwards:",
-            "  Mockito.framework().removeListener(myListener);",
-            "For more information, see the javadoc for RedundantListenerException class."));
-    }
-
-    public static void unfinishedMockingSession() {
-        throw new UnfinishedMockingSessionException(join(
-                "Unfinished mocking session detected.",
-                "Previous MockitoSession was not concluded with 'finishMocking()'.",
-                "For examples of correct usage see javadoc for MockitoSession class."));
-    }
-}
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java b/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
deleted file mode 100644
index 6f7b956ed3..0000000000
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.exceptions.stacktrace;
-
-import org.mockito.exceptions.stacktrace.StackTraceCleaner;
-
-/**
- * This predicate is used to filter "good" {@link StackTraceElement}. Good
- */
-public class DefaultStackTraceCleaner implements StackTraceCleaner {
-
-    @Override
-    public boolean isIn(StackTraceElement e) {
-        if (isFromMockitoRunner(e.getClassName()) || isFromMockitoRule(e.getClassName())) {
-            return true;
-        } else if (isMockDispatcher(e.getClassName()) || isFromMockito(e.getClassName())) {
-            return false;
-        } else {
-            return true;
-        }
-    }
-
-    private static boolean isMockDispatcher(String className) {
-        return (className.contains("$$EnhancerByMockitoWithCGLIB$$") || className.contains("$MockitoMock$"));
-    }
-
-    private static boolean isFromMockito(String className) {
-        return className.startsWith("org.mockito.");
-    }
-
-    private static boolean isFromMockitoRule(String className) {
-        return className.startsWith("org.mockito.internal.junit.JUnitRule");
-    }
-
-    private static boolean isFromMockitoRunner(String className) {
-        return className.startsWith("org.mockito.internal.runners.")
-               || className.startsWith("org.mockito.runners.")
-               || className.startsWith("org.mockito.junit.");
-    }
-}
diff --git a/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java b/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
deleted file mode 100644
index 9c07658866..0000000000
--- a/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.framework;
-
-import java.util.List;
-
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.MockitoSession;
-import org.mockito.exceptions.misusing.RedundantListenerException;
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.internal.junit.TestFinishedEvent;
-import org.mockito.internal.junit.UniversalTestListener;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.quality.Strictness;
-
-public class DefaultMockitoSession implements MockitoSession {
-
-    private final String name;
-    private final UniversalTestListener listener;
-
-    public DefaultMockitoSession(List<Object> testClassInstances, String name, Strictness strictness, MockitoLogger logger) {
-        this.name = name;
-        listener = new UniversalTestListener(strictness, logger);
-        try {
-            //So that the listener can capture mock creation events
-            Mockito.framework().addListener(listener);
-        } catch (RedundantListenerException e) {
-            Reporter.unfinishedMockingSession();
-        }
-        try {
-            for (Object testClassInstance : testClassInstances) {
-                MockitoAnnotations.initMocks(testClassInstance);
-            }
-        } catch (RuntimeException e) {
-            //clean up in case 'initMocks' fails
-            listener.setListenerDirty();
-            throw e;
-        }
-    }
-
-    @Override
-    public void setStrictness(Strictness strictness) {
-        listener.setStrictness(strictness);
-    }
-
-    @Override
-    public void finishMocking() {
-        finishMocking(null);
-    }
-
-    @Override
-    public void finishMocking(final Throwable failure) {
-        //Cleaning up the state, we no longer need the listener hooked up
-        //The listener implements MockCreationListener and at this point
-        //we no longer need to listen on mock creation events. We are wrapping up the session
-        Mockito.framework().removeListener(listener);
-
-        //Emit test finished event so that validation such as strict stubbing can take place
-        listener.testFinished(new TestFinishedEvent() {
-            @Override
-            public Throwable getFailure() {
-                return failure;
-            }
-            @Override
-            public String getTestName() {
-                return name;
-            }
-        });
-
-        //Validate only when there is no test failure to avoid reporting multiple problems
-        if (failure == null) {
-            //Finally, validate user's misuse of Mockito framework.
-            Mockito.validateMockitoUsage();
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java b/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
deleted file mode 100644
index 5183136ae7..0000000000
--- a/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.hamcrest;
-
-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> {
-
-    private final Matcher matcher;
-
-    public HamcrestArgumentMatcher(Matcher<T> matcher) {
-        this.matcher = matcher;
-    }
-
-    public boolean matches(Object argument) {
-        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 toString()
-        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
deleted file mode 100644
index c0438cd5aa..0000000000
--- a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.handler;
-
-import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.invocation.MatchersBinder;
-import org.mockito.internal.stubbing.InvocationContainerImpl;
-import org.mockito.internal.stubbing.OngoingStubbingImpl;
-import org.mockito.internal.stubbing.StubbedInvocationMatcher;
-import org.mockito.internal.stubbing.answers.DefaultAnswerValidator;
-import org.mockito.internal.verification.MockAwareVerificationMode;
-import org.mockito.internal.verification.VerificationDataImpl;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationContainer;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.verification.VerificationMode;
-
-/**
- * Invocation handler set on mock objects.
- *
- * @param <T> type of mock object to handle
- */
-public class MockHandlerImpl<T> implements MockHandler<T> {
-
-    private static final long serialVersionUID = -2917871070982574165L;
-
-    InvocationContainerImpl invocationContainer;
-
-    MatchersBinder matchersBinder = new MatchersBinder();
-
-    private final MockCreationSettings<T> mockSettings;
-
-    public MockHandlerImpl(MockCreationSettings<T> mockSettings) {
-        this.mockSettings = mockSettings;
-
-        this.matchersBinder = new MatchersBinder();
-        this.invocationContainer = new InvocationContainerImpl(mockSettings);
-    }
-
-    public Object handle(Invocation invocation) throws Throwable {
-        if (invocationContainer.hasAnswersForStubbing()) {
-            // stubbing voids with doThrow() or doAnswer() style
-            InvocationMatcher invocationMatcher = matchersBinder.bindMatchers(
-                    mockingProgress().getArgumentMatcherStorage(),
-                    invocation
-            );
-            invocationContainer.setMethodForStubbing(invocationMatcher);
-            return null;
-        }
-        VerificationMode verificationMode = mockingProgress().pullVerificationMode();
-
-        InvocationMatcher invocationMatcher = matchersBinder.bindMatchers(
-                mockingProgress().getArgumentMatcherStorage(),
-                invocation
-        );
-
-        mockingProgress().validateState();
-
-        // if verificationMode is not null then someone is doing verify()
-        if (verificationMode != null) {
-            // We need to check if verification was started on the correct mock
-            // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
-            if (((MockAwareVerificationMode) verificationMode).getMock() == invocation.getMock()) {
-                VerificationDataImpl data = new VerificationDataImpl(invocationContainer, invocationMatcher);
-                verificationMode.verify(data);
-                return null;
-            } else {
-                // this means there is an invocation on a different mock. Re-adding verification mode
-                // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
-                mockingProgress().verificationStarted(verificationMode);
-            }
-        }
-
-        // prepare invocation for stubbing
-        invocationContainer.setInvocationForPotentialStubbing(invocationMatcher);
-        OngoingStubbingImpl<T> ongoingStubbing = new OngoingStubbingImpl<T>(invocationContainer);
-        mockingProgress().reportOngoingStubbing(ongoingStubbing);
-
-        // look for existing answer for this invocation
-        StubbedInvocationMatcher stubbing = invocationContainer.findAnswerFor(invocation);
-        // 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);
-
-            try {
-                return stubbing.answer(invocation);
-            } finally {
-                //Needed so that we correctly isolate stubbings in some scenarios
-                //see MockitoStubbedCallInAnswerTest or issue #1279
-                mockingProgress().reportOngoingStubbing(ongoingStubbing);
-            }
-        } else {
-            Object ret = mockSettings.getDefaultAnswer().answer(invocation);
-            DefaultAnswerValidator.validateReturnValueFor(invocation, ret);
-
-            //Mockito uses it to redo setting invocation for potential stubbing in case of partial mocks / spies.
-            //Without it, the real method inside 'when' might have delegated to other self method
-            //and overwrite the intended stubbed method with a different one.
-            //This means we would be stubbing a wrong method.
-            //Typically this would led to runtime exception that validates return type with stubbed method signature.
-            invocationContainer.resetInvocationForPotentialStubbing(invocationMatcher);
-            return ret;
-        }
-    }
-
-    public MockCreationSettings<T> getMockSettings() {
-        return mockSettings;
-    }
-
-    public InvocationContainer getInvocationContainer() {
-        return invocationContainer;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java b/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
deleted file mode 100644
index 46236d04af..0000000000
--- a/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-
-import org.mockito.internal.creation.DelegatingMethod;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.invocation.mockref.MockWeakReference;
-import org.mockito.internal.progress.SequenceNumber;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationFactory;
-import org.mockito.invocation.Location;
-import org.mockito.mock.MockCreationSettings;
-
-public class DefaultInvocationFactory implements InvocationFactory {
-
-    public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, final Callable realMethod, Object... args) {
-        RealMethod superMethod = new RealMethod.FromCallable(realMethod);
-        return createInvocation(target, settings, method, superMethod, args);
-    }
-
-    public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethodBehavior realMethod, Object... args) {
-        RealMethod superMethod = new RealMethod.FromBehavior(realMethod);
-        return createInvocation(target, settings, method, superMethod, args);
-    }
-
-    private Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethod superMethod, Object[] args) {
-        return createInvocation(target, method, args, superMethod, settings);
-    }
-
-    public static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod, MockCreationSettings settings, Location location) {
-        return new InterceptedInvocation(
-            new MockWeakReference<Object>(mock),
-            createMockitoMethod(invokedMethod, settings),
-            arguments,
-            realMethod,
-            location,
-            SequenceNumber.next()
-        );
-    }
-
-    private static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[]
-        arguments, RealMethod realMethod, MockCreationSettings settings) {
-        return createInvocation(mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
-    }
-
-    private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
-        if (settings.isSerializable()) {
-            return new SerializableMethod(method);
-        } else {
-            return new DelegatingMethod(method);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
deleted file mode 100644
index 75002c74da..0000000000
--- a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MatchableInvocation;
-
-public class InvocationsFinder {
-
-    private InvocationsFinder() {
-    }
-
-    public static List<Invocation> findInvocations(List<Invocation> invocations, MatchableInvocation wanted) {
-        return ListUtil.filter(invocations, new RemoveNotMatching(wanted));
-    }
-
-    public static List<Invocation> findAllMatchingUnverifiedChunks(List<Invocation> invocations, MatchableInvocation wanted, InOrderContext orderingContext) {
-        List<Invocation> unverified = removeVerifiedInOrder(invocations, orderingContext);
-        return ListUtil.filter(unverified, new RemoveNotMatching(wanted));
-    }
-
-    /**
-     * some examples how it works:
-     *
-     * Given invocations sequence:
-     * 1,1,2,1
-     *
-     * if wanted is 1 and mode is times(2) then returns
-     * 1,1
-     *
-     * if wanted is 1 and mode is atLeast() then returns
-     * 1,1,1
-     *
-     * if wanted is 1 and mode is times(x), where x != 2 then returns
-     * 1,1,1
-     */
-    public static List<Invocation> findMatchingChunk(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount, InOrderContext context) {
-        List<Invocation> unverified = removeVerifiedInOrder(invocations, context);
-        List<Invocation> firstChunk = getFirstMatchingChunk(wanted, unverified);
-
-        if (wantedCount != firstChunk.size()) {
-            return findAllMatchingUnverifiedChunks(invocations, wanted, context);
-        } else {
-            return firstChunk;
-        }
-    }
-
-    private static List<Invocation> getFirstMatchingChunk(MatchableInvocation wanted, List<Invocation> unverified) {
-        List<Invocation> firstChunk = new LinkedList<Invocation>();
-        for (Invocation invocation : unverified) {
-            if (wanted.matches(invocation)) {
-                firstChunk.add(invocation);
-            } else if (!firstChunk.isEmpty()) {
-                break;
-            }
-        }
-        return firstChunk;
-    }
-
-    public static Invocation findFirstMatchingUnverifiedInvocation(List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context ){
-        for( Invocation invocation : removeVerifiedInOrder( invocations, context )){
-            if( wanted.matches( invocation )){
-                return invocation;
-            }
-        }
-        return null;
-    }
-
-    public static Invocation findSimilarInvocation(List<Invocation> invocations, MatchableInvocation wanted) {
-        Invocation firstSimilar = null;
-        for (Invocation invocation : invocations) {
-            if (!wanted.hasSimilarMethod(invocation)) {
-                continue;
-            }
-            if (firstSimilar == null) {
-                firstSimilar = invocation;
-            }
-            if (wanted.hasSameMethod(invocation)) {
-                return invocation;
-            }
-        }
-
-        return firstSimilar;
-    }
-
-    public static Invocation findFirstUnverified(List<Invocation> invocations) {
-        return findFirstUnverified(invocations, null);
-    }
-
-    static Invocation findFirstUnverified(List<Invocation> invocations, Object mock) {
-        for (Invocation i : invocations) {
-            boolean mockIsValid = mock == null || mock == i.getMock();
-            if (!i.isVerified() && mockIsValid) {
-                return i;
-            }
-        }
-        return null;
-    }
-
-    public static Location getLastLocation(List<Invocation> invocations) {
-        if (invocations.isEmpty()) {
-            return null;
-        } else {
-            Invocation last = invocations.get(invocations.size() - 1);
-            return last.getLocation();
-        }
-    }
-
-    public static Invocation findPreviousVerifiedInOrder(List<Invocation> invocations, InOrderContext context) {
-        LinkedList<Invocation> verifiedOnly = ListUtil.filter(invocations, new RemoveUnverifiedInOrder(context));
-
-        if (verifiedOnly.isEmpty()) {
-            return null;
-        } else {
-            return verifiedOnly.getLast();
-        }
-    }
-
-    private static List<Invocation> removeVerifiedInOrder(List<Invocation> invocations, InOrderContext orderingContext) {
-        List<Invocation> unverified = new LinkedList<Invocation>();
-        for (Invocation i : invocations) {
-            if (orderingContext.isVerified(i)) {
-                unverified.clear();
-            } else {
-                unverified.add(i);
-            }
-        }
-        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;
-
-        private RemoveNotMatching(MatchableInvocation wanted) {
-            this.wanted = wanted;
-        }
-
-        public boolean isOut(Invocation invocation) {
-            return !wanted.matches(invocation);
-        }
-    }
-
-    private static class RemoveUnverifiedInOrder implements Filter<Invocation> {
-        private final InOrderContext orderingContext;
-
-        public RemoveUnverifiedInOrder(InOrderContext orderingContext) {
-            this.orderingContext = orderingContext;
-        }
-
-        public boolean isOut(Invocation invocation) {
-            return !orderingContext.isVerified(invocation);
-        }
-    }
-
-    /**
-     * i3 is unverified here:
-     *
-     * i1, i2, i3
-     *     v
-     *
-     * all good here:
-     *
-     * i1, i2, i3
-     *     v   v
-     *
-     * @param context
-     * @param orderedInvocations
-     */
-    public static Invocation findFirstUnverifiedInOrder(InOrderContext context, List<Invocation> orderedInvocations) {
-        Invocation candidate = null;
-        for(Invocation i : orderedInvocations) {
-            if (!context.isVerified(i)) {
-                candidate = candidate != null ? candidate : i;
-            } else {
-                candidate = null;
-            }
-        }
-        return candidate;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java b/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
deleted file mode 100644
index e47156f07f..0000000000
--- a/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import static org.mockito.internal.invocation.MatcherApplicationStrategy.MatcherApplicationType.ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS;
-import static org.mockito.internal.invocation.MatcherApplicationStrategy.MatcherApplicationType.MATCH_EACH_VARARGS_WITH_LAST_MATCHER;
-import static org.mockito.internal.invocation.MatcherApplicationStrategy.MatcherApplicationType.ONE_MATCHER_PER_ARGUMENT;
-
-import java.util.ArrayList;
-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;
-
-public class MatcherApplicationStrategy {
-
-    private final Invocation invocation;
-    private final List<ArgumentMatcher<?>> matchers;
-    private final MatcherApplicationType matchingType;
-
-
-
-    private MatcherApplicationStrategy(Invocation invocation, List<ArgumentMatcher<?>> matchers, MatcherApplicationType matchingType) {
-        this.invocation = invocation;
-        if (matchingType == MATCH_EACH_VARARGS_WITH_LAST_MATCHER) {
-            int times = varargLength(invocation);
-            this.matchers = appendLastMatcherNTimes(matchers, times);
-        } else {
-            this.matchers = matchers;
-        }
-
-        this.matchingType = matchingType;
-    }
-
-    /**
-     * Returns the {@link MatcherApplicationStrategy} that must be used to capture the
-     * arguments of the given <b>invocation</b> using the given <b>matchers</b>.
-     *
-     * @param invocation
-     *            that contain the arguments to capture
-     * @param matchers
-     *            that will be used to capture the arguments of the invocation,
-     *            the passed {@link List} is not required to contain a
-     *            {@link CapturingMatcher}
-     * @return never <code>null</code>
-     */
-    public static MatcherApplicationStrategy getMatcherApplicationStrategyFor(Invocation invocation, List<ArgumentMatcher<?>> matchers) {
-
-        MatcherApplicationType type = getMatcherApplicationType(invocation, matchers);
-        return new MatcherApplicationStrategy(invocation, matchers, type);
-    }
-
-    /**
-     * Applies the given {@link ArgumentMatcherAction} to all arguments and
-     * corresponding matchers
-     *
-     * @param action
-     *            must not be <code>null</code>
-     * @return
-     *         <ul>
-     *         <li><code>true</code> if the given <b>action</b> returned
-     *         <code>true</code> for all arguments and matchers passed to it.
-     *         <li><code>false</code> if the given <b>action</b> returned
-     *         <code>false</code> for one of the passed arguments and matchers
-     *         <li><code>false</code> if the given matchers don't fit to the given invocation
-     *         because too many or to few matchers are available.
-     *         </ul>
-     */
-    public boolean forEachMatcherAndArgument(ArgumentMatcherAction action) {
-        if (matchingType == ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS)
-            return false;
-
-        Object[] arguments = invocation.getArguments();
-        for (int i = 0; i < arguments.length; i++) {
-            ArgumentMatcher<?> matcher = matchers.get(i);
-            Object argument = arguments[i];
-
-            if (!action.apply(matcher, argument)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private static MatcherApplicationType getMatcherApplicationType(Invocation invocation, List<ArgumentMatcher<?>> matchers) {
-        final int rawArguments = invocation.getRawArguments().length;
-        final int expandedArguments = invocation.getArguments().length;
-        final int matcherCount = matchers.size();
-
-        if (expandedArguments == matcherCount) {
-            return ONE_MATCHER_PER_ARGUMENT;
-        }
-
-        if (rawArguments == matcherCount && isLastMatcherVarargMatcher(matchers)) {
-            return MATCH_EACH_VARARGS_WITH_LAST_MATCHER;
-        }
-
-        return ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS;
-    }
-
-    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) {
-        ArgumentMatcher<?> lastMatcher = lastMatcher(matchers);
-
-        List<ArgumentMatcher<?>> expandedMatchers = new ArrayList<ArgumentMatcher<?>>(matchers);
-        for (int i = 0; i < timesToAppendLastMatcher; i++) {
-            expandedMatchers.add(lastMatcher);
-        }
-        return expandedMatchers;
-    }
-
-    private static int varargLength(Invocation invocation) {
-        int rawArgumentCount = invocation.getRawArguments().length;
-        int expandedArgumentCount = invocation.getArguments().length;
-        return expandedArgumentCount - rawArgumentCount;
-    }
-
-    private static ArgumentMatcher<?> lastMatcher(List<ArgumentMatcher<?>> matchers) {
-        return matchers.get(matchers.size() - 1);
-    }
-
-    enum MatcherApplicationType {
-        ONE_MATCHER_PER_ARGUMENT, MATCH_EACH_VARARGS_WITH_LAST_MATCHER, ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/SerializableMethod.java b/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
deleted file mode 100644
index dfc3bc46d7..0000000000
--- a/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.SuspendMethod;
-
-public class SerializableMethod implements Serializable, MockitoMethod {
-
-    private static final long serialVersionUID = 6005610965006048445L;
-
-    private final Class<?> declaringClass;
-    private final String methodName;
-    private final Class<?>[] parameterTypes;
-    private final Class<?> returnType;
-    private final Class<?>[] exceptionTypes;
-    private final boolean isVarArgs;
-    private final boolean isAbstract;
-
-    private volatile transient Method method;
-
-    public SerializableMethod(Method method) {
-        this.method = method;
-        declaringClass = method.getDeclaringClass();
-        methodName = method.getName();
-        parameterTypes = SuspendMethod.trimSuspendParameterTypes(method.getParameterTypes());
-        returnType = method.getReturnType();
-        exceptionTypes = method.getExceptionTypes();
-        isVarArgs = method.isVarArgs();
-        isAbstract = (method.getModifiers() & Modifier.ABSTRACT) != 0;
-    }
-
-    public String getName() {
-        return methodName;
-    }
-
-    public Class<?> getReturnType() {
-        return returnType;
-    }
-
-    public Class<?>[] getParameterTypes() {
-        return parameterTypes;
-    }
-
-    public Class<?>[] getExceptionTypes() {
-        return exceptionTypes;
-    }
-
-    public boolean isVarArgs() {
-        return isVarArgs;
-    }
-
-    public boolean isAbstract() {
-        return isAbstract;
-    }
-
-    public Method getJavaMethod() {
-        if (method != null) {
-            return method;
-        }
-        try {
-            method = declaringClass.getDeclaredMethod(methodName, parameterTypes);
-            return method;
-        } catch (SecurityException e) {
-            String message = String.format(
-                    "The method %1$s.%2$s is probably private or protected and cannot be mocked.\n" +
-                            "Please report this as a defect with an example of how to reproduce it.", declaringClass, methodName);
-            throw new MockitoException(message, e);
-        } catch (NoSuchMethodException e) {
-            String message = String.format(
-                    "The method %1$s.%2$s does not exists and you should not get to this point.\n" +
-                            "Please report this as a defect with an example of how to reproduce it.", declaringClass, methodName);
-            throw new MockitoException(message, e);
-        }
-    }
-
-    @Override
-    public int hashCode() {
-        return 1;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj)
-            return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
-            return false;
-        SerializableMethod other = (SerializableMethod) obj;
-        if (declaringClass == null) {
-            if (other.declaringClass != null)
-                return false;
-        } else if (!declaringClass.equals(other.declaringClass))
-            return false;
-        if (methodName == null) {
-            if (other.methodName != null)
-                return false;
-        } else if (!methodName.equals(other.methodName))
-            return false;
-        if (!Arrays.equals(parameterTypes, other.parameterTypes))
-            return false;
-        if (returnType == null) {
-            if (other.returnType != null)
-                return false;
-        } else if (!returnType.equals(other.returnType))
-            return false;
-        return true;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java b/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
deleted file mode 100644
index 1452137650..0000000000
--- a/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import java.lang.reflect.Method;
-
-import org.mockito.ArgumentMatcher;
-
-@SuppressWarnings({"unchecked","rawtypes"})
-public class TypeSafeMatching implements ArgumentMatcherAction {
-
-    private final static ArgumentMatcherAction TYPE_SAFE_MATCHING_ACTION = new TypeSafeMatching();
-
-    private TypeSafeMatching() {}
-
-
-    public static ArgumentMatcherAction matchesTypeSafe(){
-        return TYPE_SAFE_MATCHING_ACTION;
-    }
-    @Override
-    public boolean apply(ArgumentMatcher matcher, Object argument) {
-        return isCompatible(matcher, argument) && matcher.matches(argument);
-    }
-
-
-    /**
-     * Returns <code>true</code> if the given <b>argument</b> can be passed to
-     * the given <code>argumentMatcher</code> without causing a
-     * {@link ClassCastException}.
-     */
-    private static boolean isCompatible(ArgumentMatcher<?> argumentMatcher, Object argument) {
-        if (argument == null)
-            return true;
-
-        Class<?> expectedArgumentType = getArgumentType(argumentMatcher);
-
-        return expectedArgumentType.isInstance(argument);
-    }
-
-    /**
-     * Returns the type of {@link ArgumentMatcher#matches(Object)} of the given
-     * {@link ArgumentMatcher} implementation.
-     */
-    private static Class<?> getArgumentType(ArgumentMatcher<?> argumentMatcher) {
-        Method[] methods = argumentMatcher.getClass().getMethods();
-
-        for (Method method : methods) {
-            if (isMatchesMethod(method)) {
-                return method.getParameterTypes()[0];
-            }
-        }
-        throw new NoSuchMethodError("Method 'matches(T)' not found in ArgumentMatcher: " + argumentMatcher + " !\r\n Please file a bug with this stack trace at: https://github.com/mockito/mockito/issues/new ");
-    }
-
-    /**
-     * Returns <code>true</code> if the given method is
-     * {@link ArgumentMatcher#matches(Object)}
-     */
-    private static boolean isMatchesMethod(Method method) {
-        if (method.getParameterTypes().length != 1) {
-            return false;
-        }
-        if (method.isBridge()) {
-            return false;
-        }
-        return "matches".equals(method.getName());
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java b/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
deleted file mode 100644
index 3f8803f86d..0000000000
--- a/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.util.MockUtil;
-import org.mockito.invocation.Invocation;
-import org.mockito.stubbing.Stubbing;
-
-@Deprecated
-public class UnusedStubsFinder {
-
-    /**
-     * Finds all unused stubs for given mocks
-     *
-     * @param mocks full list of mocks
-     */
-    public List<Invocation> find(List<?> mocks) {
-        List<Invocation> unused = new LinkedList<Invocation>();
-        for (Object mock : mocks) {
-            List<Stubbing> fromSingleMock = MockUtil.getInvocationContainer(mock).getStubbingsDescending();
-            for(Stubbing s : fromSingleMock) {
-                if (!s.wasUsed()) {
-                     unused.add(s.getInvocation());
-                }
-            }
-        }
-        return unused;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
deleted file mode 100644
index 91bb69a6e7..0000000000
--- a/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation.finder;
-
-import java.util.*;
-
-import org.mockito.internal.invocation.InvocationComparator;
-import org.mockito.internal.stubbing.StubbingComparator;
-import org.mockito.internal.util.DefaultMockingDetails;
-import org.mockito.invocation.Invocation;
-import org.mockito.stubbing.Stubbing;
-
-public class AllInvocationsFinder {
-
-    private AllInvocationsFinder() {}
-
-    /**
-     * gets all invocations from mocks. Invocations are ordered earlier first.
-     *
-     * @param mocks mocks
-     * @return invocations
-     */
-    public static List<Invocation> find(Iterable<?> mocks) {
-        Set<Invocation> invocationsInOrder = new TreeSet<Invocation>(new InvocationComparator());
-        for (Object mock : mocks) {
-            Collection<Invocation> fromSingleMock = new DefaultMockingDetails(mock).getInvocations();
-            invocationsInOrder.addAll(fromSingleMock);
-        }
-
-        return new LinkedList<Invocation>(invocationsInOrder);
-    }
-
-    /**
-     * Gets all stubbings from mocks. Invocations are ordered earlier first.
-     *
-     * @param mocks mocks
-     * @return stubbings
-     */
-    public static Set<Stubbing> findStubbings(Iterable<?> mocks) {
-        Set<Stubbing> stubbings = new TreeSet<Stubbing>(new StubbingComparator());
-        for (Object mock : mocks) {
-            Collection<? extends Stubbing> fromSingleMock = new DefaultMockingDetails(mock).getStubbings();
-            stubbings.addAll(fromSingleMock);
-        }
-
-        return stubbings;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
deleted file mode 100644
index e3a4677c0b..0000000000
--- a/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation.finder;
-
-import java.util.List;
-
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-import org.mockito.invocation.Invocation;
-
-/**
- * Author: Szczepan Faber, created at: 4/3/11
- */
-public class VerifiableInvocationsFinder {
-
-    private VerifiableInvocationsFinder() {}
-
-    public static List<Invocation> find(List<?> mocks) {
-        List<Invocation> invocations = AllInvocationsFinder.find(mocks);
-        return ListUtil.filter(invocations, new RemoveIgnoredForVerification());
-    }
-
-    private static class RemoveIgnoredForVerification implements Filter<Invocation>{
-        public boolean isOut(Invocation invocation) {
-            return invocation.isIgnoredForVerification();
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
deleted file mode 100644
index ed7cf8d8b4..0000000000
--- a/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation.mockref;
-
-import java.io.ObjectStreamException;
-import java.lang.ref.WeakReference;
-
-/**
- * A weak reference that is converted into a strong reference when serialized.
- * See {@link MockReference}.
- */
-public class MockWeakReference<T> implements MockReference<T> {
-
-    private final WeakReference<T> ref;
-
-    public MockWeakReference(T t) {
-        this.ref = new WeakReference<T>(t);
-    }
-
-    private Object writeReplace() throws ObjectStreamException {
-        return new MockStrongReference<T>(get(), true);
-    }
-
-    @Override
-    public T get() {
-        T ref = this.ref.get();
-
-        if (ref == null) {
-            throw new IllegalStateException("The mock object was garbage collected. " +
-                "This should not happen in normal circumstances when using public API. " +
-                "Typically, the test class keeps strong reference to the mock object " +
-                "and it prevents getting the mock collected. Mockito internally needs " +
-                "to keep weak references to mock objects to avoid memory leaks for " +
-                "certain types of MockMaker implementations. If you see this exception " +
-                "using Mockito public API, please file a bug. For more information see " +
-                "issue #1313.");
-        }
-
-        return ref;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java b/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
deleted file mode 100644
index e1de44545c..0000000000
--- a/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import org.mockito.internal.invocation.finder.AllInvocationsFinder;
-import org.mockito.invocation.Invocation;
-import org.mockito.stubbing.Stubbing;
-
-/**
- * For given mocks, finds stubbing arg mismatches
- */
-class ArgMismatchFinder {
-
-    StubbingArgMismatches getStubbingArgMismatches(Iterable<?> mocks) {
-        StubbingArgMismatches mismatches = new StubbingArgMismatches();
-        for (Invocation i : AllInvocationsFinder.find(mocks)) {
-            if (i.stubInfo() != null) {
-                continue;
-            }
-            for (Stubbing stubbing : AllInvocationsFinder.findStubbings(mocks)) {
-                //method name & mock matches
-                if (!stubbing.wasUsed() && stubbing.getInvocation().getMock() == i.getMock()
-                        && stubbing.getInvocation().getMethod().getName().equals(i.getMethod().getName())) {
-                    mismatches.add(i, stubbing.getInvocation());
-                }
-            }
-        }
-        return mismatches;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java b/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
deleted file mode 100644
index d5b6eed750..0000000000
--- a/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import static org.mockito.internal.stubbing.StrictnessSelector.determineStrictness;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.internal.stubbing.UnusedStubbingReporting;
-import org.mockito.invocation.Invocation;
-import org.mockito.listeners.StubbingLookupEvent;
-import org.mockito.listeners.StubbingLookupListener;
-import org.mockito.quality.Strictness;
-import org.mockito.stubbing.Stubbing;
-
-/**
- * Default implementation of stubbing lookup listener.
- * Fails early if stub called with unexpected arguments, but only if current strictness is set to STRICT_STUBS.
- */
-class DefaultStubbingLookupListener implements StubbingLookupListener, Serializable {
-
-    private static final long serialVersionUID = -6789800638070123629L;
-
-    private Strictness currentStrictness;
-    private boolean mismatchesReported;
-
-    DefaultStubbingLookupListener(Strictness strictness) {
-        this.currentStrictness = strictness;
-    }
-
-    public void onStubbingLookup(StubbingLookupEvent event) {
-        Strictness actualStrictness = determineStrictness(event.getStubbingFound(), event.getMockSettings(), currentStrictness);
-
-        if (actualStrictness != Strictness.STRICT_STUBS) {
-            return;
-        }
-
-        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(event.getInvocation(), event.getAllStubbings());
-            if (!argMismatchStubbings.isEmpty()) {
-                mismatchesReported = true;
-                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)
-            event.getInvocation().markVerified();
-        }
-    }
-
-    private static List<Invocation> potentialArgMismatches(Invocation invocation, Collection<Stubbing> stubbings) {
-        List<Invocation> matchingStubbings = new LinkedList<Invocation>();
-        for (Stubbing s : stubbings) {
-            if (UnusedStubbingReporting.shouldBeReported(s)
-                && s.getInvocation().getMethod().getName().equals(invocation.getMethod().getName())
-                //If stubbing and invocation are in the same source file we assume they are in the test code,
-                // and we don't flag it as mismatch:
-                && !s.getInvocation().getLocation().getSourceFile().equals(invocation.getLocation().getSourceFile())) {
-                    matchingStubbings.add(s.getInvocation());
-            }
-        }
-        return matchingStubbings;
-    }
-
-    /**
-     * Enables resetting the strictness to desired level
-     */
-    void setCurrentStrictness(Strictness currentStrictness) {
-        this.currentStrictness = currentStrictness;
-    }
-
-    /**
-     * Indicates that stubbing argument mismatch was reported
-     */
-    boolean isMismatchesReported() {
-        return mismatchesReported;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java b/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java
deleted file mode 100644
index 8fe4080af5..0000000000
--- a/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2020 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import org.junit.runners.model.Statement;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.MockitoSession;
-import org.mockito.internal.session.MockitoSessionLoggerAdapter;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.quality.Strictness;
-
-class JUnitSessionStore {
-
-  private final MockitoLogger logger;
-  private MockitoSession session;
-  protected Strictness strictness;
-
-  JUnitSessionStore(MockitoLogger logger, Strictness strictness) {
-    this.logger = logger;
-    this.strictness = strictness;
-  }
-
-  Statement createStatement(final Statement base, final String methodName, final Object target) {
-    return new Statement() {
-      public void evaluate() throws Throwable {
-        if (session == null) {
-          session =
-              Mockito.mockitoSession()
-                  .name(methodName)
-                  .strictness(strictness)
-                  .logger(new MockitoSessionLoggerAdapter(logger))
-                  .initMocks(target)
-                  .startMocking();
-        } else {
-          MockitoAnnotations.initMocks(target);
-        }
-        Throwable testFailure = evaluateSafely(base);
-        session.finishMocking(testFailure);
-        if (testFailure != null) {
-          throw testFailure;
-        }
-      }
-
-      private Throwable evaluateSafely(Statement base) {
-        try {
-          base.evaluate();
-          return null;
-        } catch (Throwable throwable) {
-          return throwable;
-        }
-      }
-    };
-  }
-
-  void setStrictness(Strictness strictness) {
-    this.strictness = strictness;
-    // session is null when this method is called during initialization of
-    // the @Rule field of the test class
-    if (session != null) {
-      session.setStrictness(strictness);
-    }
-  }
-
-}
diff --git a/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java b/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
deleted file mode 100644
index 9c496bbc28..0000000000
--- a/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.MockitoLogger;
-
-/**
- * Reports stubbing argument mismatches to the supplied logger
- */
-public class MismatchReportingTestListener implements MockitoTestListener {
-
-    private final MockitoLogger logger;
-    private List<Object> mocks = new LinkedList<Object>();
-
-    public MismatchReportingTestListener(MockitoLogger logger) {
-        this.logger = logger;
-    }
-
-    public void testFinished(TestFinishedEvent event) {
-        Collection<Object> createdMocks = mocks;
-        //At this point, we don't need the mocks any more and we can mark all collected mocks for gc
-        //TODO make it better, it's easy to forget to clean up mocks and we still create new instance of list that nobody will read, it's also duplicated
-        mocks = new LinkedList<Object>();
-
-        if (event.getFailure() != null) {
-            //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users
-            new ArgMismatchFinder().getStubbingArgMismatches(createdMocks).format(event.getTestName(), logger);
-        }
-    }
-
-    public void onMockCreated(Object mock, MockCreationSettings settings) {
-        this.mocks.add(mock);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java b/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
deleted file mode 100644
index d23431bae1..0000000000
--- a/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.quality.Strictness;
-
-/**
- * Fails early when mismatched arguments used for stubbing
- */
-public class StrictStubsRunnerTestListener implements MockitoTestListener {
-
-    private final DefaultStubbingLookupListener stubbingLookupListener = new DefaultStubbingLookupListener(Strictness.STRICT_STUBS);
-
-    @Override
-    public void testFinished(TestFinishedEvent event) {}
-
-    @Override
-    public void onMockCreated(Object mock, MockCreationSettings settings) {
-        //It is not ideal that we modify the state of MockCreationSettings object
-        //MockCreationSettings is intended to be an immutable view of the creation settings
-        //However, we our previous listeners work this way and it hasn't backfired.
-        //Since it is simple and pragmatic, we'll keep it for now.
-        settings.getStubbingLookupListeners().add(stubbingLookupListener);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/StubbingHint.java b/src/main/java/org/mockito/internal/junit/StubbingHint.java
deleted file mode 100644
index 3675a4d8a9..0000000000
--- a/src/main/java/org/mockito/internal/junit/StubbingHint.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-/**
- * Stubbing hint emitted to the user
- */
-class StubbingHint {
-
-    private final StringBuilder hint;
-
-    StubbingHint(String testName) {
-        hint = new StringBuilder("[MockitoHint] ")
-            .append(testName).append(" (see javadoc for MockitoHint):");
-    }
-
-    void appendLine(Object ... elements) {
-        hint.append("\n[MockitoHint] ");
-        for (Object e : elements) {
-            hint.append(e);
-        }
-    }
-
-    public String toString() {
-        return hint.toString() + "\n";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/UniversalTestListener.java b/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
deleted file mode 100644
index 6155c19a6a..0000000000
--- a/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import java.util.Collection;
-import java.util.IdentityHashMap;
-import java.util.Map;
-
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.listeners.AutoCleanableListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.quality.Strictness;
-
-/**
- * Universal test listener that behaves accordingly to current setting of strictness.
- * Will come handy when we offer tweaking strictness at the method level with annotation.
- * Should be relatively easy to improve and offer tweaking strictness per mock.
- */
-public class UniversalTestListener implements MockitoTestListener, AutoCleanableListener {
-
-    private Strictness currentStrictness;
-    private final MockitoLogger logger;
-
-    private Map<Object, MockCreationSettings> mocks = new IdentityHashMap<Object, MockCreationSettings>();
-    private DefaultStubbingLookupListener stubbingLookupListener;
-    private boolean listenerDirty;
-
-    public UniversalTestListener(Strictness initialStrictness, MockitoLogger logger) {
-        this.currentStrictness = initialStrictness;
-        this.logger = logger;
-
-        //creating single stubbing lookup listener per junit rule instance / test method
-        //this way, when strictness is updated in the middle of the test it will affect the behavior of the stubbing listener
-        this.stubbingLookupListener = new DefaultStubbingLookupListener(currentStrictness);
-    }
-
-    @Override
-    public void testFinished(TestFinishedEvent event) {
-        Collection<Object> createdMocks = mocks.keySet();
-        //At this point, we don't need the mocks any more and we can mark all collected mocks for gc
-        //TODO make it better, it's easy to forget to clean up mocks and we still create new instance of list that nobody will read, it's also duplicated
-        //TODO clean up all other state, null out stubbingLookupListener
-        mocks = new IdentityHashMap<Object, MockCreationSettings>();
-
-        switch (currentStrictness) {
-            case WARN: emitWarnings(logger, event, createdMocks); break;
-            case STRICT_STUBS: reportUnusedStubs(event, createdMocks); break;
-            case LENIENT: break;
-            default: throw new IllegalStateException("Unknown strictness: " + currentStrictness);
-        }
-    }
-
-    private void reportUnusedStubs(TestFinishedEvent event, Collection<Object> mocks) {
-        //If there is some other failure (or mismatches were detected) don't report another exception to avoid confusion
-        if (event.getFailure() == null && !stubbingLookupListener.isMismatchesReported()) {
-            UnusedStubbings unused = new UnusedStubbingsFinder().getUnusedStubbings(mocks);
-            unused.reportUnused();
-        }
-    }
-
-    private static void emitWarnings(MockitoLogger logger, TestFinishedEvent event, Collection<Object> mocks) {
-        if (event.getFailure() != null) {
-            //print stubbing mismatches only when there is a test failure
-            //to avoid false negatives. Give hint only when test fails.
-            new ArgMismatchFinder().getStubbingArgMismatches(mocks).format(event.getTestName(), logger);
-        } else {
-            //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users
-            new UnusedStubbingsFinder().getUnusedStubbings(mocks).format(event.getTestName(), logger);
-        }
-    }
-
-    @Override
-    public void onMockCreated(Object mock, MockCreationSettings settings) {
-        this.mocks.put(mock, settings);
-
-        //It is not ideal that we modify the state of MockCreationSettings object
-        //MockCreationSettings is intended to be an immutable view of the creation settings
-        //In future, we should start passing MockSettings object to the creation listener
-        //TODO #793 - when completed, we should be able to get rid of the CreationSettings casting below
-        ((CreationSettings) settings).getStubbingLookupListeners().add(stubbingLookupListener);
-    }
-
-    public void setStrictness(Strictness strictness) {
-        this.currentStrictness = strictness;
-        this.stubbingLookupListener.setCurrentStrictness(strictness);
-    }
-
-    /**
-     * See {@link AutoCleanableListener#isListenerDirty()}
-     */
-    @Override
-    public boolean isListenerDirty() {
-        return listenerDirty;
-    }
-
-    /**
-     * Marks listener as dirty, scheduled for cleanup when the next session starts
-     */
-    public void setListenerDirty() {
-        this.listenerDirty = true;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java b/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
deleted file mode 100644
index 764659373a..0000000000
--- a/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.junit.runner.Description;
-import org.junit.runner.notification.Failure;
-import org.junit.runner.notification.RunNotifier;
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.invocation.Invocation;
-import org.mockito.listeners.MockCreationListener;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * Reports unnecessary stubbings
- */
-public class UnnecessaryStubbingsReporter implements MockCreationListener {
-
-    private List<Object> mocks = new LinkedList<Object>();
-
-    public void validateUnusedStubs(Class<?> testClass, RunNotifier notifier) {
-        Collection<Invocation> unused = new UnusedStubbingsFinder().getUnusedStubbingsByLocation(mocks);
-        if (unused.isEmpty()) {
-            return; //whoa!!! All stubbings were used!
-        }
-
-        //Oups, there are unused stubbings
-        Description unnecessaryStubbings = Description.createTestDescription(testClass, "unnecessary Mockito stubbings");
-        notifier.fireTestFailure(new Failure(unnecessaryStubbings,
-                Reporter.formatUnncessaryStubbingException(testClass, unused)));
-    }
-
-    @Override
-    public void onMockCreated(Object mock, MockCreationSettings settings) {
-        mocks.add(mock);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
deleted file mode 100644
index c602b0771a..0000000000
--- a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import static org.mockito.internal.util.collections.ListUtil.filter;
-
-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 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;
-
-/**
- * Finds unused stubbings
- */
-public class UnusedStubbingsFinder {
-
-    /**
-     * 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 !UnusedStubbingReporting.shouldBeReported(s);
-            }
-        });
-
-        return new UnusedStubbings(unused);
-    }
-
-    /**
-     * Gets unused stubbings per location. This method is less accurate than {@link #getUnusedStubbings(Iterable)}.
-     * It considers that stubbings with the same location (e.g. ClassFile + line number) are the same.
-     * This is not completely accurate because a stubbing declared in a setup or constructor
-     * is created per each test method. Because those are different test methods,
-     * different mocks are created, different 'Invocation' instance is backing the 'Stubbing' instance.
-     * In certain scenarios (detecting unused stubbings by JUnit runner), we need this exact level of accuracy.
-     * Stubbing declared in constructor but realized in % of test methods is considered as 'used' stubbing.
-     * There are high level unit tests that demonstrate this scenario.
-     */
-    public Collection<Invocation> getUnusedStubbingsByLocation(Iterable<Object> mocks) {
-        Set<Stubbing> stubbings = AllInvocationsFinder.findStubbings(mocks);
-
-        //1st pass, collect all the locations of the stubbings that were used
-        //note that those are _not_ locations where the stubbings was used
-        Set<String> locationsOfUsedStubbings = new HashSet<String>();
-        for (Stubbing s : stubbings) {
-            if (!UnusedStubbingReporting.shouldBeReported(s)) {
-                String location = s.getInvocation().getLocation().toString();
-                locationsOfUsedStubbings.add(location);
-            }
-        }
-
-        //2nd pass, collect unused stubbings by location
-        //If the location matches we assume the stubbing was used in at least one test method
-        //Also, using map to deduplicate reported unused stubbings
-        // if unused stubbing appear in the setup method / constructor we don't want to report it per each test case
-        Map<String, Invocation> out = new LinkedHashMap<String, Invocation>();
-        for (Stubbing s : stubbings) {
-            String location = s.getInvocation().getLocation().toString();
-            if (!locationsOfUsedStubbings.contains(location)) {
-                out.put(location, s.getInvocation());
-            }
-        }
-
-        return out.values();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java b/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
deleted file mode 100644
index e54d47864e..0000000000
--- a/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
-import org.junit.runner.Description;
-import org.junit.runners.model.Statement;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.internal.progress.MockingProgressImpl;
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.junit.VerificationCollector;
-import org.mockito.verification.VerificationMode;
-import org.mockito.verification.VerificationStrategy;
-
-/**
- * Mockito implementation of VerificationCollector.
- */
-public class VerificationCollectorImpl implements VerificationCollector {
-
-    private StringBuilder builder;
-    private int numberOfFailures;
-
-    public VerificationCollectorImpl() {
-        this.resetBuilder();
-    }
-
-    public Statement apply(final Statement base, final Description description) {
-        return new Statement() {
-            @Override
-            public void evaluate() throws Throwable {
-                try {
-                    VerificationCollectorImpl.this.assertLazily();
-                    base.evaluate();
-                    VerificationCollectorImpl.this.collectAndReport();
-                } finally {
-                    // If base.evaluate() throws an error, we must explicitly reset the VerificationStrategy
-                    // to prevent subsequent tests to be assert lazily
-                    mockingProgress().setVerificationStrategy(MockingProgressImpl.getDefaultVerificationStrategy());
-                }
-            }
-        };
-    }
-
-    public void collectAndReport() throws MockitoAssertionError {
-        mockingProgress().setVerificationStrategy(MockingProgressImpl.getDefaultVerificationStrategy());
-
-        if (this.numberOfFailures > 0) {
-            String error = this.builder.toString();
-
-            this.resetBuilder();
-
-            throw new MockitoAssertionError(error);
-        }
-    }
-
-    public VerificationCollector assertLazily() {
-        mockingProgress().setVerificationStrategy(new VerificationStrategy() {
-            public VerificationMode maybeVerifyLazily(VerificationMode mode) {
-                return new VerificationWrapper(mode);
-            }
-        });
-        return this;
-    }
-
-    private void resetBuilder() {
-        this.builder = new StringBuilder()
-                .append("There were multiple verification failures:");
-        this.numberOfFailures = 0;
-    }
-
-    private void append(String message) {
-        this.numberOfFailures++;
-        this.builder.append('\n')
-                .append(this.numberOfFailures).append(". ")
-                .append(message.trim()).append('\n');
-    }
-
-    private class VerificationWrapper implements VerificationMode {
-
-        private final VerificationMode delegate;
-
-        private VerificationWrapper(VerificationMode delegate) {
-            this.delegate = delegate;
-        }
-
-        public void verify(VerificationData data) {
-            try {
-                this.delegate.verify(data);
-            } catch (AssertionError error) {
-                VerificationCollectorImpl.this.append(error.getMessage());
-            }
-        }
-
-        public VerificationMode description(String description) {
-            throw new IllegalStateException("Should not fail in this mode");
-        }
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java b/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java
deleted file mode 100644
index fdeb1790d2..0000000000
--- a/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit.util;
-
-import java.lang.reflect.Field;
-
-import org.junit.runner.notification.Failure;
-import org.mockito.internal.exceptions.ExceptionIncludingMockitoWarnings;
-
-@Deprecated
-public class JUnitFailureHacker {
-
-    public void appendWarnings(Failure failure, String warnings) {
-        if (isEmpty(warnings)) {
-            return;
-        }
-        //TODO: this has to protect the use in case jUnit changes and this internal state logic fails
-        Throwable throwable = (Throwable) getInternalState(failure, "fThrownException");
-
-        String newMessage = "contains both: actual test failure *and* Mockito warnings.\n" +
-                warnings + "\n *** The actual failure is because of: ***\n";
-
-        ExceptionIncludingMockitoWarnings e = new ExceptionIncludingMockitoWarnings(newMessage, throwable);
-        e.setStackTrace(throwable.getStackTrace());
-        setInternalState(failure, "fThrownException", e);
-    }
-
-    private boolean isEmpty(String warnings) {
-        return warnings == null || "".equals(warnings); // isEmpty() is in JDK 6+
-    }
-
-    private static Object getInternalState(Object target, String field) {
-        Class<?> c = target.getClass();
-        try {
-            Field f = getFieldFromHierarchy(c, field);
-            f.setAccessible(true);
-            return f.get(target);
-        } catch (Exception e) {
-            throw new RuntimeException("Unable to get internal state on a private field. Please report to mockito mailing list.", e);
-        }
-    }
-
-    private static void setInternalState(Object target, String field, Object value) {
-        Class<?> c = target.getClass();
-        try {
-            Field f = getFieldFromHierarchy(c, field);
-            f.setAccessible(true);
-            f.set(target, value);
-        } catch (Exception e) {
-            throw new RuntimeException("Unable to set internal state on a private field. Please report to mockito mailing list.", e);
-        }
-    }
-
-    private static Field getFieldFromHierarchy(Class<?> clazz, String field) {
-        Field f = getField(clazz, field);
-        while (f == null && clazz != Object.class) {
-            clazz = clazz.getSuperclass();
-            f = getField(clazz, field);
-        }
-        if (f == null) {
-            throw new RuntimeException(
-                    "You want me to get this field: '" + field +
-                            "' on this class: '" + clazz.getSimpleName() +
-                            "' but this field is not declared within the hierarchy of this class!");
-        }
-        return f;
-    }
-
-    private static Field getField(Class<?> clazz, String field) {
-        try {
-            return clazz.getDeclaredField(field);
-        } catch (NoSuchFieldException e) {
-            return null;
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java b/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
deleted file mode 100644
index 0463164dfb..0000000000
--- a/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.listeners;
-
-import java.util.Collection;
-import java.util.List;
-
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.invocation.Invocation;
-import org.mockito.listeners.StubbingLookupEvent;
-import org.mockito.listeners.StubbingLookupListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.stubbing.Stubbing;
-
-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/listeners/VerificationStartedNotifier.java b/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
deleted file mode 100644
index 5703567eb3..0000000000
--- a/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.listeners;
-
-import java.util.List;
-import java.util.Set;
-
-import org.mockito.MockingDetails;
-import org.mockito.Mockito;
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.internal.matchers.text.ValuePrinter;
-import org.mockito.listeners.VerificationStartedEvent;
-import org.mockito.listeners.VerificationStartedListener;
-import org.mockito.mock.MockCreationSettings;
-
-public class VerificationStartedNotifier {
-
-    public static Object notifyVerificationStarted(List<VerificationStartedListener> listeners, MockingDetails originalMockingDetails) {
-        if (listeners.isEmpty()) {
-            return originalMockingDetails.getMock();
-        }
-        VerificationStartedEvent event = new Event(originalMockingDetails);
-        for (VerificationStartedListener listener : listeners) {
-            listener.onVerificationStarted(event);
-        }
-        return event.getMock();
-    }
-
-    static class Event implements VerificationStartedEvent {
-        private final MockingDetails originalMockingDetails;
-        private Object mock;
-
-        public Event(MockingDetails originalMockingDetails) {
-            this.originalMockingDetails = originalMockingDetails;
-            this.mock = originalMockingDetails.getMock();
-        }
-
-        public void setMock(Object mock) {
-            if (mock == null) {
-                throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock", "null parameter.");
-            }
-            MockingDetails mockingDetails = Mockito.mockingDetails(mock);
-            if (!mockingDetails.isMock()) {
-                throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock", "parameter which is not a Mockito mock.\n" +
-                    "  Received parameter: " + ValuePrinter.print(mock) + ".\n ");
-            }
-            MockCreationSettings originalMockSettings = this.originalMockingDetails.getMockCreationSettings();
-            assertCompatibleTypes(mock, originalMockSettings);
-            this.mock = mock;
-        }
-
-        public Object getMock() {
-            return mock;
-        }
-    }
-
-    static void assertCompatibleTypes(Object mock, MockCreationSettings originalSettings) {
-        Class originalType = originalSettings.getTypeToMock();
-        if (!originalType.isInstance(mock)) {
-            throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock",
-                "parameter which is not the same type as the original mock.\n" +
-                    "  Required type: " + originalType.getName() + "\n" +
-                    "  Received parameter: " + ValuePrinter.print(mock) + ".\n ");
-        }
-
-        for (Class iface : (Set<Class>) originalSettings.getExtraInterfaces()) {
-            if (!iface.isInstance(mock)) {
-                throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock",
-                    "parameter which does not implement all extra interfaces of the original mock.\n" +
-                        "  Required type: " + originalType.getName() + "\n" +
-                        "  Required extra interface: " + iface.getName() + "\n" +
-                        "  Received parameter: " + ValuePrinter.print(mock) + ".\n ");
-
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/And.java b/src/main/java/org/mockito/internal/matchers/And.java
deleted file mode 100644
index c27543edb0..0000000000
--- a/src/main/java/org/mockito/internal/matchers/And.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-
-@SuppressWarnings({ "unchecked", "serial","rawtypes" })
-public class And implements ArgumentMatcher<Object>, Serializable {
-    private ArgumentMatcher m1;
-    private ArgumentMatcher m2;
-
-    public And(ArgumentMatcher<?> m1, ArgumentMatcher<?> m2) {
-        this.m1 = m1;
-        this.m2 = m2;
-    }
-
-    public boolean matches(Object actual) {
-        return m1.matches(actual) && m2.matches(actual);
-    }
-
-    public String toString() {
-        return "and("+m1+", "+m2+")";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/Any.java b/src/main/java/org/mockito/internal/matchers/Any.java
deleted file mode 100644
index ecfde9f607..0000000000
--- a/src/main/java/org/mockito/internal/matchers/Any.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-
-public class Any implements ArgumentMatcher<Object>, VarargMatcher, Serializable {
-
-    public static final Any ANY = new Any();
-
-    public boolean matches(Object actual) {
-        return true;
-    }
-
-    public String toString() {
-        return "<any>";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java b/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
deleted file mode 100644
index cb7d7d1cac..0000000000
--- a/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import static org.mockito.internal.exceptions.Reporter.noArgumentValueWasCaptured;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-import org.mockito.ArgumentMatcher;
-
-@SuppressWarnings("unchecked")
-public class CapturingMatcher<T> implements ArgumentMatcher<T>, CapturesArguments, VarargMatcher, Serializable {
-
-    private final List<Object> arguments = new ArrayList<Object>();
-
-    private final ReadWriteLock lock = new ReentrantReadWriteLock();
-    private final Lock readLock = lock.readLock();
-    private final Lock writeLock = lock.writeLock();
-
-    public boolean matches(Object argument) {
-        return true;
-    }
-
-    public String toString() {
-        return "<Capturing argument>";
-    }
-
-    public T getLastValue() {
-        readLock.lock();
-        try {
-            if (arguments.isEmpty()) {
-                throw noArgumentValueWasCaptured();
-            }
-
-            return (T) arguments.get(arguments.size() - 1);
-        } finally {
-            readLock.unlock();
-        }
-    }
-
-    public List<T> getAllValues() {
-        readLock.lock();
-        try {
-            return new ArrayList<T>((List) arguments);
-        } finally {
-            readLock.unlock();
-        }
-    }
-
-    public void captureFrom(Object argument) {
-        writeLock.lock();
-        try {
-            this.arguments.add(argument);
-        } finally {
-            writeLock.unlock();
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java
deleted file mode 100644
index 3b69fbcf9c..0000000000
--- a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-/**
- * Intended to use in certain ArgumentMatchers.
- * When ArgumentMatcher fails, chance is that the actual object has the same output of toString() than
- * the wanted object. This looks weird when failures are reported.
- * Therefore when matcher fails but toString() yields the same outputs,
- * we will try to use the {@link #toStringWithType()} method.
- */
-public interface ContainsExtraTypeInfo {
-
-    /**
-     * Returns more verbose description of the object which include type information
-     */
-    String toStringWithType();
-
-    /**
-     * Checks if target target has matching type.
-     * If the type matches, there is no point in rendering result from {@link #toStringWithType()}
-     */
-    boolean typeMatches(Object target);
-}
diff --git a/src/main/java/org/mockito/internal/matchers/Equality.java b/src/main/java/org/mockito/internal/matchers/Equality.java
deleted file mode 100644
index 9702550bf6..0000000000
--- a/src/main/java/org/mockito/internal/matchers/Equality.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.lang.reflect.Array;
-
-//stolen from hamcrest because I didn't want to have more dependency than Matcher class
-public class Equality {
-
-    public static boolean areEqual(Object o1, Object o2) {
-        if (o1 == o2 ) {
-            return true;
-    } else if (o1 == null || o2 == null) {
-            return false;
-        } else if (isArray(o1)) {
-            return isArray(o2) && areArraysEqual(o1, o2);
-        } else {
-            return o1.equals(o2);
-        }
-    }
-
-    static boolean areArraysEqual(Object o1, Object o2) {
-        return areArrayLengthsEqual(o1, o2)
-                && areArrayElementsEqual(o1, o2);
-    }
-
-    static boolean areArrayLengthsEqual(Object o1, Object o2) {
-        return Array.getLength(o1) == Array.getLength(o2);
-    }
-
-    static boolean areArrayElementsEqual(Object o1, Object o2) {
-        for (int i = 0; i < Array.getLength(o1); i++) {
-            if (!areEqual(Array.get(o1, i), Array.get(o2, i))) return false;
-        }
-        return true;
-    }
-
-    static boolean isArray(Object o) {
-        return o.getClass().isArray();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/Equals.java b/src/main/java/org/mockito/internal/matchers/Equals.java
deleted file mode 100644
index 5b364784c2..0000000000
--- a/src/main/java/org/mockito/internal/matchers/Equals.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.text.ValuePrinter;
-
-public class Equals implements ArgumentMatcher<Object>, ContainsExtraTypeInfo, Serializable {
-
-    private final Object wanted;
-
-    public Equals(Object wanted) {
-        this.wanted = wanted;
-    }
-
-    public boolean matches(Object actual) {
-        return Equality.areEqual(this.wanted, actual);
-    }
-
-    public String toString() {
-        return describe(wanted);
-    }
-
-    private String describe(Object object) {
-        return ValuePrinter.print(object);
-    }
-
-    protected final Object getWanted() {
-        return wanted;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (o == null || !this.getClass().equals(o.getClass())) {
-            return false;
-        }
-        Equals other = (Equals) o;
-        return this.wanted == null && other.wanted == null || this.wanted != null && this.wanted.equals(other.wanted);
-    }
-
-    @Override
-    public int hashCode() {
-        return 1;
-    }
-
-    public String toStringWithType() {
-        return "("+ wanted.getClass().getSimpleName() +") " + describe(wanted);
-    }
-
-    public boolean typeMatches(Object target) {
-        return wanted != null && target != null && target.getClass() == wanted.getClass();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/InstanceOf.java b/src/main/java/org/mockito/internal/matchers/InstanceOf.java
deleted file mode 100644
index 1b25507564..0000000000
--- a/src/main/java/org/mockito/internal/matchers/InstanceOf.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.util.Primitives;
-
-
-public class InstanceOf implements ArgumentMatcher<Object>, Serializable {
-
-    private final Class<?> clazz;
-    private String description;
-
-    public InstanceOf(Class<?> clazz) {
-        this(clazz, "isA(" + clazz.getCanonicalName() + ")");
-    }
-
-    public InstanceOf(Class<?> clazz, String describedAs) {
-        this.clazz = clazz;
-        this.description = describedAs;
-    }
-
-    public boolean matches(Object actual) {
-        return (actual != null) &&
-                (Primitives.isAssignableFromWrapper(actual.getClass(), clazz)
-                        || clazz.isAssignableFrom(actual.getClass()));
-    }
-
-    public String toString() {
-        return description;
-    }
-
-    public static class VarArgAware extends InstanceOf implements VarargMatcher {
-
-        public VarArgAware(Class<?> clazz) {
-            super(clazz);
-        }
-
-        public VarArgAware(Class<?> clazz, String describedAs) {
-            super(clazz, describedAs);
-        }
-    }
-
-
-}
diff --git a/src/main/java/org/mockito/internal/matchers/NotNull.java b/src/main/java/org/mockito/internal/matchers/NotNull.java
deleted file mode 100644
index 9c41b3e16e..0000000000
--- a/src/main/java/org/mockito/internal/matchers/NotNull.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-
-public class NotNull implements ArgumentMatcher<Object>, Serializable {
-
-    public static final NotNull NOT_NULL = new NotNull();
-
-    private NotNull() {
-    }
-
-    public boolean matches(Object actual) {
-        return actual != null;
-    }
-
-    public String toString() {
-        return "notNull()";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/Null.java b/src/main/java/org/mockito/internal/matchers/Null.java
deleted file mode 100644
index 0d6918513c..0000000000
--- a/src/main/java/org/mockito/internal/matchers/Null.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-
-public class Null implements ArgumentMatcher<Object>, Serializable {
-
-    public static final Null NULL = new Null();
-
-    private Null() {
-    }
-
-    public boolean matches(Object actual) {
-        return actual == null;
-    }
-
-    public String toString() {
-        return "isNull()";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/Or.java b/src/main/java/org/mockito/internal/matchers/Or.java
deleted file mode 100644
index 71f5574faa..0000000000
--- a/src/main/java/org/mockito/internal/matchers/Or.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-import org.mockito.ArgumentMatcher;
-
-@SuppressWarnings({ "unchecked", "serial","rawtypes" })
-public class Or implements ArgumentMatcher<Object>, Serializable {
-    private final ArgumentMatcher m1;
-    private final ArgumentMatcher m2;
-
-    public Or(ArgumentMatcher<?> m1, ArgumentMatcher<?> m2) {
-        this.m1 = m1;
-        this.m2 = m2;
-    }
-
-    public boolean matches(Object actual) {
-        return m1.matches(actual) || m2.matches(actual);
-    }
-
-    public String toString() {
-        return "or("+m1+", "+m2+")";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/VarargMatcher.java b/src/main/java/org/mockito/internal/matchers/VarargMatcher.java
deleted file mode 100644
index fc843f63b2..0000000000
--- a/src/main/java/org/mockito/internal/matchers/VarargMatcher.java
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import java.io.Serializable;
-
-/**
- * Internal interface that informs Mockito that the matcher is intended to capture varargs.
- * This information is needed when mockito collects the arguments.
- */
-public interface VarargMatcher extends Serializable {
-}
diff --git a/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java b/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
deleted file mode 100644
index 028059a6c9..0000000000
--- a/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers.text;
-
-import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-import static org.mockito.internal.util.StringUtil.decamelizeMatcher;
-
-import java.lang.reflect.Method;
-
-import org.mockito.ArgumentMatcher;
-
-/**
- * Provides better toString() text for matcher that don't have toString() method declared.
- */
-class MatcherToString {
-
-    /**
-     * Attempts to provide more descriptive toString() for given matcher.
-     * Searches matcher class hierarchy for toString() method. If it is found it will be used.
-     * If no toString() is defined for the matcher hierarchy,
-     * uses decamelized class name instead of default Object.toString().
-     * This way we can promote meaningful names for custom matchers.
-     *
-     * @param matcher
-     * @return
-     */
-    static String toString(ArgumentMatcher<?> matcher) {
-        Class<?> cls = matcher.getClass();
-        while(cls != Object.class) {
-            Method[] methods = cls.getDeclaredMethods();
-            for (Method m : methods) {
-                if(isToStringMethod(m)) {
-                    return matcher.toString();
-                }
-            }
-            cls = cls.getSuperclass();
-        }
-        return decamelizeMatcher(matcher.getClass().getSimpleName());
-    }
-
-
-}
diff --git a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java
deleted file mode 100644
index 044871b013..0000000000
--- a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers.text;
-
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.ContainsExtraTypeInfo;
-import org.mockito.internal.reporting.PrintSettings;
-
-@SuppressWarnings("unchecked")
-public class MatchersPrinter {
-
-    public String getArgumentsLine(List<ArgumentMatcher> matchers, PrintSettings printSettings) {
-        Iterator args = applyPrintSettings(matchers, printSettings);
-        return ValuePrinter.printValues("(", ", ", ");", args);
-    }
-
-    public String getArgumentsBlock(List<ArgumentMatcher> matchers, PrintSettings printSettings) {
-        Iterator args = applyPrintSettings(matchers, printSettings);
-        return ValuePrinter.printValues("(\n    ", ",\n    ", "\n);", args);
-    }
-
-    private Iterator<FormattedText> applyPrintSettings(List<ArgumentMatcher> matchers, PrintSettings printSettings) {
-        List<FormattedText> out = new LinkedList<FormattedText>();
-        int i = 0;
-        for (final ArgumentMatcher matcher : matchers) {
-            if (matcher instanceof ContainsExtraTypeInfo && printSettings.extraTypeInfoFor(i)) {
-                out.add(new FormattedText(((ContainsExtraTypeInfo) matcher).toStringWithType()));
-            } else {
-                out.add(new FormattedText(MatcherToString.toString(matcher)));
-            }
-            i++;
-        }
-        return out.iterator();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
deleted file mode 100644
index 059968e6cb..0000000000
--- a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers.text;
-
-import static java.lang.String.valueOf;
-
-import java.lang.reflect.Array;
-import java.util.Iterator;
-import java.util.Map;
-
-/**
- * Prints a Java object value in a way humans can read it neatly.
- * Inspired on hamcrest. Used for printing arguments in verification errors.
- */
-public class ValuePrinter {
-
-    private ValuePrinter(){}
-
-    /**
-     * Prints given value so that it is neatly readable by humans.
-     * Handles explosive toString() implementations.
-     */
-    public static String print(final Object value) {
-        if (value == null) {
-            return "null";
-        }
-        if (value instanceof String) {
-            return '"' + value.toString() + '"';
-        }
-        if (value instanceof Character) {
-            return printChar((Character) value);
-        }
-        if (value instanceof Long) {
-            return value + "L";
-        }
-        if (value instanceof Double) {
-            return value + "d";
-        }
-        if (value instanceof Float) {
-            return value + "f";
-        }
-        if (value instanceof Short) {
-            return "(short) " + value;
-        }
-        if (value instanceof Byte) {
-            return String.format("(byte) 0x%02X", (Byte) value);
-        }
-        if (value instanceof Map) {
-            return printMap((Map<?, ?>) value);
-        }
-        if (value.getClass().isArray()) {
-            return printValues("[", ", ", "]", new Iterator<Object>() {
-                private int currentIndex = 0;
-
-                public boolean hasNext() {
-                    return currentIndex < Array.getLength(value);
-                }
-
-                public Object next() {
-                    return Array.get(value, currentIndex++);
-                }
-
-                public void remove() {
-                    throw new UnsupportedOperationException("cannot remove items from an array");
-                }
-            });
-        }
-        if (value instanceof FormattedText) {
-            return (((FormattedText) value).getText());
-        }
-
-        return descriptionOf(value);
-    }
-
-    private static String printMap(Map<?,?> map) {
-        StringBuilder result = new StringBuilder();
-        Iterator<? extends Map.Entry<?, ?>> iterator = map.entrySet().iterator();
-        while (iterator.hasNext()) {
-            Map.Entry<?, ?> entry = iterator.next();
-            result.append(print(entry.getKey())).append(" = ").append(print(entry.getValue()));
-            if (iterator.hasNext()) {
-                result.append(", ");
-            }
-        }
-        return "{" + result.toString() + "}";
-    }
-
-    /**
-     * Print values in a nice format, e.g. (1, 2, 3)
-     *
-     * @param start the beginning of the values, e.g. "("
-     * @param separator the separator of values, e.g. ", "
-     * @param end the end of the values, e.g. ")"
-     * @param values the values to print
-     *
-     * @return neatly formatted value list
-     */
-    public static String printValues(String start, String separator, String end, Iterator<?> values) {
-        if(start == null){
-            start = "(";
-        }
-        if (separator == null){
-            separator = ",";
-        }
-        if (end == null){
-            end = ")";
-        }
-
-        StringBuilder sb = new StringBuilder(start);
-        while(values.hasNext()) {
-            sb.append(print(values.next()));
-            if (values.hasNext()) {
-                sb.append(separator);
-            }
-        }
-        return sb.append(end).toString();
-    }
-
-    private static String printChar(char value) {
-        StringBuilder sb = new StringBuilder();
-        sb.append('\'');
-        switch (value) {
-            case '"':
-                sb.append("\\\"");
-                break;
-            case '\n':
-                sb.append("\\n");
-                break;
-            case '\r':
-                sb.append("\\r");
-                break;
-            case '\t':
-                sb.append("\\t");
-                break;
-            default:
-                sb.append(value);
-        }
-        sb.append('\'');
-        return sb.toString();
-    }
-
-    private static String descriptionOf(Object value) {
-        try {
-            return valueOf(value);
-        }
-        catch (Exception e) {
-            return value.getClass().getName() + "@" + Integer.toHexString(value.hashCode());
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java b/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
deleted file mode 100644
index 6e9ac2933f..0000000000
--- a/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.progress;
-
-import static org.mockito.internal.exceptions.Reporter.unfinishedStubbing;
-import static org.mockito.internal.exceptions.Reporter.unfinishedVerificationException;
-
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import org.mockito.internal.configuration.GlobalConfiguration;
-import org.mockito.internal.debugging.Localized;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.internal.listeners.AutoCleanableListener;
-import org.mockito.invocation.Location;
-import org.mockito.listeners.MockCreationListener;
-import org.mockito.listeners.MockitoListener;
-import org.mockito.listeners.VerificationListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.stubbing.OngoingStubbing;
-import org.mockito.verification.VerificationMode;
-import org.mockito.verification.VerificationStrategy;
-
-@SuppressWarnings("unchecked")
-public class MockingProgressImpl implements MockingProgress {
-
-    private final ArgumentMatcherStorage argumentMatcherStorage = new ArgumentMatcherStorageImpl();
-
-    private OngoingStubbing<?> ongoingStubbing;
-    private Localized<VerificationMode> verificationMode;
-    private Location stubbingInProgress = null;
-    private VerificationStrategy verificationStrategy;
-    private final Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();
-
-    public MockingProgressImpl() {
-        this.verificationStrategy = getDefaultVerificationStrategy();
-    }
-
-    public static VerificationStrategy getDefaultVerificationStrategy() {
-        return new VerificationStrategy() {
-            public VerificationMode maybeVerifyLazily(VerificationMode mode) {
-                return mode;
-            }
-        };
-    }
-
-    public void reportOngoingStubbing(OngoingStubbing ongoingStubbing) {
-        this.ongoingStubbing = ongoingStubbing;
-    }
-
-    public OngoingStubbing<?> pullOngoingStubbing() {
-        OngoingStubbing<?> temp = ongoingStubbing;
-        ongoingStubbing = null;
-        return temp;
-    }
-
-    @Override
-    public Set<VerificationListener> verificationListeners() {
-        final LinkedHashSet<VerificationListener> verificationListeners = new LinkedHashSet<VerificationListener>();
-
-        for (MockitoListener listener : listeners) {
-            if (listener instanceof VerificationListener) {
-                verificationListeners.add((VerificationListener) listener);
-            }
-        }
-
-        return verificationListeners;
-    }
-
-
-    public void verificationStarted(VerificationMode verify) {
-        validateState();
-        resetOngoingStubbing();
-        verificationMode = new Localized(verify);
-    }
-
-    /* (non-Javadoc)
-     * @see org.mockito.internal.progress.MockingProgress#resetOngoingStubbing()
-     */
-    public void resetOngoingStubbing() {
-        ongoingStubbing = null;
-    }
-
-    public VerificationMode pullVerificationMode() {
-        if (verificationMode == null) {
-            return null;
-        }
-
-        VerificationMode temp = verificationMode.getObject();
-        verificationMode = null;
-        return temp;
-    }
-
-    public void stubbingStarted() {
-        validateState();
-        stubbingInProgress = new LocationImpl();
-    }
-
-    public void validateState() {
-        validateMostStuff();
-
-        //validate stubbing:
-        if (stubbingInProgress != null) {
-            Location temp = stubbingInProgress;
-            stubbingInProgress = null;
-            throw unfinishedStubbing(temp);
-        }
-    }
-
-    private void validateMostStuff() {
-        //State is cool when GlobalConfiguration is already loaded
-        //this cannot really be tested functionally because I cannot dynamically mess up org.mockito.configuration.MockitoConfiguration class
-        GlobalConfiguration.validate();
-
-        if (verificationMode != null) {
-            Location location = verificationMode.getLocation();
-            verificationMode = null;
-            throw unfinishedVerificationException(location);
-        }
-
-        getArgumentMatcherStorage().validateState();
-    }
-
-    public void stubbingCompleted() {
-        stubbingInProgress = null;
-    }
-
-    public String toString() {
-        return  "ongoingStubbing: " + ongoingStubbing +
-        ", verificationMode: " + verificationMode +
-        ", stubbingInProgress: " + stubbingInProgress;
-    }
-
-    public void reset() {
-        stubbingInProgress = null;
-        verificationMode = null;
-        getArgumentMatcherStorage().reset();
-    }
-
-    public ArgumentMatcherStorage getArgumentMatcherStorage() {
-        return argumentMatcherStorage;
-    }
-
-    public void mockingStarted(Object mock, MockCreationSettings settings) {
-        for (MockitoListener listener : listeners) {
-            if (listener instanceof MockCreationListener) {
-                ((MockCreationListener) listener).onMockCreated(mock, settings);
-            }
-        }
-        validateMostStuff();
-    }
-
-    public void addListener(MockitoListener listener) {
-        addListener(listener, listeners);
-    }
-
-    static void addListener(MockitoListener listener, Set<MockitoListener> listeners) {
-        List<MockitoListener> delete = new LinkedList<MockitoListener>();
-        for (MockitoListener existing : listeners) {
-            if (existing.getClass().equals(listener.getClass())) {
-                if (existing instanceof AutoCleanableListener && ((AutoCleanableListener) existing).isListenerDirty()) {
-                    //dirty listener means that there was an exception even before the test started
-                    //if we fail here with redundant mockito listener exception there will be multiple failures causing confusion
-                    //so we simply remove the existing listener and move on
-                    delete.add(existing);
-                } else {
-                    Reporter.redundantMockitoListener(listener.getClass().getSimpleName());
-                }
-            }
-        }
-        //delete dirty listeners so they don't occupy state/memory and don't receive notifications
-        for (MockitoListener toDelete : delete) {
-            listeners.remove(toDelete);
-        }
-        listeners.add(listener);
-    }
-
-    public void removeListener(MockitoListener listener) {
-        this.listeners.remove(listener);
-    }
-
-    public void setVerificationStrategy(VerificationStrategy strategy) {
-        this.verificationStrategy = strategy;
-    }
-
-    public VerificationMode maybeVerifyLazily(VerificationMode mode) {
-        return this.verificationStrategy.maybeVerifyLazily(mode);
-    }
-
-    public void clearListeners() {
-        listeners.clear();
-    }
-
-     /*
-
-     //TODO 545 thread safety of all mockito
-
-     use cases:
-        - single threaded execution throughout
-        - single threaded mock creation, stubbing & verification, multi-threaded interaction with mock
-        - thread per test case
-
-     */
-}
diff --git a/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java b/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
deleted file mode 100644
index 4735a118be..0000000000
--- a/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.progress;
-
-/**
- * Provides access to the {@link MockingProgress} of a corresponding {@link Thread}. Every {@link Thread} in Mockito has it s own {@link MockingProgress} to avoid data races while stubbing.
- */
-public class ThreadSafeMockingProgress {
-
-    private static final ThreadLocal<MockingProgress> MOCKING_PROGRESS_PROVIDER = new ThreadLocal<MockingProgress>() {
-        @Override
-        protected MockingProgress initialValue() {
-            return new MockingProgressImpl();
-        }
-    };
-
-    private ThreadSafeMockingProgress() {
-    }
-
-    /**
-     * Returns the {@link MockingProgress} for the current Thread.
-     * <p>
-     * <b>IMPORTANT</b>: Never assign and access the returned {@link MockingProgress} to an instance or static field. Thread safety can not be guaranteed in this case, cause the Thread that wrote the field might not be the same that read it. In other words multiple threads will access the same {@link MockingProgress}.
-     *
-     * @return never <code>null</code>
-     */
-    public final static MockingProgress mockingProgress() {
-        return MOCKING_PROGRESS_PROVIDER.get();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/reporting/PrintSettings.java b/src/main/java/org/mockito/internal/reporting/PrintSettings.java
deleted file mode 100644
index c6fa92b425..0000000000
--- a/src/main/java/org/mockito/internal/reporting/PrintSettings.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.reporting;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.text.MatchersPrinter;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MatchableInvocation;
-
-public class PrintSettings {
-
-    public static final int MAX_LINE_LENGTH = 45;
-    private boolean multiline;
-    private List<Integer> withTypeInfo = new LinkedList<Integer>();
-
-    public void setMultiline(boolean multiline) {
-        this.multiline = multiline;
-    }
-
-    public boolean isMultiline() {
-        return multiline;
-    }
-
-    public static PrintSettings verboseMatchers(Integer ... indexesOfMatchers) {
-        PrintSettings settings = new PrintSettings();
-        settings.setMatchersToBeDescribedWithExtraTypeInfo(indexesOfMatchers);
-        return settings;
-    }
-
-    public boolean extraTypeInfoFor(int argumentIndex) {
-        return withTypeInfo.contains(argumentIndex);
-    }
-
-    public void setMatchersToBeDescribedWithExtraTypeInfo(Integer[] indexesOfMatchers) {
-        this.withTypeInfo = Arrays.asList(indexesOfMatchers);
-    }
-
-    public String print(List<ArgumentMatcher> matchers, Invocation invocation) {
-        MatchersPrinter matchersPrinter = new MatchersPrinter();
-        String qualifiedName = MockUtil.getMockName(invocation.getMock()) + "." + invocation.getMethod().getName();
-        String invocationString = qualifiedName + matchersPrinter.getArgumentsLine(matchers, this);
-        if (isMultiline() || (!matchers.isEmpty() && invocationString.length() > MAX_LINE_LENGTH)) {
-            return qualifiedName + matchersPrinter.getArgumentsBlock(matchers, this);
-        } else {
-            return invocationString;
-        }
-    }
-
-    public String print(Invocation invocation) {
-        return print(invocation.getArgumentsAsMatchers(), invocation);
-    }
-
-    public String print(MatchableInvocation invocation) {
-        return print(invocation.getMatchers(), invocation.getInvocation());
-    }
-}
diff --git a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
deleted file mode 100644
index 400133fa5d..0000000000
--- a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.reporting;
-
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MatchableInvocation;
-
-/**
- * Makes sure both wanted and actual are printed consistently (single line or multiline)
- * <p>
- * Makes arguments printed with types if necessary
- */
-public class SmartPrinter {
-
-    private final String wanted;
-    private final List<String> actuals;
-
-    public SmartPrinter(MatchableInvocation wanted, Invocation actual, Integer ... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
-        this(wanted, Collections.singletonList(actual), indexesOfMatchersToBeDescribedWithExtraTypeInfo);
-    }
-
-    public SmartPrinter(MatchableInvocation wanted, List<Invocation> allActualInvocations, Integer ... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
-        PrintSettings printSettings = new PrintSettings();
-        printSettings.setMultiline(isMultiLine(wanted, allActualInvocations));
-        printSettings.setMatchersToBeDescribedWithExtraTypeInfo(indexesOfMatchersToBeDescribedWithExtraTypeInfo);
-
-        this.wanted = printSettings.print(wanted);
-
-        List<String> actuals = new ArrayList<String>();
-        for (Invocation actual : allActualInvocations) {
-            actuals.add(printSettings.print(actual));
-        }
-        this.actuals = Collections.unmodifiableList(actuals);
-    }
-
-    public String getWanted() {
-        return wanted;
-    }
-
-    public List<String> getActuals() {
-        return actuals;
-    }
-
-    private static boolean isMultiLine(MatchableInvocation wanted, List<Invocation> allActualInvocations) {
-        boolean isWantedMultiline = wanted.toString().contains("\n");
-        boolean isAnyActualMultiline = false;
-        for (Invocation invocation : allActualInvocations) {
-            isAnyActualMultiline |= invocation.toString().contains("\n");
-        }
-        return isWantedMultiline || isAnyActualMultiline;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java b/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
deleted file mode 100644
index ad115f09b6..0000000000
--- a/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.runners;
-
-import org.junit.runner.Description;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.Failure;
-import org.junit.runner.notification.RunListener;
-import org.junit.runner.notification.RunNotifier;
-import org.junit.runners.BlockJUnit4ClassRunner;
-import org.junit.runners.model.FrameworkMethod;
-import org.junit.runners.model.InitializationError;
-import org.junit.runners.model.Statement;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.internal.junit.DefaultTestFinishedEvent;
-import org.mockito.internal.junit.MockitoTestListener;
-import org.mockito.internal.util.Supplier;
-
-public class DefaultInternalRunner implements InternalRunner {
-
-    private final BlockJUnit4ClassRunner runner;
-
-    public DefaultInternalRunner(Class<?> testClass, final Supplier<MockitoTestListener> listenerSupplier) throws InitializationError {
-        runner = new BlockJUnit4ClassRunner(testClass) {
-
-            public Object target;
-            private MockitoTestListener mockitoTestListener;
-
-            protected Statement withBefores(FrameworkMethod method, final Object target, Statement statement) {
-                this.target = target;
-                final Statement base = super.withBefores(method, target, statement);
-                return new Statement() {
-                    @Override
-                    public void evaluate() throws Throwable {
-                        if (mockitoTestListener == null) {
-                            // get new test listener and add it to the framework
-                            mockitoTestListener = listenerSupplier.get();
-                            Mockito.framework().addListener(mockitoTestListener);
-                            // init annotated mocks before tests
-                            MockitoAnnotations.initMocks(target);
-                        }
-                        base.evaluate();
-                    }
-                };
-            }
-
-            public void run(final RunNotifier notifier) {
-                RunListener listener = new RunListener() {
-                    Throwable failure;
-
-                    @Override
-                    public void testFailure(Failure failure) throws Exception {
-                        this.failure = failure.getException();
-                    }
-
-                    @Override
-                    public void testFinished(Description description) throws Exception {
-                        try {
-                            if (mockitoTestListener != null) {
-                                Mockito.framework().removeListener(mockitoTestListener);
-                                mockitoTestListener.testFinished(new DefaultTestFinishedEvent(target, description.getMethodName(), failure));
-                                mockitoTestListener = null;
-                            }
-                            Mockito.validateMockitoUsage();
-                        } catch (Throwable t) {
-                            //In order to produce clean exception to the user we need to fire test failure with the right description
-                            //Otherwise JUnit framework will report failure with some generic test name
-                            notifier.fireTestFailure(new Failure(description, t));
-                        }
-                    }
-                };
-                notifier.addListener(listener);
-                super.run(notifier);
-            }
-        };
-    }
-
-    public void run(final RunNotifier notifier) {
-        runner.run(notifier);
-    }
-
-    public Description getDescription() {
-        return runner.getDescription();
-    }
-
-    public void filter(Filter filter) throws NoTestsRemainException {
-        runner.filter(filter);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/runners/RunnerFactory.java b/src/main/java/org/mockito/internal/runners/RunnerFactory.java
deleted file mode 100644
index e2446b58fb..0000000000
--- a/src/main/java/org/mockito/internal/runners/RunnerFactory.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.runners;
-
-import static org.mockito.internal.runners.util.TestMethodsFinder.hasTestMethods;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.junit.MismatchReportingTestListener;
-import org.mockito.internal.junit.MockitoTestListener;
-import org.mockito.internal.junit.NoOpTestListener;
-import org.mockito.internal.junit.StrictStubsRunnerTestListener;
-import org.mockito.internal.runners.util.RunnerProvider;
-import org.mockito.internal.util.Supplier;
-
-/**
- * Creates instances of Mockito JUnit Runner in a safe way, e.g. detecting inadequate version of JUnit, etc.
- */
-public class RunnerFactory {
-
-    /**
-     * Creates silent runner implementation
-     */
-    public InternalRunner create(Class<?> klass) throws InvocationTargetException {
-        return create(klass, new Supplier<MockitoTestListener>() {
-            public MockitoTestListener get() {
-                return new NoOpTestListener();
-            }
-        });
-    }
-
-    /**
-     * Creates strict runner implementation
-     */
-    public InternalRunner createStrict(Class<?> klass) throws InvocationTargetException {
-        return create(klass, new Supplier<MockitoTestListener>() {
-            public MockitoTestListener get() {
-                return new MismatchReportingTestListener(Plugins.getMockitoLogger());
-            }
-        });
-    }
-
-    /**
-     * Creates strict stubs runner implementation
-     *
-     * TODO, let's try to apply Brice suggestion and use switch + Strictness
-     */
-    public InternalRunner createStrictStubs(Class<?> klass) throws InvocationTargetException {
-        return create(klass, new Supplier<MockitoTestListener>() {
-            public MockitoTestListener get() {
-                return new StrictStubsRunnerTestListener();
-            }
-        });
-    }
-
-    /**
-     * Creates runner implementation with provided listener supplier
-     */
-    public InternalRunner create(Class<?> klass, Supplier<MockitoTestListener> listenerSupplier) throws InvocationTargetException {
-        try {
-            String runnerClassName = "org.mockito.internal.runners.DefaultInternalRunner";
-            //Warning: I'm using String literal on purpose!
-            //When JUnit is not on classpath, we want the code to throw exception here so that we can catch it
-            //If we statically link the class, we will get Error when class is loaded
-            return new RunnerProvider().newInstance(runnerClassName, klass, listenerSupplier);
-        } catch (InvocationTargetException e) {
-            if (!hasTestMethods(klass)) {
-                throw new MockitoException(
-                    "\n" +
-                    "\n" +
-                    "No tests found in " + klass.getSimpleName() + "\n" +
-                    "Is the method annotated with @Test?\n" +
-                    "Is the method public?\n"
-                    , e);
-            }
-            throw e;
-        } catch (Throwable t) {
-            throw new MockitoException(
-                    "\n" +
-                    "\n" +
-                    "MockitoRunner can only be used with JUnit 4.5 or higher.\n" +
-                    "You can upgrade your JUnit version or write your own Runner (please consider contributing your runner to the Mockito community).\n" +
-                    "Bear in mind that you can still enjoy all features of the framework without using runners (they are completely optional).\n" +
-                    "If you get this error despite using JUnit 4.5 or higher then please report this error to the mockito mailing list.\n"
-                    , t);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/runners/StrictRunner.java b/src/main/java/org/mockito/internal/runners/StrictRunner.java
deleted file mode 100644
index d87289fc5c..0000000000
--- a/src/main/java/org/mockito/internal/runners/StrictRunner.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.runners;
-
-import org.junit.runner.Description;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.RunNotifier;
-import org.mockito.Mockito;
-import org.mockito.internal.junit.UnnecessaryStubbingsReporter;
-import org.mockito.internal.runners.util.FailureDetector;
-
-public class StrictRunner implements InternalRunner {
-
-    private final Class<?> testClass;
-    private final InternalRunner runner;
-    private boolean filterRequested;
-
-    /**
-     * @param runner - the runner to wrap around
-     * @param testClass - for reporting purposes
-     */
-    public StrictRunner(InternalRunner runner, Class<?> testClass) {
-        this.runner = runner;
-        this.testClass = testClass;
-    }
-
-    public void run(RunNotifier notifier) {
-        //TODO need to be able to opt in for full stack trace instead of just relying on the stack trace filter
-        UnnecessaryStubbingsReporter reporter = new UnnecessaryStubbingsReporter();
-        FailureDetector listener = new FailureDetector();
-
-        Mockito.framework().addListener(reporter);
-        try {
-            // add listener that detects test failures
-            notifier.addListener(listener);
-            runner.run(notifier);
-        } finally {
-            Mockito.framework().removeListener(reporter);
-        }
-
-        if (!filterRequested && listener.isSuccessful()) {
-            //only report when:
-            //1. if all tests from given test have ran (filter requested is false)
-            //   Otherwise we would report unnecessary stubs even if the user runs just single test from the class
-            //2. tests are successful (we don't want to add an extra failure on top of any existing failure, to avoid confusion)
-            reporter.validateUnusedStubs(testClass, notifier);
-        }
-    }
-
-    public Description getDescription() {
-        return runner.getDescription();
-    }
-
-    public void filter(Filter filter) throws NoTestsRemainException {
-        filterRequested = true;
-        runner.filter(filter);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java b/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
deleted file mode 100644
index 983e056ef1..0000000000
--- a/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.session;
-
-import static java.util.Collections.emptyList;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.mockito.MockitoSession;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.framework.DefaultMockitoSession;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.quality.Strictness;
-import org.mockito.session.MockitoSessionBuilder;
-import org.mockito.session.MockitoSessionLogger;
-
-public class DefaultMockitoSessionBuilder implements MockitoSessionBuilder {
-
-    private List<Object> testClassInstances = new ArrayList<Object>();
-    private String name;
-    private Strictness strictness;
-    private MockitoSessionLogger logger;
-
-    @Override
-    public MockitoSessionBuilder initMocks(Object testClassInstance) {
-        if (testClassInstance != null) {
-            this.testClassInstances.add(testClassInstance);
-        }
-        return this;
-    }
-
-    @Override
-    public MockitoSessionBuilder initMocks(Object... testClassInstances) {
-        if (testClassInstances != null) {
-            for (Object instance : testClassInstances) {
-                initMocks(instance);
-            }
-        }
-        return this;
-    }
-
-    @Override
-    public MockitoSessionBuilder name(String name) {
-        this.name = name;
-        return this;
-    }
-
-    @Override
-    public MockitoSessionBuilder strictness(Strictness strictness) {
-        this.strictness = strictness;
-        return this;
-    }
-
-    @Override
-    public MockitoSessionBuilder logger(MockitoSessionLogger logger) {
-        this.logger = logger;
-        return this;
-    }
-
-    @Override
-    public MockitoSession startMocking() {
-        //Configure default values
-        List<Object> effectiveTestClassInstances;
-        String effectiveName;
-        if (testClassInstances.isEmpty()) {
-            effectiveTestClassInstances = emptyList();
-            effectiveName = this.name == null ? "<Unnamed Session>" : this.name;
-        } else {
-            effectiveTestClassInstances = new ArrayList<Object>(testClassInstances);
-            Object lastTestClassInstance = testClassInstances.get(testClassInstances.size() - 1);
-            effectiveName = this.name == null ? lastTestClassInstance.getClass().getName() : this.name;
-        }
-        Strictness effectiveStrictness = this.strictness == null ? Strictness.STRICT_STUBS : this.strictness;
-        MockitoLogger logger = this.logger == null ? Plugins.getMockitoLogger() : new MockitoLoggerAdapter(this.logger);
-        return new DefaultMockitoSession(effectiveTestClassInstances, effectiveName, effectiveStrictness, logger);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
deleted file mode 100644
index 19922a7fa8..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing;
-
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.invocation.StubInfoImpl;
-import org.mockito.internal.verification.DefaultRegisteredInvocations;
-import org.mockito.internal.verification.RegisteredInvocations;
-import org.mockito.internal.verification.SingleRegisteredInvocation;
-import org.mockito.invocation.Invocation;
-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;
-
-@SuppressWarnings("unchecked")
-public class InvocationContainerImpl implements InvocationContainer, Serializable {
-
-    private static final long serialVersionUID = -5334301962749537177L;
-    private final LinkedList<StubbedInvocationMatcher> stubbed = new LinkedList<StubbedInvocationMatcher>();
-    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) {
-        registeredInvocations.add(invocation.getInvocation());
-        this.invocationForStubbing = invocation;
-    }
-
-    public void resetInvocationForPotentialStubbing(MatchableInvocation invocationMatcher) {
-        this.invocationForStubbing = invocationMatcher;
-    }
-
-    public void addAnswer(Answer answer, Strictness stubbingStrictness) {
-        unmarkLastUsedStubIfNecessary();
-
-        registeredInvocations.removeLast();
-        addAnswer(answer, false, stubbingStrictness);
-    }
-
-    /**
-     *  A stubbed call is marked as used when the method call is stubbed again, because the second
-     *  stub looks like an actual usage of the first stubbed call. When the second stub is set up,
-     *  the previous one is marked as unused again.
-     */
-    private void unmarkLastUsedStubIfNecessary() {
-        synchronized (stubbed) {
-            Invocation invocation = invocationForStubbing.getInvocation();
-
-            for (StubbedInvocationMatcher s : stubbed) {
-                if (s.matches(invocation)) {
-                    s.markStubUsed(null);
-                    invocation.markStubbed(null);
-                    return;
-                }
-            }
-        }
-    }
-
-    public void addConsecutiveAnswer(Answer answer) {
-        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, Strictness stubbingStrictness) {
-        Invocation invocation = invocationForStubbing.getInvocation();
-        mockingProgress().stubbingCompleted();
-        if (answer instanceof ValidableAnswer) {
-            ((ValidableAnswer) answer).validateFor(invocation);
-        }
-
-        synchronized (stubbed) {
-            if (isConsecutive) {
-                stubbed.getFirst().addAnswer(answer);
-            } else {
-                Strictness effectiveStrictness = stubbingStrictness != null ? stubbingStrictness : this.mockStrictness;
-                stubbed.addFirst(new StubbedInvocationMatcher(answer, invocationForStubbing, effectiveStrictness));
-            }
-            return stubbed.getFirst();
-        }
-    }
-
-    Object answerTo(Invocation invocation) throws Throwable {
-        return findAnswerFor(invocation).answer(invocation);
-    }
-
-    public StubbedInvocationMatcher findAnswerFor(Invocation invocation) {
-        synchronized (stubbed) {
-            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;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Sets the answers declared with 'doAnswer' style.
-     */
-    public void setAnswersForStubbing(List<Answer<?>> answers, Strictness strictness) {
-        doAnswerStyleStubbing.setAnswers(answers, strictness);
-    }
-
-    public boolean hasAnswersForStubbing() {
-        return !doAnswerStyleStubbing.isSet();
-    }
-
-    public boolean hasInvocationForPotentialStubbing() {
-        return !registeredInvocations.isEmpty();
-    }
-
-    public void setMethodForStubbing(MatchableInvocation invocation) {
-        invocationForStubbing = invocation;
-        assert hasAnswersForStubbing();
-        for (int i = 0; i < doAnswerStyleStubbing.getAnswers().size(); i++) {
-            addAnswer(doAnswerStyleStubbing.getAnswers().get(i), i != 0, doAnswerStyleStubbing.getStubbingStrictness());
-        }
-        doAnswerStyleStubbing.clear();
-    }
-
-    @Override
-    public String toString() {
-        return "invocationForStubbing: " + invocationForStubbing;
-    }
-
-    public List<Invocation> getInvocations() {
-        return registeredInvocations.getAll();
-    }
-
-    public void clearInvocations() {
-        registeredInvocations.clear();
-    }
-
-    /**
-     * 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();
-    }
-
-    public MatchableInvocation getInvocationForStubbing() {
-        return invocationForStubbing;
-    }
-
-    private RegisteredInvocations createRegisteredInvocations(MockCreationSettings mockSettings) {
-        return mockSettings.isStubOnly()
-          ? new SingleRegisteredInvocation()
-          : new DefaultRegisteredInvocations();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java b/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
deleted file mode 100644
index 6aaf520fae..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.Answer1;
-import org.mockito.stubbing.Answer2;
-import org.mockito.stubbing.Answer3;
-import org.mockito.stubbing.Answer4;
-import org.mockito.stubbing.Answer5;
-import org.mockito.stubbing.Answer6;
-import org.mockito.stubbing.VoidAnswer1;
-import org.mockito.stubbing.VoidAnswer2;
-import org.mockito.stubbing.VoidAnswer3;
-import org.mockito.stubbing.VoidAnswer4;
-import org.mockito.stubbing.VoidAnswer5;
-import org.mockito.stubbing.VoidAnswer6;
-
-/**
- * Functional interfaces to make it easy to implement answers in Java 8
- *
- * @since 2.1.0
- */
-public class AnswerFunctionalInterfaces {
-    /**
-     * Hide constructor to avoid instantiation of class with only static methods
-     */
-    private AnswerFunctionalInterfaces() {
-    }
-
-    /**
-     * Construct an answer from a two parameter answer interface
-     * @param answer answer interface
-     * @param <T> return type
-     * @param <A> input parameter 1 type
-     * @return a new answer object
-     */
-    public static <T, A> Answer<T> toAnswer(final Answer1<T, A> answer) {
-        return new Answer<T>() {
-            @SuppressWarnings("unchecked")
-            public T answer(InvocationOnMock invocation) throws Throwable {
-                return answer.answer((A)invocation.getArgument(0));
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a two parameter answer interface
-     * @param answer answer interface
-     * @param <A> input parameter 1 type
-     * @return a new answer object
-     */
-    public static <A> Answer<Void> toAnswer(final VoidAnswer1<A> answer) {
-        return new Answer<Void>() {
-            @SuppressWarnings("unchecked")
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                answer.answer((A)invocation.getArgument(0));
-                return null;
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a two parameter answer interface
-     * @param answer answer interface
-     * @param <T> return type
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @return a new answer object
-     */
-    public static <T, A, B> Answer<T> toAnswer(final Answer2<T, A, B> answer) {
-        return new Answer<T>() {
-            @SuppressWarnings("unchecked")
-            public T answer(InvocationOnMock invocation) throws Throwable {
-                return answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1));
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a two parameter answer interface
-     * @param answer answer interface
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @return a new answer object
-     */
-    public static <A, B> Answer<Void> toAnswer(final VoidAnswer2<A, B> answer) {
-        return new Answer<Void>() {
-            @SuppressWarnings("unchecked")
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1));
-                return null;
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a three parameter answer interface
-     * @param answer answer interface
-     * @param <T> return type
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @return a new answer object
-     */
-    public static <T, A, B, C> Answer<T> toAnswer(final Answer3<T, A, B, C> answer) {
-        return new Answer<T>() {
-            @SuppressWarnings("unchecked")
-            public T answer(InvocationOnMock invocation) throws Throwable {
-                return answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2));
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a three parameter answer interface
-     * @param answer answer interface
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @return a new answer object
-     */
-    public static <A, B, C> Answer<Void> toAnswer(final VoidAnswer3<A, B, C> answer) {
-        return new Answer<Void>() {
-            @SuppressWarnings("unchecked")
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2));
-                return null;
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a four parameter answer interface
-     * @param answer answer interface
-     * @param <T> return type
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @param <D> input parameter 4 type
-     * @return a new answer object
-     */
-    public static <T, A, B, C, D> Answer<T> toAnswer(final Answer4<T, A, B, C, D> answer) {
-        return new Answer<T>() {
-            @SuppressWarnings("unchecked")
-            public T answer(InvocationOnMock invocation) throws Throwable {
-                return answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2),
-                        (D)invocation.getArgument(3));
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a four parameter answer interface
-     * @param answer answer interface
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @param <D> input parameter 4 type
-     * @return a new answer object
-     */
-    public static <A, B, C, D> Answer<Void> toAnswer(final VoidAnswer4<A, B, C, D> answer) {
-        return new Answer<Void>() {
-            @SuppressWarnings("unchecked")
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2),
-                        (D)invocation.getArgument(3));
-                return null;
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a five parameter answer interface
-     * @param answer answer interface
-     * @param <T> return type
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @param <D> input parameter 4 type
-     * @param <E> input parameter 5 type
-     * @return a new answer object
-     */
-    public static <T, A, B, C, D, E> Answer<T> toAnswer(final Answer5<T, A, B, C, D, E> answer) {
-        return new Answer<T>() {
-            @SuppressWarnings("unchecked")
-            public T answer(InvocationOnMock invocation) throws Throwable {
-                return answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2),
-                        (D)invocation.getArgument(3),
-                        (E)invocation.getArgument(4));
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a five parameter answer interface
-     * @param answer answer interface
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @param <D> input parameter 4 type
-     * @param <E> input parameter 5 type
-     * @return a new answer object
-     */
-    public static <A, B, C, D, E> Answer<Void> toAnswer(final VoidAnswer5<A, B, C, D, E> answer) {
-        return new Answer<Void>() {
-            @SuppressWarnings("unchecked")
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2),
-                        (D)invocation.getArgument(3),
-                        (E)invocation.getArgument(4));
-                return null;
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a six parameter answer interface
-     *
-     * @param answer answer interface
-     * @param <T> return type
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @param <D> input parameter 4 type
-     * @param <E> input parameter 5 type
-     * @param <F> input parameter 6 type
-     * @return a new answer object
-     */
-    public static <T, A, B, C, D, E, F> Answer<T> toAnswer(final Answer6<T, A, B, C, D, E, F> answer) {
-        return new Answer<T>() {
-            @SuppressWarnings("unchecked")
-            public T answer(InvocationOnMock invocation) throws Throwable {
-                return answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2),
-                        (D)invocation.getArgument(3),
-                        (E)invocation.getArgument(4),
-                        (F)invocation.getArgument(5));
-            }
-        };
-    }
-
-    /**
-     * Construct an answer from a five parameter answer interface
-
-     * @param answer answer interface
-     * @param <A> input parameter 1 type
-     * @param <B> input parameter 2 type
-     * @param <C> input parameter 3 type
-     * @param <D> input parameter 4 type
-     * @param <E> input parameter 5 type
-     * @param <F> input parameter 6 type
-     * @return a new answer object
-     */
-    public static <A, B, C, D, E, F> Answer<Void> toAnswer(final VoidAnswer6<A, B, C, D, E, F> answer) {
-        return new Answer<Void>() {
-            @SuppressWarnings("unchecked")
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                answer.answer(
-                        (A)invocation.getArgument(0),
-                        (B)invocation.getArgument(1),
-                        (C)invocation.getArgument(2),
-                        (D)invocation.getArgument(3),
-                        (E)invocation.getArgument(4),
-                        (F)invocation.getArgument(5));
-                return null;
-            }
-        };
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java b/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
deleted file mode 100644
index af243ccb81..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-
-import org.mockito.internal.invocation.AbstractAwareMethod;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.internal.util.Primitives;
-import org.mockito.internal.util.reflection.GenericMetadataSupport;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.mock.MockCreationSettings;
-
-public class InvocationInfo implements AbstractAwareMethod {
-
-    private final Method method;
-    private final InvocationOnMock invocation;
-
-    public InvocationInfo(InvocationOnMock theInvocation) {
-        this.method = theInvocation.getMethod();
-        this.invocation = theInvocation;
-    }
-
-    public boolean isValidException(Throwable throwable) {
-        Class<?>[] exceptions = method.getExceptionTypes();
-        Class<?> throwableClass = throwable.getClass();
-        for (Class<?> exception : exceptions) {
-            if (exception.isAssignableFrom(throwableClass)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public boolean isValidReturnType(Class<?> clazz) {
-        if (method.getReturnType().isPrimitive() || clazz.isPrimitive()) {
-            return Primitives.primitiveTypeOf(clazz) == Primitives.primitiveTypeOf(method.getReturnType());
-        } else {
-            return method.getReturnType().isAssignableFrom(clazz);
-        }
-    }
-
-    /**
-     * Returns {@code true} is the return type is {@link Void} or represents the pseudo-type to the keyword {@code void}.
-     * E.g:  {@code void foo()} or {@code Void bar()}
-     */
-    public boolean isVoid() {
-        final MockCreationSettings mockSettings = MockUtil.getMockHandler(invocation.getMock())
-            .getMockSettings();
-        Class<?> returnType = GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock())
-            .resolveGenericReturnType(this.method)
-            .rawType();
-        return returnType == Void.TYPE || returnType == Void.class;
-    }
-
-    public String printMethodReturnType() {
-        return method.getReturnType().getSimpleName();
-    }
-
-    public String getMethodName() {
-        return method.getName();
-    }
-
-    public boolean returnsPrimitive() {
-        return method.getReturnType().isPrimitive();
-    }
-
-    public Method getMethod() {
-        return method;
-    }
-
-    public boolean isDeclaredOnInterface() {
-        return method.getDeclaringClass().isInterface();
-    }
-
-    @Override
-    public boolean isAbstract() {
-        return (method.getModifiers() & Modifier.ABSTRACT) != 0;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/Returns.java b/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
deleted file mode 100644
index 145f24516e..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.mockito.internal.exceptions.Reporter.cannotStubVoidMethodWithAReturnValue;
-import static org.mockito.internal.exceptions.Reporter.wrongTypeOfReturnValue;
-
-import java.io.Serializable;
-
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.ValidableAnswer;
-
-public class Returns implements Answer<Object>, ValidableAnswer, Serializable {
-
-    private static final long serialVersionUID = -6245608253574215396L;
-    private final Object value;
-
-    public Returns(Object value) {
-        this.value = value;
-    }
-
-    public Object answer(InvocationOnMock invocation) throws Throwable {
-        return value;
-    }
-
-    @Override
-    public void validateFor(InvocationOnMock invocation) {
-        InvocationInfo invocationInfo = new InvocationInfo(invocation);
-        if (invocationInfo.isVoid()) {
-            throw cannotStubVoidMethodWithAReturnValue(invocationInfo.getMethodName());
-        }
-
-        if (returnsNull() && invocationInfo.returnsPrimitive()) {
-            throw wrongTypeOfReturnValue(invocationInfo.printMethodReturnType(), "null", invocationInfo.getMethodName());
-        }
-
-        if (!returnsNull() && !invocationInfo.isValidReturnType(returnType())) {
-            throw wrongTypeOfReturnValue(invocationInfo.printMethodReturnType(), printReturnType(), invocationInfo.getMethodName());
-        }
-    }
-
-    private String printReturnType() {
-        return value.getClass().getSimpleName();
-    }
-
-    private Class<?> returnType() {
-        return value.getClass();
-    }
-
-    private boolean returnsNull() {
-        return value == null;
-    }
-
-    @Override
-    public String toString() {
-        return "Returns: " + value;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
deleted file mode 100644
index 38c9eec5c2..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.mockito.internal.exceptions.Reporter.invalidArgumentPositionRangeAtInvocationTime;
-import static org.mockito.internal.exceptions.Reporter.invalidArgumentRangeAtIdentityAnswerCreationTime;
-import static org.mockito.internal.exceptions.Reporter.wrongTypeOfArgumentToReturn;
-
-import java.io.Serializable;
-import java.lang.reflect.Method;
-
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.ValidableAnswer;
-
-/**
- * Returns the passed parameter identity at specified index.
- * <p>
- * <p>
- * The <code>argumentIndex</code> represents the index in the argument array of the invocation.
- * </p>
- * <p>
- * If this number equals -1 then the last argument is returned.
- * </p>
- *
- * @see org.mockito.AdditionalAnswers
- * @since 1.9.5
- */
-public class ReturnsArgumentAt implements Answer<Object>, ValidableAnswer, Serializable {
-
-    private static final long serialVersionUID = -589315085166295101L;
-
-    public static final int LAST_ARGUMENT = -1;
-
-    private final int wantedArgumentPosition;
-
-    /**
-     * Build the identity answer to return the argument at the given position in the argument array.
-     *
-     * @param wantedArgumentPosition
-     *            The position of the argument identity to return in the invocation. Using <code>-1</code> indicates the last argument ({@link #LAST_ARGUMENT}).
-     */
-    public ReturnsArgumentAt(int wantedArgumentPosition) {
-        if (wantedArgumentPosition != LAST_ARGUMENT && wantedArgumentPosition < 0) {
-            throw invalidArgumentRangeAtIdentityAnswerCreationTime();
-        }
-        this.wantedArgumentPosition = wantedArgumentPosition;
-    }
-
-    @Override
-    public Object answer(InvocationOnMock invocation) throws Throwable {
-        int argumentPosition = inferWantedArgumentPosition(invocation);
-        validateIndexWithinInvocationRange(invocation, argumentPosition);
-
-        if (wantedArgIndexIsVarargAndSameTypeAsReturnType(invocation.getMethod(), argumentPosition)) {
-            // answer raw vararg array argument
-            return ((Invocation) invocation).getRawArguments()[argumentPosition];
-        }
-
-        // answer expanded argument at wanted position
-        return invocation.getArgument(argumentPosition);
-
-    }
-
-    @Override
-    public void validateFor(InvocationOnMock invocation) {
-        int argumentPosition = inferWantedArgumentPosition(invocation);
-        validateIndexWithinInvocationRange(invocation, argumentPosition);
-        validateArgumentTypeCompatibility((Invocation) invocation, argumentPosition);
-    }
-
-    private int inferWantedArgumentPosition(InvocationOnMock invocation) {
-        if (wantedArgumentPosition == LAST_ARGUMENT)
-            return invocation.getArguments().length - 1;
-
-        return wantedArgumentPosition;
-    }
-
-    private void validateIndexWithinInvocationRange(InvocationOnMock invocation, int argumentPosition) {
-        if (!wantedArgumentPositionIsValidForInvocation(invocation, argumentPosition)) {
-            throw invalidArgumentPositionRangeAtInvocationTime(invocation,
-                                                               wantedArgumentPosition == LAST_ARGUMENT,
-                                                               wantedArgumentPosition);
-        }
-    }
-
-    private void validateArgumentTypeCompatibility(Invocation invocation, int argumentPosition) {
-        InvocationInfo invocationInfo = new InvocationInfo(invocation);
-
-        Class<?> inferredArgumentType = inferArgumentType(invocation, argumentPosition);
-
-        if (!invocationInfo.isValidReturnType(inferredArgumentType)){
-            throw wrongTypeOfArgumentToReturn(invocation,
-                                              invocationInfo.printMethodReturnType(),
-                                              inferredArgumentType,
-                                              wantedArgumentPosition);
-        }
-    }
-
-    private boolean wantedArgIndexIsVarargAndSameTypeAsReturnType(Method method, int argumentPosition) {
-        Class<?>[] parameterTypes = method.getParameterTypes();
-        return method.isVarArgs() &&
-              argumentPosition == /* vararg index */ parameterTypes.length - 1 &&
-              method.getReturnType().isAssignableFrom(parameterTypes[argumentPosition]);
-    }
-
-    private boolean wantedArgumentPositionIsValidForInvocation(InvocationOnMock invocation, int argumentPosition) {
-        if (argumentPosition < 0) {
-            return false;
-        }
-        if (!invocation.getMethod().isVarArgs()) {
-            return invocation.getArguments().length > argumentPosition;
-        }
-        // for all varargs accepts positive ranges
-        return true;
-    }
-
-    private Class<?> inferArgumentType(Invocation invocation, int argumentIndex) {
-        Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
-
-        // Easy when the method is not a vararg
-        if (!invocation.getMethod().isVarArgs()) {
-            Class<?> argumentType = parameterTypes[argumentIndex];
-            Object argumentValue = invocation.getArgument(argumentIndex);
-            // we don't want to return primitive wrapper types
-            if (argumentType.isPrimitive() || argumentValue == null) {
-                return argumentType;
-            }
-
-            return argumentValue.getClass();
-        }
-
-        // Now for varargs
-        int varargIndex = parameterTypes.length - 1; // vararg always last
-
-        if (argumentIndex < varargIndex) {
-            // Same for non vararg arguments
-            return parameterTypes[argumentIndex];
-        }
-        // if wanted argument is vararg
-        if (wantedArgIndexIsVarargAndSameTypeAsReturnType(invocation.getMethod(), argumentIndex)) {
-            // return the vararg array if return type is compatible
-            // because the user probably want to return the array itself if the return type is compatible
-            return parameterTypes[argumentIndex]; // move to MethodInfo ?
-        }
-        // return the type in this vararg array
-        return parameterTypes[varargIndex].getComponentType();
-
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
deleted file mode 100644
index bc1b987f37..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
-import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
-
-import java.io.Serializable;
-
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.ValidableAnswer;
-
-/**
- * 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);
-        throw t;
-    }
-
-    @Override
-    public void validateFor(InvocationOnMock invocation) {
-        if (throwable == null) {
-            throw cannotStubWithNullThrowable();
-        }
-
-        if (throwable instanceof RuntimeException || throwable instanceof Error) {
-            return;
-        }
-
-        if (!new InvocationInfo(invocation).isValidException(throwable)) {
-            throw checkedExceptionInvalid(throwable);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
deleted file mode 100644
index 7ef283ccbe..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import static org.mockito.internal.exceptions.Reporter.delegatedMethodDoesNotExistOnDelegate;
-import static org.mockito.internal.exceptions.Reporter.delegatedMethodHasWrongReturnType;
-
-import java.io.Serializable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/**
- * Internal answer to forward invocations on a real instance.
- *
- * @since 1.9.5
- */
-public class ForwardsInvocations implements Answer<Object>, Serializable {
-    private static final long serialVersionUID = -8343690268123254910L;
-
-    private Object delegatedObject = null ;
-
-    public ForwardsInvocations(Object delegatedObject) {
-        this.delegatedObject = delegatedObject ;
-    }
-
-    public Object answer(InvocationOnMock invocation) throws Throwable {
-        Method mockMethod = invocation.getMethod();
-
-        try {
-            Method delegateMethod = getDelegateMethod(mockMethod);
-
-            if (!compatibleReturnTypes(mockMethod.getReturnType(), delegateMethod.getReturnType())) {
-                throw delegatedMethodHasWrongReturnType(mockMethod, delegateMethod, invocation.getMock(), delegatedObject);
-            }
-
-            Object[] rawArguments = ((Invocation) invocation).getRawArguments();
-            try {
-                delegateMethod.setAccessible(true);
-            } catch (SecurityException ignore) {
-                // try to invoke anyway
-            }
-            return delegateMethod.invoke(delegatedObject, rawArguments);
-        } catch (NoSuchMethodException e) {
-            throw delegatedMethodDoesNotExistOnDelegate(mockMethod, invocation.getMock(), delegatedObject);
-        } catch (InvocationTargetException e) {
-            // propagate the original exception from the delegate
-            throw e.getCause();
-        }
-    }
-
-    private Method getDelegateMethod(Method mockMethod) throws NoSuchMethodException {
-        if (mockMethod.getDeclaringClass().isAssignableFrom(delegatedObject.getClass())) {
-            // Compatible class. Return original method.
-            return mockMethod;
-        } else {
-            // Return method of delegate object with the same signature as mockMethod.
-            return delegatedObject.getClass().getMethod(mockMethod.getName(), mockMethod.getParameterTypes());
-        }
-    }
-
-    private static boolean compatibleReturnTypes(Class<?> superType, Class<?> subType) {
-        return superType.equals(subType) || superType.isAssignableFrom(subType);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
deleted file mode 100644
index 939b8b8f5d..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import static org.mockito.Mockito.withSettings;
-
-import java.io.IOException;
-import java.io.Serializable;
-
-import org.mockito.MockSettings;
-import org.mockito.Mockito;
-import org.mockito.internal.MockitoCore;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.stubbing.InvocationContainerImpl;
-import org.mockito.internal.stubbing.StubbedInvocationMatcher;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.internal.util.reflection.GenericMetadataSupport;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.Stubbing;
-
-/**
- * Returning deep stub implementation.
- *
- * <p>Will return previously created mock if the invocation matches.
- *
- * <p>Supports nested generic information, with this answer you can write code like this :
- *
- * <pre class="code"><code class="java">
- *     interface GenericsNest&lt;K extends Comparable&lt;K&gt; & Cloneable&gt; extends Map&lt;K, Set&lt;Number&gt;&gt; {}
- *
- *     GenericsNest&lt;?&gt; mock = mock(GenericsNest.class, new ReturnsGenericDeepStubs());
- *     Number number = mock.entrySet().iterator().next().getValue().iterator().next();
- * </code></pre>
- * </p>
- *
- * <p>However this answer does not support generics information when the mock has been deserialized.
- *
- * @see org.mockito.Mockito#RETURNS_DEEP_STUBS
- * @see org.mockito.Answers#RETURNS_DEEP_STUBS
- */
-public class ReturnsDeepStubs implements Answer<Object>, Serializable {
-
-    private static final long serialVersionUID = -7105341425736035847L;
-
-    public Object answer(InvocationOnMock invocation) throws Throwable {
-        GenericMetadataSupport returnTypeGenericMetadata =
-            actualParameterizedType(invocation.getMock()).resolveGenericReturnType(invocation.getMethod());
-
-        Class<?> rawType = returnTypeGenericMetadata.rawType();
-        if (!mockitoCore().isTypeMockable(rawType)) {
-            return delegate().returnValueFor(rawType);
-        }
-
-        // When dealing with erased generics, we only receive the Object type as rawType. At this
-        // point, there is nothing to salvage for Mockito. Instead of trying to be smart and generate
-        // a mock that would potentially match the return signature, instead return `null`. This
-        // is valid per the CheckCast JVM instruction and is better than causing a ClassCastException
-        // on runtime.
-        if (rawType.equals(Object.class) && !returnTypeGenericMetadata.hasRawExtraInterfaces()) {
-            return null;
-        }
-
-        return deepStub(invocation, returnTypeGenericMetadata);
-    }
-
-    private Object deepStub(InvocationOnMock invocation, GenericMetadataSupport returnTypeGenericMetadata) throws Throwable {
-        InvocationContainerImpl container = MockUtil.getInvocationContainer(invocation.getMock());
-
-        // matches invocation for verification
-        // TODO why don't we do container.findAnswer here?
-        for (Stubbing stubbing : container.getStubbingsDescending()) {
-            if (container.getInvocationForStubbing().matches(stubbing.getInvocation())) {
-                return stubbing.answer(invocation);
-            }
-        }
-
-        // record deep stub answer
-        StubbedInvocationMatcher stubbing = recordDeepStubAnswer(
-            newDeepStubMock(returnTypeGenericMetadata, invocation.getMock()),
-            container
-                                                                );
-
-        // deep stubbing creates a stubbing and immediately uses it
-        // so the stubbing is actually used by the same invocation
-        stubbing.markStubUsed(stubbing.getInvocation());
-
-        return stubbing.answer(invocation);
-    }
-
-    /**
-     * Creates a mock using the Generics Metadata.
-     *
-     * <li>Finally as we want to mock the actual type, but we want to pass along the contextual generics meta-data
-     * that was resolved for the current return type, for this to happen we associate to the mock an new instance of
-     * {@link ReturnsDeepStubs} answer in which we will store the returned type generic metadata.
-     *
-     * @param returnTypeGenericMetadata The metadata to use to create the new mock.
-     * @param parentMock                The parent of the current deep stub mock.
-     * @return The mock
-     */
-    private Object newDeepStubMock(GenericMetadataSupport returnTypeGenericMetadata, Object parentMock) {
-        MockCreationSettings parentMockSettings = MockUtil.getMockSettings(parentMock);
-        return mockitoCore().mock(
-            returnTypeGenericMetadata.rawType(),
-            withSettingsUsing(returnTypeGenericMetadata, parentMockSettings)
-                                 );
-    }
-
-    private MockSettings withSettingsUsing(GenericMetadataSupport returnTypeGenericMetadata, MockCreationSettings parentMockSettings) {
-        MockSettings mockSettings = returnTypeGenericMetadata.hasRawExtraInterfaces() ?
-                                    withSettings().extraInterfaces(returnTypeGenericMetadata.rawExtraInterfaces())
-                                                                                      : withSettings();
-
-        return propagateSerializationSettings(mockSettings, parentMockSettings)
-            .defaultAnswer(returnsDeepStubsAnswerUsing(returnTypeGenericMetadata));
-    }
-
-    private MockSettings propagateSerializationSettings(MockSettings mockSettings, MockCreationSettings parentMockSettings) {
-        return mockSettings.serializable(parentMockSettings.getSerializableMode());
-    }
-
-    private ReturnsDeepStubs returnsDeepStubsAnswerUsing(final GenericMetadataSupport returnTypeGenericMetadata) {
-        return new ReturnsDeepStubsSerializationFallback(returnTypeGenericMetadata);
-    }
-
-    private StubbedInvocationMatcher recordDeepStubAnswer(final Object mock, InvocationContainerImpl container) {
-        DeeplyStubbedAnswer answer = new DeeplyStubbedAnswer(mock);
-        return container.addAnswer(answer, false, null);
-    }
-
-    protected GenericMetadataSupport actualParameterizedType(Object mock) {
-        CreationSettings mockSettings = (CreationSettings) MockUtil.getMockHandler(mock).getMockSettings();
-        return GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock());
-    }
-
-
-    private static class ReturnsDeepStubsSerializationFallback extends ReturnsDeepStubs implements Serializable {
-        @SuppressWarnings("serial") // not gonna be serialized
-        private final GenericMetadataSupport returnTypeGenericMetadata;
-
-        public ReturnsDeepStubsSerializationFallback(GenericMetadataSupport returnTypeGenericMetadata) {
-            this.returnTypeGenericMetadata = returnTypeGenericMetadata;
-        }
-
-        @Override
-        protected GenericMetadataSupport actualParameterizedType(Object mock) {
-            return returnTypeGenericMetadata;
-        }
-
-        /**
-         * Generics support and serialization with deep stubs don't work together.
-         * <p>
-         * The issue is that GenericMetadataSupport is not serializable because
-         * the type elements inferred via reflection are not serializable. Supporting
-         * serialization would require to replace all types coming from the Java reflection
-         * with our own and still managing type equality with the JDK ones.
-         */
-        private Object writeReplace() throws IOException {
-            return Mockito.RETURNS_DEEP_STUBS;
-        }
-    }
-
-
-    private static class DeeplyStubbedAnswer implements Answer<Object>, Serializable {
-        @SuppressWarnings("serial") // serialization will fail with a nice message if mock not serializable
-        private final Object mock;
-
-        DeeplyStubbedAnswer(Object mock) {
-            this.mock = mock;
-        }
-
-        public Object answer(InvocationOnMock invocation) throws Throwable {
-            return mock;
-        }
-    }
-
-
-    private static MockitoCore mockitoCore() {
-        return LazyHolder.MOCKITO_CORE;
-    }
-
-    private static ReturnsEmptyValues delegate() {
-        return LazyHolder.DELEGATE;
-    }
-
-    private static class LazyHolder {
-        private static final MockitoCore MOCKITO_CORE = new MockitoCore();
-        private static final ReturnsEmptyValues DELEGATE = new ReturnsEmptyValues();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
deleted file mode 100644
index 8e92a0d93e..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import static org.mockito.internal.util.ObjectMethodsGuru.isCompareToMethod;
-import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-
-import java.io.Serializable;
-import java.util.*;
-
-import org.mockito.internal.util.JavaEightUtil;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.internal.util.Primitives;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.mock.MockName;
-import org.mockito.stubbing.Answer;
-
-/**
- * Default answer of every Mockito mock.
- * <ul>
- * <li>
- * Returns appropriate primitive for primitive-returning methods
- * </li>
- * <li>
- * Returns consistent values for primitive wrapper classes (e.g. int-returning method returns 0 <b>and</b> Integer-returning method returns 0, too)
- * </li>
- * <li>
- * Returns empty collection for collection-returning methods (works for most commonly used collection types)
- * </li>
- * <li>
- * Returns description of mock for toString() method
- * </li>
- * <li>
- * Returns zero if references are equals otherwise non-zero for Comparable#compareTo(T other) method (see issue 184)
- * </li>
- * <li>
- * Returns an {@code java.util.Optional#empty() empty Optional} for Optional. Similarly for primitive optional variants.
- * </li>
- * <li>
- * Returns an {@code java.util.stream.Stream#empty() empty Stream} for Stream. Similarly for primitive stream variants.
- * </li>
- * <li>
- * Returns null for everything else
- * </li>
- * </ul>
- */
-public class ReturnsEmptyValues implements Answer<Object>, Serializable {
-
-    private static final long serialVersionUID = 1998191268711234347L;
-
-
-    /* (non-Javadoc)
-     * @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
-     */
-    public Object answer(InvocationOnMock invocation) {
-        if (isToStringMethod(invocation.getMethod())) {
-            Object mock = invocation.getMock();
-            MockName name = MockUtil.getMockName(mock);
-            if (name.isDefault()) {
-                return "Mock for " + MockUtil.getMockSettings(mock).getTypeToMock().getSimpleName() + ", hashCode: " + mock.hashCode();
-            } else {
-                return name.toString();
-            }
-        } else if (isCompareToMethod(invocation.getMethod())) {
-            //see issue 184.
-            //mocks by default should return 0 if references are the same, otherwise some other value because they are not the same. Hence we return 1 (anything but 0 is good).
-            //Only for compareTo() method by the Comparable interface
-            return invocation.getMock() == invocation.getArgument(0) ? 0 : 1;
-        }
-
-        Class<?> returnType = invocation.getMethod().getReturnType();
-        return returnValueFor(returnType);
-    }
-
-    Object returnValueFor(Class<?> type) {
-        if (Primitives.isPrimitiveOrWrapper(type)) {
-            return Primitives.defaultValue(type);
-            //new instances are used instead of Collections.emptyList(), etc.
-            //to avoid UnsupportedOperationException if code under test modifies returned collection
-        } else if (type == Iterable.class) {
-            return new ArrayList<Object>(0);
-        } else if (type == Collection.class) {
-            return new LinkedList<Object>();
-        } else if (type == Set.class) {
-            return new HashSet<Object>();
-        } else if (type == HashSet.class) {
-            return new HashSet<Object>();
-        } else if (type == SortedSet.class) {
-            return new TreeSet<Object>();
-        } else if (type == TreeSet.class) {
-            return new TreeSet<Object>();
-        } else if (type == LinkedHashSet.class) {
-            return new LinkedHashSet<Object>();
-        } else if (type == List.class) {
-            return new LinkedList<Object>();
-        } else if (type == LinkedList.class) {
-            return new LinkedList<Object>();
-        } else if (type == ArrayList.class) {
-            return new ArrayList<Object>();
-        } else if (type == Map.class) {
-            return new HashMap<Object, Object>();
-        } else if (type == HashMap.class) {
-            return new HashMap<Object, Object>();
-        } else if (type == SortedMap.class) {
-            return new TreeMap<Object, Object>();
-        } else if (type == TreeMap.class) {
-            return new TreeMap<Object, Object>();
-        } else if (type == LinkedHashMap.class) {
-            return new LinkedHashMap<Object, Object>();
-        } else if ("java.util.Optional".equals(type.getName())) {
-            return JavaEightUtil.emptyOptional();
-        } else if ("java.util.OptionalDouble".equals(type.getName())) {
-            return JavaEightUtil.emptyOptionalDouble();
-        } else if ("java.util.OptionalInt".equals(type.getName())) {
-            return JavaEightUtil.emptyOptionalInt();
-        } else if ("java.util.OptionalLong".equals(type.getName())) {
-            return JavaEightUtil.emptyOptionalLong();
-        } else if ("java.util.stream.Stream".equals(type.getName())) {
-            return JavaEightUtil.emptyStream();
-        } else if ("java.util.stream.DoubleStream".equals(type.getName())) {
-            return JavaEightUtil.emptyDoubleStream();
-        } else if ("java.util.stream.IntStream".equals(type.getName())) {
-            return JavaEightUtil.emptyIntStream();
-        } else if ("java.util.stream.LongStream".equals(type.getName())) {
-            return JavaEightUtil.emptyLongStream();
-        }
-
-        //Let's not care about the rest of collections.
-        return null;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
deleted file mode 100755
index 867c8794d8..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import java.io.Serializable;
-
-import org.mockito.Mockito;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-public class ReturnsMocks implements Answer<Object>, Serializable {
-
-    private static final long serialVersionUID = -6755257986994634579L;
-    private final Answer<Object> delegate = new ReturnsMoreEmptyValues();
-
-    @Override
-    public Object answer(final InvocationOnMock invocation) throws Throwable {
-        Object defaultReturnValue = delegate.answer(invocation);
-
-        if (defaultReturnValue != null) {
-            return defaultReturnValue;
-        }
-
-        return RetrieveGenericsForDefaultAnswers.returnTypeForMockWithCorrectGenerics(invocation,
-            new RetrieveGenericsForDefaultAnswers.AnswerCallback() {
-                @Override
-                public Object apply(Class<?> type) {
-                    if (type == null) {
-                        return null;
-                    }
-
-                    return Mockito
-                        .mock(type, new MockSettingsImpl<Object>().defaultAnswer(ReturnsMocks.this));
-                }
-            });
-    }
-}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
deleted file mode 100644
index ae5c01d03d..0000000000
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import static org.mockito.internal.exceptions.Reporter.smartNullPointerException;
-import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-
-import java.io.Serializable;
-
-import org.mockito.Mockito;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.invocation.Location;
-import org.mockito.stubbing.Answer;
-
-/**
- * Optional Answer that can be used with
- * {@link Mockito#mock(Class, Answer)}
- * <p>
- * This implementation can be helpful when working with legacy code. Unstubbed
- * methods often return null. If your code uses the object returned by an
- * unstubbed call you get a NullPointerException. This implementation of
- * Answer returns SmartNulls instead of nulls.
- * SmartNull gives nicer exception message than NPE because it points out the
- * line where unstubbed method was called. You just click on the stack trace.
- * <p>
- * ReturnsSmartNulls first tries to return ordinary return values (see
- * {@link ReturnsMoreEmptyValues}) then it tries to return SmartNull. If the
- * return type is not mockable (e.g. final) then ordinary null is returned.
- * <p>
- * ReturnsSmartNulls will be probably the default return values strategy in
- * Mockito 2.1.0
- */
-public class ReturnsSmartNulls implements Answer<Object>, Serializable {
-
-    private static final long serialVersionUID = 7618312406617949441L;
-
-    private final Answer<Object> delegate = new ReturnsMoreEmptyValues();
-
-    @Override
-    public Object answer(final InvocationOnMock invocation) throws Throwable {
-        Object defaultReturnValue = delegate.answer(invocation);
-
-        if (defaultReturnValue != null) {
-            return defaultReturnValue;
-        }
-
-        return RetrieveGenericsForDefaultAnswers.returnTypeForMockWithCorrectGenerics(invocation,
-            new RetrieveGenericsForDefaultAnswers.AnswerCallback() {
-                @Override
-                public Object apply(Class<?> type) {
-                    if (type == null) {
-                        return null;
-                    }
-
-                    return Mockito.mock(type, new ThrowsSmartNullPointer(invocation, new LocationImpl()));
-                }
-            });
-    }
-
-    private static class ThrowsSmartNullPointer implements Answer {
-
-        private final InvocationOnMock unstubbedInvocation;
-
-        private final Location location;
-
-        ThrowsSmartNullPointer(InvocationOnMock unstubbedInvocation, Location location) {
-            this.unstubbedInvocation = unstubbedInvocation;
-            this.location = location;
-        }
-
-        public Object answer(InvocationOnMock currentInvocation) throws Throwable {
-            if (isToStringMethod(currentInvocation.getMethod())) {
-                return "SmartNull returned by this unstubbed method call on a mock:\n" +
-                    unstubbedInvocation.toString();
-            }
-
-            throw smartNullPointerException(unstubbedInvocation.toString(), location);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/JavaEightUtil.java b/src/main/java/org/mockito/internal/util/JavaEightUtil.java
deleted file mode 100644
index ce85487a8b..0000000000
--- a/src/main/java/org/mockito/internal/util/JavaEightUtil.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import java.lang.reflect.Method;
-
-import org.mockito.internal.creation.instance.InstantiationException;
-
-/**
- * Helper class to work with features that were introduced in Java versions after 1.5.
- * This class uses reflection in most places to avoid coupling with a newer JDK.
- */
-public final class JavaEightUtil {
-
-    // No need for volatile, these optionals are already safe singletons.
-    private static Object emptyOptional;
-    private static Object emptyOptionalDouble;
-    private static Object emptyOptionalInt;
-    private static Object emptyOptionalLong;
-
-    private JavaEightUtil() {
-        // utility class
-    }
-
-    /**
-     * Creates an empty Optional using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty Optional.
-     */
-    public static Object emptyOptional() {
-        // no need for double-checked locking
-        if (emptyOptional != null) {
-            return emptyOptional;
-        }
-
-        return emptyOptional = invokeNullaryFactoryMethod("java.util.Optional", "empty");
-    }
-
-
-    /**
-     * Creates an empty OptionalDouble using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty OptionalDouble.
-     */
-    public static Object emptyOptionalDouble() {
-        // no need for double-checked locking
-        if (emptyOptionalDouble != null) {
-            return emptyOptionalDouble;
-        }
-
-        return emptyOptionalDouble = invokeNullaryFactoryMethod("java.util.OptionalDouble", "empty");
-    }
-
-    /**
-     * Creates an empty OptionalInt using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty OptionalInt.
-     */
-    public static Object emptyOptionalInt() {
-        // no need for double-checked locking
-        if (emptyOptionalInt != null) {
-            return emptyOptionalInt;
-        }
-
-        return emptyOptionalInt = invokeNullaryFactoryMethod("java.util.OptionalInt", "empty");
-    }
-
-    /**
-     * Creates an empty OptionalLong using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty OptionalLong.
-     */
-    public static Object emptyOptionalLong() {
-        // no need for double-checked locking
-        if (emptyOptionalLong != null) {
-            return emptyOptionalLong;
-        }
-
-        return emptyOptionalLong = invokeNullaryFactoryMethod("java.util.OptionalLong", "empty");
-    }
-
-    /**
-     * Creates an empty Stream using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty Stream.
-     */
-    public static Object emptyStream() {
-        // note: the empty stream can not be stored as a singleton.
-        return invokeNullaryFactoryMethod("java.util.stream.Stream", "empty");
-    }
-
-    /**
-     * Creates an empty DoubleStream using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty DoubleStream.
-     */
-    public static Object emptyDoubleStream() {
-        // note: the empty stream can not be stored as a singleton.
-        return invokeNullaryFactoryMethod("java.util.stream.DoubleStream", "empty");
-    }
-
-    /**
-     * Creates an empty IntStream using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty IntStream.
-     */
-    public static Object emptyIntStream() {
-        // note: the empty stream can not be stored as a singleton.
-        return invokeNullaryFactoryMethod("java.util.stream.IntStream", "empty");
-    }
-
-    /**
-     * Creates an empty LongStream using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @return an empty LongStream.
-     */
-    public static Object emptyLongStream() {
-        // note: the empty stream can not be stored as a singleton.
-        return invokeNullaryFactoryMethod("java.util.stream.LongStream", "empty");
-    }
-
-    /**
-     * Invokes a nullary static factory method using reflection to stay backwards-compatible with older JDKs.
-     *
-     * @param fqcn The fully qualified class name of the type to be produced.
-     * @param methodName The name of the factory method.
-     * @return the object produced.
-     */
-    private static Object invokeNullaryFactoryMethod(final String fqcn, final String methodName) {
-        try {
-            final Class<?> type = Class.forName(fqcn);
-            final Method method = type.getMethod(methodName);
-
-            return method.invoke(null);
-            // any exception is really unexpected since the type name has
-            // already been verified
-        } catch (final Exception e) {
-            throw new InstantiationException(
-                    String.format("Could not create %s#%s(): %s", fqcn, methodName, e), e);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/MockNameImpl.java b/src/main/java/org/mockito/internal/util/MockNameImpl.java
deleted file mode 100644
index 6a1459145f..0000000000
--- a/src/main/java/org/mockito/internal/util/MockNameImpl.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import java.io.Serializable;
-
-import org.mockito.mock.MockName;
-
-public class MockNameImpl implements MockName, Serializable {
-
-    private static final long serialVersionUID = 8014974700844306925L;
-    private final String mockName;
-    private boolean defaultName;
-
-    @SuppressWarnings("unchecked")
-    public MockNameImpl(String mockName, Class<?> classToMock) {
-        if (mockName == null) {
-            this.mockName = toInstanceName(classToMock);
-            this.defaultName = true;
-        } else {
-            this.mockName = mockName;
-        }
-    }
-
-    public MockNameImpl(String mockName) {
-        this.mockName = mockName;
-    }
-
-    private static String toInstanceName(Class<?> clazz) {
-        String className = clazz.getSimpleName();
-        if (className.length() == 0) {
-            //it's an anonymous class, let's get name from the parent
-            className = clazz.getSuperclass().getSimpleName();
-        }
-        //lower case first letter
-        return className.substring(0, 1).toLowerCase() + className.substring(1);
-    }
-
-    public boolean isDefault() {
-        return defaultName;
-    }
-
-    @Override
-    public String toString() {
-        return mockName;
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/MockUtil.java b/src/main/java/org/mockito/internal/util/MockUtil.java
deleted file mode 100644
index ec5e7a1f7a..0000000000
--- a/src/main/java/org/mockito/internal/util/MockUtil.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
-
-import org.mockito.Mockito;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.stubbing.InvocationContainerImpl;
-import org.mockito.internal.util.reflection.LenientCopyTool;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.MockName;
-import org.mockito.plugins.MockMaker;
-import org.mockito.plugins.MockMaker.TypeMockability;
-
-@SuppressWarnings("unchecked")
-public class MockUtil {
-
-    private static final MockMaker mockMaker = Plugins.getMockMaker();
-
-    private MockUtil() {}
-
-    public static TypeMockability typeMockabilityOf(Class<?> type) {
-      return mockMaker.isTypeMockable(type);
-    }
-
-    public static <T> T createMock(MockCreationSettings<T> settings) {
-        MockHandler mockHandler =  createMockHandler(settings);
-
-        T mock = mockMaker.createMock(settings, mockHandler);
-
-        Object spiedInstance = settings.getSpiedInstance();
-        if (spiedInstance != null) {
-            new LenientCopyTool().copyToMock(spiedInstance, mock);
-        }
-
-        return mock;
-    }
-
-    public static <T> void resetMock(T mock) {
-        MockHandler oldHandler = getMockHandler(mock);
-        MockCreationSettings settings = oldHandler.getMockSettings();
-        MockHandler newHandler = createMockHandler(settings);
-
-        mockMaker.resetMock(mock, newHandler, settings);
-    }
-
-    public static <T> MockHandler<T> getMockHandler(T mock) {
-        if (mock == null) {
-            throw new NotAMockException("Argument should be a mock, but is null!");
-        }
-
-        if (isMock(mock)) {
-            return mockMaker.getHandler(mock);
-        } else {
-            throw new NotAMockException("Argument should be a mock, but is: " + mock.getClass());
-        }
-    }
-
-    public static InvocationContainerImpl getInvocationContainer(Object mock) {
-        return (InvocationContainerImpl) getMockHandler(mock).getInvocationContainer();
-    }
-
-    public static boolean isSpy(Object mock) {
-        return isMock(mock) && getMockSettings(mock).getDefaultAnswer() == Mockito.CALLS_REAL_METHODS;
-    }
-
-    public static boolean isMock(Object mock) {
-        // TODO SF (perf tweak) in our codebase we call mockMaker.getHandler() multiple times unnecessarily
-        // This is not ideal because getHandler() can be expensive (reflective calls inside mock maker)
-        // The frequent pattern in the codebase are separate calls to: 1) isMock(mock) then 2) getMockHandler(mock)
-        // We could replace it with using mockingDetails().isMock()
-        // Let's refactor the codebase and use new mockingDetails() in all relevant places.
-        // Potentially we could also move other methods to MockitoMock, some other candidates: getInvocationContainer, isSpy, etc.
-        // This also allows us to reuse our public API MockingDetails
-        return mock != null && mockMaker.getHandler(mock) != null;
-    }
-
-    public static MockName getMockName(Object mock) {
-        return getMockHandler(mock).getMockSettings().getMockName();
-    }
-
-    public static void maybeRedefineMockName(Object mock, String newName) {
-        MockName mockName = getMockName(mock);
-        //TODO SF hacky...
-        MockCreationSettings mockSettings = getMockHandler(mock).getMockSettings();
-        if (mockName.isDefault() && mockSettings instanceof CreationSettings) {
-            ((CreationSettings) mockSettings).setMockName(new MockNameImpl(newName));
-        }
-    }
-
-    public static MockCreationSettings getMockSettings(Object mock) {
-        return getMockHandler(mock).getMockSettings();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/Platform.java b/src/main/java/org/mockito/internal/util/Platform.java
deleted file mode 100644
index 48ae3ab282..0000000000
--- a/src/main/java/org/mockito/internal/util/Platform.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.mockito.internal.util.StringUtil.join;
-
-import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public abstract class Platform {
-
-    private static final Pattern JAVA_8_RELEASE_VERSION_SCHEME = Pattern.compile("1\\.8\\.0_(\\d+)(?:-ea)?(?:-b\\d+)?");
-    private static final Pattern JAVA_8_DEV_VERSION_SCHEME = Pattern.compile("1\\.8\\.0b\\d+_u(\\d+)");
-    public static final String JAVA_VERSION = System.getProperty("java.specification.version");
-    public static final String JVM_VERSION = System.getProperty("java.runtime.version");
-    public static final String JVM_VENDOR = System.getProperty("java.vm.vendor");
-    public static final String JVM_VENDOR_VERSION = System.getProperty("java.vm.version");
-    public static final String JVM_NAME = System.getProperty("java.vm.name");
-    public static final String JVM_INFO = System.getProperty("java.vm.info");
-    public static final String OS_NAME = System.getProperty("os.name");
-    public static final String OS_VERSION = System.getProperty("os.version");
-
-    private Platform() {
-    }
-
-    public static boolean isAndroid() {
-        return System.getProperty("java.vendor", "").toLowerCase(Locale.US).contains("android");
-    }
-
-    public static boolean isAndroidMockMakerRequired() {
-        return Boolean.getBoolean("org.mockito.mock.android");
-    }
-
-    public static String describe() {
-        String description = String.format("Java               : %s\n" +
-                             "JVM vendor name    : %s\n" +
-                             "JVM vendor version : %s\n" +
-                             "JVM name           : %s\n" +
-                             "JVM version        : %s\n" +
-                             "JVM info           : %s\n" +
-                             "OS name            : %s\n" +
-                             "OS version         : %s\n",
-                             JAVA_VERSION,
-                             JVM_VENDOR,
-                             JVM_VENDOR_VERSION,
-                             JVM_NAME,
-                             JVM_VERSION,
-                             JVM_INFO,
-                             OS_NAME,
-                             OS_VERSION);
-        if (isAndroid()) {
-            description = join(
-                    "IMPORTANT INFORMATION FOR ANDROID USERS:",
-                    "",
-                    "The regular Byte Buddy mock makers cannot generate code on an Android VM!",
-                    "To resolve this, please use the 'mockito-android' dependency for your application:",
-                    "http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22mockito-android%22%20g%3A%22org.mockito%22",
-                    "",
-                    description
-            );
-        }
-        return description;
-    }
-
-    public static boolean isJava8BelowUpdate45() {
-        return isJava8BelowUpdate45(JVM_VERSION);
-    }
-
-    static boolean isJava8BelowUpdate45(String jvmVersion) {
-        Matcher matcher = JAVA_8_RELEASE_VERSION_SCHEME.matcher(jvmVersion);
-        if (matcher.matches()) {
-            int update = Integer.parseInt(matcher.group(1));
-            return update < 45;
-        }
-
-        matcher = JAVA_8_DEV_VERSION_SCHEME.matcher(jvmVersion);
-        if (matcher.matches()) {
-            int update = Integer.parseInt(matcher.group(1));
-            return update < 45;
-        }
-
-        matcher = Pattern.compile("1\\.8\\.0-b\\d+").matcher(jvmVersion);
-        return matcher.matches();
-
-    }
-
-    public static String warnForVM(String vmName1, String warnMessage1,
-                                   String vmName2, String warnMessage2) {
-        return warnForVM(JVM_NAME,
-                         vmName1, warnMessage1,
-                         vmName2, warnMessage2);
-    }
-
-    static String warnForVM(String current,
-                            String vmName1, String warnMessage1,
-                            String vmName2, String warnMessage2) {
-        if (vmName1 != null && current.contains(vmName1)) {
-            return warnMessage1;
-        }
-        if (vmName2 != null && current.contains(vmName2)) {
-            return warnMessage2;
-        }
-        return "";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java b/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
deleted file mode 100644
index d8b581c070..0000000000
--- a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.collections;
-
-import org.mockito.internal.util.MockUtil;
-
-/**
- * hashCode and equals safe mock wrapper.
- *
- * <p>
- *     It doesn't use the actual mock {@link Object#hashCode} and {@link Object#equals} method as they might
- *     throw an NPE if those method cannot be stubbed <em>even internally</em>.
- * </p>
- *
- * <p>
- *     Instead the strategy is :
- *     <ul>
- *         <li>For hashCode : <strong>use {@link System#identityHashCode}</strong></li>
- *         <li>For equals : <strong>use the object reference equality</strong></li>
- *     </ul>
- * </p>
- *
- * @see HashCodeAndEqualsSafeSet
- */
-public class HashCodeAndEqualsMockWrapper {
-
-    private final Object mockInstance;
-
-    public HashCodeAndEqualsMockWrapper(Object mockInstance) {
-        this.mockInstance = mockInstance;
-    }
-
-    public Object get() {
-        return mockInstance;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (!(o instanceof HashCodeAndEqualsMockWrapper)) return false;
-
-        HashCodeAndEqualsMockWrapper that = (HashCodeAndEqualsMockWrapper) o;
-
-        return mockInstance == that.mockInstance;
-    }
-
-    @Override
-    public int hashCode() {
-        return System.identityHashCode(mockInstance);
-    }
-
-    public static HashCodeAndEqualsMockWrapper of(Object mock) {
-        return new HashCodeAndEqualsMockWrapper(mock);
-    }
-
-    @Override public String toString() {
-        return "HashCodeAndEqualsMockWrapper{" +
-                "mockInstance=" + (MockUtil.isMock(mockInstance) ? MockUtil.getMockName(mockInstance) : typeInstanceString()) +
-                '}';
-    }
-
-    private String typeInstanceString() {
-        return mockInstance.getClass().getSimpleName() + "(" + System.identityHashCode(mockInstance) + ")";
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/collections/Iterables.java b/src/main/java/org/mockito/internal/util/collections/Iterables.java
deleted file mode 100644
index 933ce893d4..0000000000
--- a/src/main/java/org/mockito/internal/util/collections/Iterables.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.collections;
-
-import java.util.Enumeration;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-/**
- * Utilities for Iterables
- */
-public class Iterables {
-
-    /**
-     * Converts enumeration into iterable
-     */
-    public static <T> Iterable<T> toIterable(Enumeration<T> in) {
-        List<T> out = new LinkedList<T>();
-        while(in.hasMoreElements()) {
-            out.add(in.nextElement());
-        }
-        return out;
-    }
-
-    /**
-     * Returns first element of provided iterable or fails fast when iterable is empty.
-     *
-     * @param iterable non-empty iterable
-     * @return first element of supplied iterable
-     * @throws IllegalArgumentException when supplied iterable is empty
-     */
-    public static <T> T firstOf(Iterable<T> iterable) {
-        Iterator<T> iterator = iterable.iterator();
-        if (!iterator.hasNext()) {
-            throw new IllegalArgumentException("Cannot provide 1st element from empty iterable: " + iterable);
-        }
-        return iterator.next();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/collections/ListUtil.java b/src/main/java/org/mockito/internal/util/collections/ListUtil.java
deleted file mode 100644
index ecad009f48..0000000000
--- a/src/main/java/org/mockito/internal/util/collections/ListUtil.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.collections;
-
-import java.util.Collection;
-import java.util.LinkedList;
-
-/**
- * Basic list/collection operators.
- * We know that there are existing libraries that implement those use cases neatly.
- * However, we want to keep Mockito dependencies minimal.
- * In Java8 we should be able to get rid of this class.
- */
-public class ListUtil {
-
-    public static <T> LinkedList<T> filter(Collection<T> collection, Filter<T> filter) {
-        LinkedList<T> filtered = new LinkedList<T>();
-        for (T t : collection) {
-            if (!filter.isOut(t)) {
-                filtered.add(t);
-            }
-        }
-        return filtered;
-    }
-
-    public static <From, To> LinkedList<To> convert(Collection<From> collection, Converter<From, To> converter) {
-        LinkedList<To> converted = new LinkedList<To>();
-        for (From f: collection) {
-            converted.add(converter.convert(f));
-        }
-        return converted;
-    }
-
-    public interface Filter<T> {
-        boolean isOut(T object);
-    }
-
-    public interface Converter<From, To> {
-        To convert(From from);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/io/IOUtil.java b/src/main/java/org/mockito/internal/util/io/IOUtil.java
deleted file mode 100644
index 2752a2c834..0000000000
--- a/src/main/java/org/mockito/internal/util/io/IOUtil.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.io;
-
-import java.io.*;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.exceptions.base.MockitoException;
-
-/**
- * IO utils. A bit of reinventing the wheel but we don't want extra dependencies at this stage and we want to be java.
- */
-public class IOUtil {
-
-    /**
-     * Writes text to file
-     */
-    public static void writeText(String text, File output) {
-        PrintWriter pw = null;
-        try {
-            pw = new PrintWriter(new FileWriter(output));
-            pw.write(text);
-        } catch (Exception e) {
-            throw new MockitoException("Problems writing text to file: " + output, e);
-        } finally {
-            close(pw);
-        }
-    }
-
-    public static Collection<String> readLines(InputStream is) {
-        List<String> out = new LinkedList<String>();
-        BufferedReader r = new BufferedReader(new InputStreamReader(is));
-        String line;
-        try {
-            while((line = r.readLine()) != null) {
-                out.add(line);
-            }
-        } catch (IOException e) {
-            throw new MockitoException("Problems reading from: " + is, e);
-        }
-        return out;
-    }
-
-    /**
-     * Closes the target. Does nothing when target is null. Is silent.
-     *
-     * @param closeable the target, may be null
-     */
-    public static void closeQuietly(Closeable closeable) {
-        try {
-            close(closeable);
-        } catch (MockitoException ignored) {
-            //ignore, for backwards compatibility
-        }
-    }
-
-    /**
-     * Closes the target. Does nothing when target is null. Is not silent and exceptions are rethrown.
-     *
-     * @param closeable the target, may be null
-     */
-    public static void close(Closeable closeable) {
-        if (closeable != null) {
-            try {
-                closeable.close();
-            } catch (IOException e) {
-                throw new MockitoException("Problems closing stream: " + closeable, e);
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java b/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
deleted file mode 100644
index f02acbebfb..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.AccessibleObject;
-
-public class AccessibilityChanger {
-
-    private Boolean wasAccessible = null;
-
-    /**
-     * safely disables access
-     */
-    public void safelyDisableAccess(AccessibleObject accessibleObject) {
-        assert wasAccessible != null : "accessibility info shall not be null";
-        try {
-            accessibleObject.setAccessible(wasAccessible);
-        } catch (Throwable t) {
-            //ignore
-        }
-    }
-
-    /**
-     * changes the accessibleObject accessibility and returns true if accessibility was changed
-     */
-    public void enableAccess(AccessibleObject accessibleObject) {
-        wasAccessible = accessibleObject.isAccessible();
-        accessibleObject.setAccessible(true);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java b/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
deleted file mode 100644
index 9ef9481b80..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Locale;
-
-/**
- * This utility class will call the setter of the property to inject a new value.
- */
-public class BeanPropertySetter {
-
-    private static final String SET_PREFIX = "set";
-
-    private final Object target;
-    private final boolean reportNoSetterFound;
-    private final Field field;
-
-    /**
-     * New BeanPropertySetter
-     * @param target The target on which the setter must be invoked
-     * @param propertyField The field that should be accessed with the setter
-     * @param reportNoSetterFound Allow the set method to raise an Exception if the setter cannot be found
-     */
-    public BeanPropertySetter(final Object target, final Field propertyField, boolean reportNoSetterFound) {
-        this.field = propertyField;
-        this.target = target;
-        this.reportNoSetterFound = reportNoSetterFound;
-    }
-
-    /**
-     * New BeanPropertySetter that don't report failure
-     * @param target The target on which the setter must be invoked
-     * @param propertyField The propertyField that must be accessed through a setter
-     */
-    public BeanPropertySetter(final Object target, final Field propertyField) {
-        this(target, propertyField, false);
-    }
-
-    /**
-     * Set the value to the property represented by this {@link BeanPropertySetter}
-     * @param value the new value to pass to the property setter
-     * @return <code>true</code> if the value has been injected, <code>false</code> otherwise
-     * @throws RuntimeException Can be thrown if the setter threw an exception, if the setter is not accessible
-     *          or, if <code>reportNoSetterFound</code> and setter could not be found.
-     */
-    public boolean set(final Object value) {
-
-        AccessibilityChanger changer = new AccessibilityChanger();
-        Method writeMethod = null;
-        try {
-            writeMethod = target.getClass().getMethod(setterName(field.getName()), field.getType());
-
-            changer.enableAccess(writeMethod);
-            writeMethod.invoke(target, value);
-            return true;
-        } catch (InvocationTargetException e) {
-            throw new RuntimeException("Setter '" + writeMethod + "' of '" + target + "' with value '" + value + "' threw exception : '" + e.getTargetException() + "'", e);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException("Access not authorized on field '" + field + "' of object '" + target + "' with value: '" + value + "'", e);
-        } catch (NoSuchMethodException e) {
-            reportNoSetterFound();
-        } finally {
-            if(writeMethod != null) {
-                changer.safelyDisableAccess(writeMethod);
-            }
-        }
-
-        reportNoSetterFound();
-        return false;
-    }
-
-    /**
-     * Retrieve the setter name from the field name.
-     *
-     * <p>Implementation is based on the code of {@link java.beans.Introspector}.</p>
-     *
-     * @param fieldName the Field name
-     * @return Setter name.
-     */
-    private String setterName(String fieldName) {
-        return new StringBuilder(SET_PREFIX)
-                .append(fieldName.substring(0, 1).toUpperCase(Locale.ENGLISH))
-                .append(fieldName.substring(1))
-                .toString();
-    }
-
-    private void reportNoSetterFound() {
-        if(reportNoSetterFound) {
-            throw new RuntimeException("Problems setting value on object: [" + target + "] for property : [" + field.getName() + "], setter not found");
-        }
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldCopier.java b/src/main/java/org/mockito/internal/util/reflection/FieldCopier.java
deleted file mode 100644
index 67f7203944..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/FieldCopier.java
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-
-public class FieldCopier {
-
-    public <T> void copyValue(T from, T to, Field field) throws IllegalAccessException {
-        Object value = field.get(from);
-        field.set(to, value);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java b/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
deleted file mode 100644
index e247d18c13..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static java.lang.reflect.Modifier.isStatic;
-
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.MockUtil;
-
-/**
- * Initialize a field with type instance if a default constructor can be found.
- *
- * <p>
- * If the given field is already initialized, then <strong>the actual instance is returned</strong>.
- * This initializer doesn't work with inner classes, local classes, interfaces or abstract types.
- * </p>
- *
- */
-public class FieldInitializer {
-
-    private final Object fieldOwner;
-    private final Field field;
-    private final ConstructorInstantiator instantiator;
-
-
-    /**
-     * Prepare initializer with the given field on the given instance.
-     *
-     * <p>
-     * This constructor fail fast if the field type cannot be handled.
-     * </p>
-     *
-     * @param fieldOwner Instance of the test.
-     * @param field Field to be initialize.
-     */
-    public FieldInitializer(Object fieldOwner, Field field) {
-        this(fieldOwner, field, new NoArgConstructorInstantiator(fieldOwner, field));
-    }
-
-    /**
-     * Prepare initializer with the given field on the given instance.
-     *
-     * <p>
-     * This constructor fail fast if the field type cannot be handled.
-     * </p>
-     *
-     * @param fieldOwner Instance of the test.
-     * @param field Field to be initialize.
-     * @param argResolver Constructor parameters resolver
-     */
-    public FieldInitializer(Object fieldOwner, Field field, ConstructorArgumentResolver argResolver) {
-        this(fieldOwner, field, new ParameterizedConstructorInstantiator(fieldOwner, field, argResolver));
-    }
-
-    private FieldInitializer(Object fieldOwner, Field field, ConstructorInstantiator instantiator) {
-        if(new FieldReader(fieldOwner, field).isNull()) {
-            checkNotLocal(field);
-            checkNotInner(field);
-            checkNotInterface(field);
-            checkNotEnum(field);
-            checkNotAbstract(field);
-
-        }
-        this.fieldOwner = fieldOwner;
-        this.field = field;
-        this.instantiator = instantiator;
-    }
-
-    /**
-     * Initialize field if not initialized and return the actual instance.
-     *
-     * @return Actual field instance.
-     */
-    public FieldInitializationReport initialize() {
-        final AccessibilityChanger changer = new AccessibilityChanger();
-        changer.enableAccess(field);
-
-        try {
-            return acquireFieldInstance();
-        } catch(IllegalAccessException e) {
-            throw new MockitoException("Problems initializing field '" + field.getName() + "' of type '" + field.getType().getSimpleName() + "'", e);
-        } finally {
-            changer.safelyDisableAccess(field);
-        }
-    }
-
-    private void checkNotLocal(Field field) {
-        if(field.getType().isLocalClass()) {
-            throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is a local class.");
-        }
-    }
-
-    private void checkNotInner(Field field) {
-        Class<?> type = field.getType();
-        if(type.isMemberClass() && !isStatic(type.getModifiers())) {
-            throw new MockitoException("the type '" + type.getSimpleName() + "' is an inner non static class.");
-        }
-    }
-
-    private void checkNotInterface(Field field) {
-        if(field.getType().isInterface()) {
-            throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an interface.");
-        }
-    }
-
-    private void checkNotAbstract(Field field) {
-        if(Modifier.isAbstract(field.getType().getModifiers())) {
-            throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an abstract class.");
-        }
-    }
-
-    private void checkNotEnum(Field field) {
-        if(field.getType().isEnum()) {
-            throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an enum.");
-        }
-    }
-
-
-    private FieldInitializationReport acquireFieldInstance() throws IllegalAccessException {
-        Object fieldInstance = field.get(fieldOwner);
-        if(fieldInstance != null) {
-            return new FieldInitializationReport(fieldInstance, false, false);
-        }
-
-        return instantiator.instantiate();
-    }
-
-    /**
-     * Represents the strategy used to resolve actual instances
-     * to be given to a constructor given the argument types.
-     */
-    public interface ConstructorArgumentResolver {
-
-        /**
-         * Try to resolve instances from types.
-         *
-         * <p>
-         * Checks on the real argument type or on the correct argument number
-         * will happen during the field initialization {@link FieldInitializer#initialize()}.
-         * I.e the only responsibility of this method, is to provide instances <strong>if possible</strong>.
-         * </p>
-         *
-         * @param argTypes Constructor argument types, should not be null.
-         * @return The argument instances to be given to the constructor, should not be null.
-         */
-        Object[] resolveTypeInstances(Class<?>... argTypes);
-    }
-
-    private interface ConstructorInstantiator {
-        FieldInitializationReport instantiate();
-    }
-
-    /**
-     * Constructor instantiating strategy for no-arg constructor.
-     *
-     * <p>
-     * If a no-arg constructor can be found then the instance is created using
-     * this constructor.
-     * Otherwise a technical MockitoException is thrown.
-     * </p>
-     */
-    static class NoArgConstructorInstantiator implements ConstructorInstantiator {
-        private final Object testClass;
-        private final Field field;
-
-        /**
-         * Internal, checks are done by FieldInitializer.
-         * Fields are assumed to be accessible.
-         */
-        NoArgConstructorInstantiator(Object testClass, Field field) {
-            this.testClass = testClass;
-            this.field = field;
-        }
-
-        public FieldInitializationReport instantiate() {
-            final AccessibilityChanger changer = new AccessibilityChanger();
-            Constructor<?> constructor = null;
-            try {
-                constructor = field.getType().getDeclaredConstructor();
-                changer.enableAccess(constructor);
-
-                final Object[] noArg = new Object[0];
-                Object newFieldInstance = constructor.newInstance(noArg);
-                setField(testClass, field,newFieldInstance);
-
-                return new FieldInitializationReport(field.get(testClass), true, false);
-            } catch (NoSuchMethodException e) {
-                throw new MockitoException("the type '" + field.getType().getSimpleName() + "' has no default constructor", e);
-            } catch (InvocationTargetException e) {
-                throw new MockitoException("the default constructor of type '" + field.getType().getSimpleName() + "' has raised an exception (see the stack trace for cause): " + e.getTargetException().toString(), e);
-            } catch (InstantiationException e) {
-                throw new MockitoException("InstantiationException (see the stack trace for cause): " + e.toString(), e);
-            } catch (IllegalAccessException e) {
-                throw new MockitoException("IllegalAccessException (see the stack trace for cause): " + e.toString(), e);
-            } finally {
-                if(constructor != null) {
-                    changer.safelyDisableAccess(constructor);
-                }
-            }
-        }
-    }
-
-    /**
-     * Constructor instantiating strategy for parameterized constructors.
-     *
-     * <p>
-     * Choose the constructor with the highest number of parameters, then
-     * call the ConstructorArgResolver to get actual argument instances.
-     * If the argResolver fail, then a technical MockitoException is thrown is thrown.
-     * Otherwise the instance is created with the resolved arguments.
-     * </p>
-     */
-    static class ParameterizedConstructorInstantiator implements ConstructorInstantiator {
-        private final Object testClass;
-        private final Field field;
-        private final ConstructorArgumentResolver argResolver;
-        private final Comparator<Constructor<?>> byParameterNumber = new Comparator<Constructor<?>>() {
-            public int compare(Constructor<?> constructorA, Constructor<?> constructorB) {
-                int argLengths = constructorB.getParameterTypes().length - constructorA.getParameterTypes().length;
-                if (argLengths == 0) {
-                    int constructorAMockableParamsSize = countMockableParams(constructorA);
-                    int constructorBMockableParamsSize = countMockableParams(constructorB);
-                    return constructorBMockableParamsSize - constructorAMockableParamsSize;
-                }
-                return argLengths;
-            }
-
-            private int countMockableParams(Constructor<?> constructor) {
-                int constructorMockableParamsSize = 0;
-                for (Class<?> aClass : constructor.getParameterTypes()) {
-                    if(MockUtil.typeMockabilityOf(aClass).mockable()){
-                        constructorMockableParamsSize++;
-                    }
-                }
-                return constructorMockableParamsSize;
-            }
-        };
-
-        /**
-         * Internal, checks are done by FieldInitializer.
-         * Fields are assumed to be accessible.
-         */
-        ParameterizedConstructorInstantiator(Object testClass, Field field, ConstructorArgumentResolver argumentResolver) {
-            this.testClass = testClass;
-            this.field = field;
-            this.argResolver = argumentResolver;
-        }
-
-        public FieldInitializationReport instantiate() {
-            final AccessibilityChanger changer = new AccessibilityChanger();
-            Constructor<?> constructor = null;
-            try {
-                constructor = biggestConstructor(field.getType());
-                changer.enableAccess(constructor);
-
-                final Object[] args = argResolver.resolveTypeInstances(constructor.getParameterTypes());
-                Object newFieldInstance = constructor.newInstance(args);
-                setField(testClass, field,newFieldInstance);
-
-                return new FieldInitializationReport(field.get(testClass), false, true);
-            } catch (IllegalArgumentException e) {
-                throw new MockitoException("internal error : argResolver provided incorrect types for constructor " + constructor + " of type " + field.getType().getSimpleName(), e);
-            } catch (InvocationTargetException e) {
-                throw new MockitoException("the constructor of type '" + field.getType().getSimpleName() + "' has raised an exception (see the stack trace for cause): " + e.getTargetException().toString(), e);
-            } catch (InstantiationException e) {
-                throw new MockitoException("InstantiationException (see the stack trace for cause): " + e.toString(), e);
-            } catch (IllegalAccessException e) {
-                throw new MockitoException("IllegalAccessException (see the stack trace for cause): " + e.toString(), e);
-            } finally {
-                if(constructor != null) {
-                    changer.safelyDisableAccess(constructor);
-                }
-            }
-        }
-
-        private void checkParameterized(Constructor<?> constructor, Field field) {
-            if(constructor.getParameterTypes().length == 0) {
-                throw new MockitoException("the field " + field.getName() + " of type " + field.getType() + " has no parameterized constructor");
-            }
-        }
-
-        private Constructor<?> biggestConstructor(Class<?> clazz) {
-            final List<? extends Constructor<?>> constructors = Arrays.asList(clazz.getDeclaredConstructors());
-            Collections.sort(constructors, byParameterNumber);
-
-            Constructor<?> constructor = constructors.get(0);
-            checkParameterized(constructor, field);
-            return constructor;
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldReader.java b/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
deleted file mode 100644
index 5d0bb59ca6..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-
-import org.mockito.exceptions.base.MockitoException;
-
-public class FieldReader {
-
-    final Object target;
-    final Field field;
-    final AccessibilityChanger changer = new AccessibilityChanger();
-
-    public FieldReader(Object target, Field field) {
-        this.target = target;
-        this.field = field;
-        changer.enableAccess(field);
-    }
-
-    public boolean isNull() {
-            return read() == null;
-    }
-
-    public Object read() {
-        try {
-            return field.get(target);
-        } catch (Exception e) {
-            throw new MockitoException("Cannot read state from field: " + field + ", on instance: " + target);
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java b/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
deleted file mode 100644
index 69b5b161a6..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-
-public class FieldSetter {
-
-    private FieldSetter(){}
-
-    public static void setField(Object target, Field field,Object value) {
-        AccessibilityChanger changer = new AccessibilityChanger();
-        changer.enableAccess(field);
-        try {
-            field.set(target, value);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException("Access not authorized on field '" + field + "' of object '" + target + "' with value: '" + value + "'", e);
-        } catch (IllegalArgumentException e) {
-            throw new RuntimeException("Wrong argument on field '" + field + "' of object '" + target + "' with value: '" + value + "', \n" +
-                    "reason : " + e.getMessage(), e);
-        }
-        changer.safelyDisableAccess(field);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/Fields.java b/src/main/java/org/mockito/internal/util/reflection/Fields.java
deleted file mode 100644
index 3d3fb9c3dc..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/Fields.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.mockito.internal.util.Checks;
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-
-/**
- * Small fluent reflection tools to work with fields.
- *
- * Code is very new and might need rework.
- */
-public abstract class Fields {
-
-    /**
-     * Instance fields declared in the class and superclasses of the given instance.
-     *
-     * @param instance Instance from which declared fields will be retrieved.
-     * @return InstanceFields of this object instance.
-     */
-    public static InstanceFields allDeclaredFieldsOf(Object instance) {
-        List<InstanceField> instanceFields = new ArrayList<InstanceField>();
-        for (Class<?> clazz = instance.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
-            instanceFields.addAll(instanceFieldsIn(instance, clazz.getDeclaredFields()));
-        }
-        return new InstanceFields(instance, instanceFields);
-    }
-
-    /**
-     * Instance fields declared in the class of the given instance.
-     *
-     * @param instance Instance from which declared fields will be retrieved.
-     * @return InstanceFields of this object instance.
-     */
-    public static InstanceFields declaredFieldsOf(Object instance) {
-        List<InstanceField> instanceFields = new ArrayList<InstanceField>();
-        instanceFields.addAll(instanceFieldsIn(instance, instance.getClass().getDeclaredFields()));
-        return new InstanceFields(instance, instanceFields);
-    }
-
-    private static List<InstanceField> instanceFieldsIn(Object instance, Field[] fields) {
-        List<InstanceField> instanceDeclaredFields = new ArrayList<InstanceField>();
-        for (Field field : fields) {
-            InstanceField instanceField = new InstanceField(field, instance);
-            instanceDeclaredFields.add(instanceField);
-        }
-        return instanceDeclaredFields;
-    }
-
-    /**
-     * Accept fields annotated by the given annotations.
-     *
-     * @param annotations Annotation types to check.
-     * @return The filter.
-     */
-    @SuppressWarnings({"unchecked", "vararg"})
-    public static Filter<InstanceField> annotatedBy(final Class<? extends Annotation>... annotations) {
-        return new Filter<InstanceField>() {
-            public boolean isOut(InstanceField instanceField) {
-                Checks.checkNotNull(annotations, "Provide at least one annotation class");
-
-                for (Class<? extends Annotation> annotation : annotations) {
-                    if(instanceField.isAnnotatedBy(annotation)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-        };
-    }
-
-    /**
-     * Accept fields with non null value.
-     *
-     * @return The filter.
-     */
-    private static Filter<InstanceField> nullField() {
-        return new Filter<InstanceField>() {
-            public boolean isOut(InstanceField instanceField) {
-                return instanceField.isNull();
-            }
-        };
-    }
-
-    /**
-     * Accept fields with non null value.
-     *
-     * @return The filter.
-     */
-    public static Filter<InstanceField> syntheticField() {
-        return new Filter<InstanceField>() {
-            public boolean isOut(InstanceField instanceField) {
-                return instanceField.isSynthetic();
-            }
-        };
-    }
-
-    public static class InstanceFields {
-        private final Object instance;
-
-        private final List<InstanceField> instanceFields;
-
-        public InstanceFields(Object instance, List<InstanceField> instanceFields) {
-            this.instance = instance;
-            this.instanceFields = instanceFields;
-        }
-
-        public InstanceFields filter(Filter<InstanceField> withFilter) {
-            return new InstanceFields(instance, ListUtil.filter(instanceFields, withFilter));
-        }
-
-        public InstanceFields notNull() {
-            return filter(nullField());
-        }
-
-        public List<InstanceField> instanceFields() {
-            return new ArrayList<InstanceField>(instanceFields);
-        }
-
-        public List<Object> assignedValues() {
-            List<Object> values = new ArrayList<Object>(instanceFields.size());
-            for (InstanceField instanceField : instanceFields) {
-                values.add(instanceField.read());
-            }
-            return values;
-        }
-
-        public List<String> names() {
-            List<String> fieldNames = new ArrayList<String>(instanceFields.size());
-            for (InstanceField instanceField : instanceFields) {
-                fieldNames.add(instanceField.name());
-            }
-            return fieldNames;
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java b/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
deleted file mode 100644
index a477ba43dd..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-
-public class GenericMaster {
-
-    /**
-     * Finds the generic type (parametrized type) of the field. If the field is not generic it returns Object.class.
-     *
-     * @param field the field to inspect
-     */
-    public Class<?> getGenericType(Field field) {
-        Type generic = field.getGenericType();
-        if (generic instanceof ParameterizedType) {
-            Type actual = ((ParameterizedType) generic).getActualTypeArguments()[0];
-            if (actual instanceof Class) {
-                return (Class<?>) actual;
-            } else if (actual instanceof ParameterizedType) {
-                //in case of nested generics we don't go deep
-                return (Class<?>) ((ParameterizedType) actual).getRawType();
-            }
-        }
-
-        return Object.class;
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java b/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
deleted file mode 100644
index c6b9919206..0000000000
--- a/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-
-@SuppressWarnings("unchecked")
-public class LenientCopyTool {
-
-    FieldCopier fieldCopier = new FieldCopier();
-
-    public <T> void copyToMock(T from, T mock) {
-        copy(from, mock, from.getClass());
-    }
-
-    public <T> void copyToRealObject(T from, T to) {
-        copy(from, to, from.getClass());
-    }
-
-    private <T> void copy(T from, T to, Class<?> fromClazz) {
-        while (fromClazz != Object.class) {
-            copyValues(from, to, fromClazz);
-            fromClazz = fromClazz.getSuperclass();
-        }
-    }
-
-    private <T> void copyValues(T from, T mock, Class<?> classFrom) {
-        Field[] fields = classFrom.getDeclaredFields();
-
-        for (Field field : fields) {
-            // ignore static fields
-            if (Modifier.isStatic(field.getModifiers())) {
-                continue;
-            }
-            AccessibilityChanger accessibilityChanger = new AccessibilityChanger();
-            try {
-                accessibilityChanger.enableAccess(field);
-                fieldCopier.copyValue(from, mock, field);
-            } catch (Throwable t) {
-                //Ignore - be lenient - if some field cannot be copied then let's be it
-            } finally {
-                accessibilityChanger.safelyDisableAccess(field);
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
deleted file mode 100644
index c69871e688..0000000000
--- a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification;
-
-import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-
-import java.io.Serializable;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-import org.mockito.invocation.Invocation;
-
-
-public class DefaultRegisteredInvocations implements RegisteredInvocations, Serializable {
-
-    private static final long serialVersionUID = -2674402327380736290L;
-    private final LinkedList<Invocation> invocations = new LinkedList<Invocation>();
-
-    public void add(Invocation invocation) {
-        synchronized (invocations) {
-            invocations.add(invocation);
-        }
-    }
-
-    public void removeLast() {
-        //TODO: add specific test for synchronization of this block (it is tested by InvocationContainerImplTest at the moment)
-        synchronized (invocations) {
-            if (! invocations.isEmpty()) {
-                invocations.removeLast();
-            }
-        }
-    }
-
-    public List<Invocation> getAll() {
-        List<Invocation> copiedList;
-        synchronized (invocations) {
-            copiedList = new LinkedList<Invocation>(invocations) ;
-        }
-
-        return ListUtil.filter(copiedList, new RemoveToString());
-    }
-
-    public void clear() {
-        synchronized (invocations) {
-            invocations.clear();
-        }
-    }
-
-    public boolean isEmpty() {
-        synchronized (invocations) {
-            return invocations.isEmpty();
-        }
-    }
-
-    private static class RemoveToString implements Filter<Invocation> {
-        public boolean isOut(Invocation invocation) {
-            return isToStringMethod(invocation.getMethod());
-        }
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationWrapper.java b/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
deleted file mode 100644
index 66336a94f1..0000000000
--- a/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification;
-
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.verification.VerificationMode;
-
-public abstract class VerificationWrapper<WrapperType extends VerificationMode> implements VerificationMode {
-
-    protected final WrapperType wrappedVerification;
-
-    public VerificationWrapper(WrapperType wrappedVerification) {
-        this.wrappedVerification = wrappedVerification;
-    }
-
-    public void verify(VerificationData data) {
-        wrappedVerification.verify(data);
-    }
-
-    protected abstract VerificationMode copySelfWithNewVerificationMode(VerificationMode verificationMode);
-
-    public VerificationMode times(int wantedNumberOfInvocations) {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.times(wantedNumberOfInvocations));
-    }
-
-    public VerificationMode never() {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.atMost(0));
-    }
-
-    public VerificationMode atLeastOnce() {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.atLeastOnce());
-    }
-
-    public VerificationMode atLeast(int minNumberOfInvocations) {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.atLeast(minNumberOfInvocations));
-    }
-
-    public VerificationMode atMostOnce() {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.atMostOnce());
-    }
-
-    public VerificationMode atMost(int maxNumberOfInvocations) {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.atMost(maxNumberOfInvocations));
-    }
-
-    public VerificationMode only() {
-        return copySelfWithNewVerificationMode(VerificationModeFactory.only());
-    }
-
-}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java b/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
deleted file mode 100644
index 87d9076e00..0000000000
--- a/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification;
-
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.InOrderImpl;
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.internal.verification.api.VerificationInOrderMode;
-import org.mockito.verification.VerificationMode;
-
-public class VerificationWrapperInOrderWrapper implements VerificationMode {
-    private final VerificationMode delegate;
-
-    public VerificationWrapperInOrderWrapper(VerificationWrapper<?> verificationWrapper, InOrderImpl inOrder) {
-        VerificationMode verificationMode = verificationWrapper.wrappedVerification;
-
-        VerificationMode inOrderWrappedVerificationMode = wrapInOrder(verificationWrapper, verificationMode, inOrder);
-
-        delegate = verificationWrapper.copySelfWithNewVerificationMode(inOrderWrappedVerificationMode);
-    }
-
-    @Override
-    public void verify(VerificationData data) {
-        delegate.verify(data);
-    }
-
-    private VerificationMode wrapInOrder(VerificationWrapper<?> verificationWrapper, VerificationMode verificationMode, InOrderImpl inOrder) {
-        if (verificationMode instanceof VerificationInOrderMode) {
-            final VerificationInOrderMode verificationInOrderMode = (VerificationInOrderMode)verificationMode;
-            return new InOrderWrapper(verificationInOrderMode, inOrder);
-        }
-
-        if (verificationMode instanceof VerificationOverTimeImpl) {
-            final VerificationOverTimeImpl verificationOverTime = (VerificationOverTimeImpl)verificationMode;
-            if (verificationOverTime.isReturnOnSuccess()) {
-                return new VerificationOverTimeImpl(verificationOverTime.getPollingPeriodMillis(),
-                        verificationOverTime.getTimer().duration(),
-                        wrapInOrder(verificationWrapper, verificationOverTime.getDelegate(), inOrder),
-                        verificationOverTime.isReturnOnSuccess());
-            }
-        }
-
-        //TODO ugly exception message!!!
-        throw new MockitoException(verificationMode.getClass().getSimpleName() +
-                " is not implemented to work with InOrder wrapped inside a " +
-                verificationWrapper.getClass().getSimpleName());
-    }
-}
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationData.java b/src/main/java/org/mockito/internal/verification/api/VerificationData.java
deleted file mode 100644
index bc699209ff..0000000000
--- a/src/main/java/org/mockito/internal/verification/api/VerificationData.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.api;
-
-import java.util.List;
-
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MatchableInvocation;
-
-/**
- * Data needed to perform verification of interactions.
- * This interface is considered public even though it lives in private package.
- * In the next major version of Mockito, this class will be moved to public space.
- */
-public interface VerificationData {
-
-    /**
-     * All invocations recorded on the mock object that is being verified.
-     * Does not include invocations recorded on other mock objects.
-     */
-    List<Invocation> getAllInvocations();
-
-    /**
-     * The target or wanted invocation.
-     * Below example illustrates what is the 'target' invocation:
-     * <pre class="code"><code class="java">
-     *   mock.foo();   // <- invocation 1
-     *   mock.bar();   // <- invocation 2
-     *
-     *   verify(mock).bar();  // <- target invocation
-     * </code></pre>
-     *
-     * Target invocation can contain argument matchers therefore the returned type is {@link MatchableInvocation}
-     * and not {@link Invocation}.
-     *
-     * @since 2.2.12
-     */
-    MatchableInvocation getTarget();
-
-    /**
-     * @deprecated - This internal method leaks internal class <code>InvocationMatcher</code>.
-     * Please use {@link org.mockito.internal.verification.api.VerificationData#getTarget()} instead.
-     *
-     * Deprecated since 2.2.12
-     */
-    @Deprecated
-    InvocationMatcher getWanted();
-}
diff --git a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java
deleted file mode 100644
index 17f9196a09..0000000000
--- a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.argumentmatching;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.ContainsExtraTypeInfo;
-
-@SuppressWarnings("unchecked")
-public class ArgumentMatchingTool {
-
-    private ArgumentMatchingTool(){}
-    /**
-     * Suspiciously not matching arguments are those that don't match, the toString() representation is the same but types are different.
-     */
-    public static Integer[] getSuspiciouslyNotMatchingArgsIndexes(List<ArgumentMatcher> matchers, Object[] arguments) {
-        if (matchers.size() != arguments.length) {
-            return new Integer[0];
-        }
-
-        List<Integer> suspicious = new LinkedList<Integer>();
-        int i = 0;
-        for (ArgumentMatcher m : matchers) {
-            if (m instanceof ContainsExtraTypeInfo
-                    && !safelyMatches(m, arguments[i])
-                    && toStringEquals(m, arguments[i])
-                    && !((ContainsExtraTypeInfo) m).typeMatches(arguments[i])) {
-                suspicious.add(i);
-            }
-            i++;
-        }
-        return suspicious.toArray(new Integer[0]);
-    }
-
-    private static boolean safelyMatches(ArgumentMatcher m, Object arg) {
-        try {
-            return m.matches(arg);
-        } catch (Throwable t) {
-            return false;
-        }
-    }
-
-    private static boolean toStringEquals(ArgumentMatcher m, Object arg) {
-        return m.toString().equals(arg == null ? "null" : arg.toString());
-    }
-}
diff --git a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
deleted file mode 100644
index 86a24f2003..0000000000
--- a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.checkers;
-
-import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocations;
-import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocationsInOrder;
-import static org.mockito.internal.invocation.InvocationMarker.markVerified;
-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.getAllLocations;
-
-import java.util.List;
-
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MatchableInvocation;
-
-public class AtLeastXNumberOfInvocationsChecker {
-
-    public static void checkAtLeastNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
-        List<Invocation> actualInvocations = findInvocations(invocations, wanted);
-
-        int actualCount = actualInvocations.size();
-        if (wantedCount > actualCount) {
-            List<Location> allLocations = getAllLocations(actualInvocations);
-            throw tooFewActualInvocations(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
-        }
-
-        markVerified(actualInvocations, wanted);
-    }
-
-    public static void checkAtLeastNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount,InOrderContext orderingContext) {
-        List<Invocation> chunk = findAllMatchingUnverifiedChunks(invocations, wanted, orderingContext);
-
-        int actualCount = chunk.size();
-
-        if (wantedCount > actualCount) {
-            List<Location> allLocations = getAllLocations(chunk);
-            throw tooFewActualInvocationsInOrder(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
-        }
-
-        markVerifiedInOrder(chunk, wanted, orderingContext);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java
deleted file mode 100644
index 73ad4879d0..0000000000
--- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.checkers;
-
-import static org.mockito.internal.exceptions.Reporter.argumentsAreDifferent;
-import static org.mockito.internal.exceptions.Reporter.wantedButNotInvoked;
-import static org.mockito.internal.exceptions.Reporter.wantedButNotInvokedInOrder;
-import static org.mockito.internal.invocation.InvocationsFinder.findAllMatchingUnverifiedChunks;
-import static org.mockito.internal.invocation.InvocationsFinder.findInvocations;
-import static org.mockito.internal.invocation.InvocationsFinder.findPreviousVerifiedInOrder;
-import static org.mockito.internal.invocation.InvocationsFinder.findSimilarInvocation;
-import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes;
-
-import java.util.List;
-
-import org.mockito.internal.reporting.SmartPrinter;
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MatchableInvocation;
-
-public class MissingInvocationChecker {
-
-    private MissingInvocationChecker() {
-    }
-
-    public static void checkMissingInvocation(List<Invocation> invocations, MatchableInvocation wanted) {
-        List<Invocation> actualInvocations = findInvocations(invocations, wanted);
-
-        if (!actualInvocations.isEmpty()){
-            return;
-        }
-
-        Invocation similar = findSimilarInvocation(invocations, wanted);
-        if (similar == null) {
-            throw wantedButNotInvoked(wanted, invocations);
-        }
-
-        Integer[] indexesOfSuspiciousArgs = getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments());
-        SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs);
-        List<Location> actualLocations = ListUtil.convert(invocations, new ListUtil.Converter<Invocation, Location>() {
-            @Override
-            public Location convert(Invocation invocation) {
-                return invocation.getLocation();
-            }
-        });
-
-        throw argumentsAreDifferent(smartPrinter.getWanted(), smartPrinter.getActuals(), actualLocations);
-
-    }
-
-    public static void checkMissingInvocation(List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context) {
-        List<Invocation> chunk = findAllMatchingUnverifiedChunks(invocations, wanted, context);
-
-        if (!chunk.isEmpty()) {
-            return;
-        }
-
-        Invocation previousInOrder = findPreviousVerifiedInOrder(invocations, context);
-        if (previousInOrder != null) {
-            throw wantedButNotInvokedInOrder(wanted, previousInOrder);
-        }
-
-        checkMissingInvocation(invocations, wanted);
-    }
-}
diff --git a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
deleted file mode 100644
index 1b5ffc14ba..0000000000
--- a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.checkers;
-
-import static org.mockito.internal.exceptions.Reporter.neverWantedButInvoked;
-import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocations;
-import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocationsInOrder;
-import static org.mockito.internal.exceptions.Reporter.tooManyActualInvocations;
-import static org.mockito.internal.exceptions.Reporter.tooManyActualInvocationsInOrder;
-import static org.mockito.internal.invocation.InvocationMarker.markVerified;
-import static org.mockito.internal.invocation.InvocationMarker.markVerifiedInOrder;
-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.getAllLocations;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.mockito.internal.reporting.Discrepancy;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MatchableInvocation;
-
-public class NumberOfInvocationsChecker {
-
-    private NumberOfInvocationsChecker() {
-    }
-
-    public static void checkNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
-        List<Invocation> actualInvocations = findInvocations(invocations, wanted);
-
-        int actualCount = actualInvocations.size();
-        if (wantedCount > actualCount) {
-            List<Location> allLocations = getAllLocations(actualInvocations);
-            throw tooFewActualInvocations(new Discrepancy(wantedCount, actualCount), wanted, allLocations);
-        }
-        if (wantedCount == 0 && actualCount > 0) {
-            throw neverWantedButInvoked(wanted, getAllLocations(actualInvocations));
-        }
-        if (wantedCount < actualCount) {
-            throw tooManyActualInvocations(wantedCount, actualCount, wanted, getAllLocations(actualInvocations));
-        }
-
-        markVerified(actualInvocations, wanted);
-    }
-
-    public static void checkNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount, InOrderContext context) {
-        List<Invocation> chunk = findMatchingChunk(invocations, wanted, wantedCount, context);
-
-        int actualCount = chunk.size();
-
-        if (wantedCount > actualCount) {
-            List<Location> allLocations = getAllLocations(chunk);
-            throw tooFewActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, allLocations);
-        }
-        if (wantedCount < actualCount) {
-            throw tooManyActualInvocationsInOrder(wantedCount, actualCount, wanted, getAllLocations(chunk));
-        }
-
-        markVerifiedInOrder(chunk, wanted, context);
-    }
-
-    public static void checkNumberOfInvocationsNonGreedy(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount, InOrderContext context) {
-        int actualCount = 0;
-        Location lastLocation = null;
-        while( actualCount < wantedCount ){
-            Invocation next = findFirstMatchingUnverifiedInvocation(invocations, wanted, context );
-            if( next == null ){
-                throw tooFewActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, Arrays.asList(lastLocation));
-            }
-            markVerified( next, wanted );
-            context.markVerified( next );
-            lastLocation = next.getLocation();
-            actualCount++;
-        }
-    }
-}
diff --git a/src/main/java/org/mockito/invocation/InvocationFactory.java b/src/main/java/org/mockito/invocation/InvocationFactory.java
deleted file mode 100644
index d3294bd3db..0000000000
--- a/src/main/java/org/mockito/invocation/InvocationFactory.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.invocation;
-
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-
-import org.mockito.Incubating;
-import org.mockito.MockitoFramework;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * Available via {@link MockitoFramework#getInvocationFactory()}.
- * Provides means to create instances of {@link Invocation} objects.
- * Useful for framework integrations that need to programmatically simulate method calls on mock objects.
- * To simulate a method call on mock, one needs an instance of {@link Invocation}.
- * <p>
- * Please don't provide your own implementation of {@link Invocation} type.
- * Mockito team needs flexibility to add new methods to this interface if we need to.
- * If you integrate Mockito framework and you need an instance of {@link Invocation}, use {@link #createInvocation(Object, MockCreationSettings, Method, RealMethodBehavior, Object...)}.
- *
- * @since 2.10.0
- */
-@Incubating
-public interface InvocationFactory {
-
-    /**
-     * @deprecated Use {@link #createInvocation(Object, MockCreationSettings, Method, RealMethodBehavior, Object...)} instead.
-     *
-     * Why deprecated? We found use cases where we need to handle Throwable and ensure correct stack trace filtering
-     * (removing Mockito internals from the stack trace). Hence the introduction of {@link RealMethodBehavior}.
-     *
-     * Creates instance of an {@link Invocation} object.
-     * This method is useful for framework integrators to programmatically simulate method calls on mocks using {@link MockHandler}.
-     * It enables advanced framework integrations.
-     *
-     * @param target the mock object the method is invoked on.
-     * @param settings creation settings of the mock object.
-     * @param method java method invoked on mock.
-     * @param realMethod real method behavior. Needed for spying / invoking real behavior on mock objects.
-     * @param args the java method arguments
-     *
-     * @return invocation instance
-     * @since 2.10.0
-     */
-    @Deprecated
-    Invocation createInvocation(Object target, MockCreationSettings settings, Method method, Callable realMethod, Object... args);
-
-    /**
-     * Behavior of the real method.
-     *
-     * @since 2.14.0
-     */
-    interface RealMethodBehavior<R> extends Serializable {
-        R call() throws Throwable;
-    }
-
-    /**
-     * Creates instance of an {@link Invocation} object.
-     * This method is useful for framework integrators to programmatically simulate method calls on mocks using {@link MockHandler}.
-     * It enables advanced framework integrations.
-     *
-     * @param target the mock object the method is invoked on.
-     * @param settings creation settings of the mock object.
-     * @param method java method invoked on mock.
-     * @param realMethod real method behavior. Needed for spying / invoking real behavior on mock objects.
-     * @param args the java method arguments
-     *
-     * @return invocation instance
-     * @since 2.14.0
-     */
-    @Incubating
-    Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethodBehavior realMethod, Object... args);
-}
diff --git a/src/main/java/org/mockito/junit/MockitoJUnitRunner.java b/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
deleted file mode 100644
index 52fca881fd..0000000000
--- a/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.junit;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.runner.Description;
-import org.junit.runner.Runner;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.Filterable;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.RunNotifier;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.MockitoSession;
-import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.internal.runners.InternalRunner;
-import org.mockito.internal.runners.RunnerFactory;
-import org.mockito.internal.runners.StrictRunner;
-import org.mockito.quality.MockitoHint;
-import org.mockito.quality.Strictness;
-
-
-/**
- * Mockito JUnit Runner keeps tests clean and improves debugging experience.
- * Make sure to try out {@link MockitoJUnitRunner.StrictStubs} which automatically
- * detects <strong>stubbing argument mismatches</strong> and is planned to be the default in Mockito v3.
- * Runner is compatible with JUnit 4.4 and higher and adds following behavior:
- * <ul>
- *   <li>
- *       (new since Mockito 2.1.0) Detects unused stubs in the test code.
- *       See {@link UnnecessaryStubbingException}.
- *       Similar to JUnit rules, the runner also reports stubbing argument mismatches as console warnings
- *       (see {@link MockitoHint}).
- *       To opt-out from this feature, use {@code}&#064;RunWith(MockitoJUnitRunner.Silent.class){@code}
- *   <li>
- *      Initializes mocks annotated with {@link Mock},
- *      so that explicit usage of {@link MockitoAnnotations#initMocks(Object)} is not necessary.
- *      Mocks are initialized before each test method.
- *   <li>
- *      Validates framework usage after each test method. See javadoc for {@link Mockito#validateMockitoUsage()}.
- *   <li>
- *      It is highly recommended to use {@link MockitoJUnitRunner.StrictStubs} variant of the runner.
- *      It drives cleaner tests and improves debugging experience.
- *      The only reason this feature is not turned on by default
- *      is because it would have been an incompatible change
- *      and Mockito strictly follows <a href="http://semver.org">semantic versioning</a>.
- * </ul>
- *
- * Runner is completely optional - there are other ways you can get &#064;Mock working, for example by writing a base class.
- * Explicitly validating framework usage is also optional because it is triggered automatically by Mockito every time you use the framework.
- * See javadoc for {@link Mockito#validateMockitoUsage()}.
- * <p>
- * Read more about &#064;Mock annotation in javadoc for {@link MockitoAnnotations}
- * <pre class="code"><code class="java">
- * <b>&#064;RunWith(MockitoJUnitRunner.StrictStubs.class)</b>
- * public class ExampleTest {
- *
- *     &#064;Mock
- *     private List list;
- *
- *     &#064;Test
- *     public void shouldDoSomething() {
- *         list.add(100);
- *     }
- * }
- * </code></pre>
- *
- * If you would like to take advantage of Mockito JUnit runner features
- * but you cannot use the runner because, for example, you use TestNG, there is a solution!
- * {@link MockitoSession} API is intended to offer cleaner tests and improved debuggability
- * to users that cannot use Mockito's built-in JUnit support (runner or the rule).
- */
-public class MockitoJUnitRunner extends Runner implements Filterable {
-
-    /**
-     * This Mockito JUnit Runner implementation *ignores*
-     * stubbing argument mismatches ({@link MockitoJUnitRunner.StrictStubs})
-     * and *does not detect* unused stubbings.
-     * The runner remains 'silent' even if incorrect stubbing is present.
-     * It is an equivalent of {@link Strictness#LENIENT}.
-     * This was the behavior of Mockito JUnit runner in versions 1.x.
-     * Using this implementation of the runner is not recommended.
-     * Engineers should care for removing unused stubbings because they are dead code,
-     * they add unnecessary details, potentially making the test code harder to comprehend.
-     * If you have good reasons to use the silent runner, let us know at the mailing list
-     * or raise an issue in our issue tracker.
-     * The purpose of silent implementation is to satisfy edge/unanticipated use cases,
-     * and to offer users an opt-out.
-     * Mockito framework is opinionated to drive clean tests but it is not dogmatic.
-     * <p>
-     * See also {@link UnnecessaryStubbingException}.
-     * <p>
-     * Usage:
-     * <pre class="code"><code class="java">
-     * <b>&#064;RunWith(MockitoJUnitRunner.Silent.class)</b>
-     * public class ExampleTest {
-     *   // ...
-     * }
-     * </code></pre>
-     *
-     * @since 2.1.0
-     */
-    public static class Silent extends MockitoJUnitRunner {
-        public Silent(Class<?> klass) throws InvocationTargetException {
-            super(new RunnerFactory().create(klass));
-        }
-    }
-
-    /**
-     * Detects unused stubs and reports them as failures. Default behavior in Mockito 2.x.
-     * To improve productivity and quality of tests please consider newer API, the {@link StrictStubs}.
-     * <p>
-     * For more information on detecting unusued stubs, see {@link UnnecessaryStubbingException}.
-     * For more information on stubbing argument mismatch warnings see {@link MockitoHint}.
-     *
-     * @since 2.1.0
-     */
-    public static class Strict extends MockitoJUnitRunner {
-        public Strict(Class<?> klass) throws InvocationTargetException {
-            super(new StrictRunner(new RunnerFactory().createStrict(klass), klass));
-        }
-    }
-
-    /**
-     * Improves debugging tests, helps keeping the tests clean.
-     * Highly recommended to improve productivity and quality of tests.
-     * Planned default behavior for Mockito v3.
-     * Adds behavior equivalent to {@link Strictness#STRICT_STUBS}.
-     * <p>
-     * Usage:
-     * <pre class="code"><code class="java">
-     * <b>&#064;RunWith(MockitoJUnitRunner.StrictStubs.class)</b>
-     * public class ExampleTest {
-     *   // ...
-     * }
-     * </code></pre>
-     *
-     * @since 2.5.1
-     */
-    public static class StrictStubs extends MockitoJUnitRunner {
-        public StrictStubs(Class<?> klass) throws InvocationTargetException {
-            super(new StrictRunner(new RunnerFactory().createStrictStubs(klass), klass));
-        }
-    }
-
-    private final InternalRunner runner;
-
-    public MockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
-        //by default, StrictRunner is used. We can change that potentially based on feedback from users
-        this(new StrictRunner(new RunnerFactory().createStrict(klass), klass));
-    }
-
-    MockitoJUnitRunner(InternalRunner runner) throws InvocationTargetException {
-        this.runner = runner;
-    }
-
-    @Override
-    public void run(final RunNotifier notifier) {
-        runner.run(notifier);
-    }
-
-    @Override
-    public Description getDescription() {
-        return runner.getDescription();
-    }
-
-    public void filter(Filter filter) throws NoTestsRemainException {
-        //filter is required because without it UnrootedTests show up in Eclipse
-        runner.filter(filter);
-    }
-}
diff --git a/src/main/java/org/mockito/listeners/MockCreationListener.java b/src/main/java/org/mockito/listeners/MockCreationListener.java
deleted file mode 100644
index 24a1904aa7..0000000000
--- a/src/main/java/org/mockito/listeners/MockCreationListener.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.listeners;
-
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * Notified when mock object is created.
- * For more information on listeners see {@link org.mockito.MockitoFramework#addListener(MockitoListener)}.
- */
-public interface MockCreationListener extends MockitoListener {
-
-    /**
-     * Mock object was just created.
-     *
-     * @param mock created mock object
-     * @param settings the settings used for creation
-     */
-    void onMockCreated(Object mock, MockCreationSettings settings);
-}
diff --git a/src/main/java/org/mockito/plugins/AnnotationEngine.java b/src/main/java/org/mockito/plugins/AnnotationEngine.java
deleted file mode 100644
index c60f477b9f..0000000000
--- a/src/main/java/org/mockito/plugins/AnnotationEngine.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.plugins;
-
-/**
- * Configures test via annotations.
- *
- * <p>Mockito default engine handles the logic behind &#064;Mock, &#064;Captor, &#064;Spy and &#064;InjectMocks annotations.
- *
- * <p>This interface is an extension point that make possible to use a different annotation engine allowing to extend
- * or replace mockito default engine.
- *
- * <p>
- * If you are interested then see implementations or source code of {@link org.mockito.MockitoAnnotations#initMocks(Object)}
- *
- * <p>This plugin mechanism supersedes the {@link org.mockito.configuration.IMockitoConfiguration}
- * in regard of switching mockito components.
- */
-public interface AnnotationEngine {
-    /**
-     * Processes the test instance to configure annotated members.
-     *
-     * @param clazz Class where to extract field information, check implementation for details
-     * @param testInstance Test instance
-     */
-    void process(Class<?> clazz, Object testInstance);
-}
diff --git a/src/main/java/org/mockito/plugins/InstantiatorProvider.java b/src/main/java/org/mockito/plugins/InstantiatorProvider.java
deleted file mode 100644
index 354b87b082..0000000000
--- a/src/main/java/org/mockito/plugins/InstantiatorProvider.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.plugins;
-
-import org.mockito.internal.creation.instance.Instantiator;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * @deprecated since 2.15.4 because this internal class was leaking from the public API.
- * For more information why deprecated, see {@link org.mockito.plugins.InstantiatorProvider2} and
- * <a href="https://github.com/mockito/mockito/issues/1303">Issue 1303</a>
- *
- * <p>
- *     Mockito will invoke this interface in order to fetch an instance instantiator provider.
- * </p>
- *
- * <p>
- *     By default, an internal byte-buddy/asm/objenesis based implementation is used.
- * </p>
- *
- * <h3>Using the extension point</h3>
- *
- * <p>
- *     The plugin mechanism of mockito works in a similar way as the
- *     {@link java.util.ServiceLoader}, however instead of looking in the <code>META-INF</code>
- *     directory, Mockito will look in <code>mockito-extensions</code> directory.
- *     <em>The reason for that is that Android SDK strips jar from the <code>META-INF</code>
- *     directory when creating an APK.</em>
- * </p>
- *
- * <ol style="list-style-type: lower-alpha">
- *     <li>The implementation itself, for example
- *         <code>org.awesome.mockito.AwesomeInstantiatorProvider</code> that implements the
- *         <code>InstantiatorProvider</code>.</li>
- *     <li>A file "<code>mockito-extensions/org.mockito.plugins.InstantiatorProvider</code>".
- *         The content of this file is exactly a <strong>one</strong> line with the qualified
- *         name: <code>org.awesome.mockito.AwesomeInstantiatorProvider</code>.</li>
- * </ol></p>
- *
- * <p>
- *     Note that if several <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider</code>
- *     files exists in the classpath, Mockito will only use the first returned by the standard
- *     {@link ClassLoader#getResource} mechanism.
- * <p>
- *     So just create a custom implementation of {@link InstantiatorProvider} and place the
- *     qualified name in the following file
- *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider</code>.
- * </p>
- * <p>
- *     This class is deprecated and was replaced by
- *     {@link org.mockito.plugins.InstantiatorProvider2}. Hence if there is both a
- *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider</code> and
- *     <code>mockito-extensions/org.mockito.plugins.InstantiatorProvider2</code> the second one
- *     takes preference.
- * </p>
- *
- * @since 2.0.31
- */
-@Deprecated
-public interface InstantiatorProvider {
-
-    /**
-     * @deprecated, see {@link InstantiatorProvider}.
-     *
-     * Returns an instantiator, used to create new class instances.
-     */
-    @Deprecated
-    Instantiator getInstantiator(MockCreationSettings<?> settings);
-}
diff --git a/src/main/java/org/mockito/plugins/MockMaker.java b/src/main/java/org/mockito/plugins/MockMaker.java
deleted file mode 100644
index e4b0ca8b49..0000000000
--- a/src/main/java/org/mockito/plugins/MockMaker.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.plugins;
-
-import org.mockito.Incubating;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * The facility to create mocks.
- *
- * <p>By default, an internal byte-buddy/asm/objenesis based implementation is used.</p>
- *
- * <p>{@code MockMaker} is an extension point that makes it possible to use custom dynamic proxies
- * and avoid using the default byte-buddy/asm/objenesis implementation.
- * For example, the android users can use a MockMaker that can work with Dalvik virtual machine
- * and hence bring Mockito to android apps developers.</p>
- *
- * <h3>Using the extension point</h3>
- *
- * <p>Suppose you wrote an extension to create mocks with some <em>Awesome</em> library, in order to tell
- * Mockito to use it you need to put in your <strong>classpath</strong>:
- * <ol style="list-style-type: lower-alpha">
- *     <li>
- *         The implementation itself, for example <code>org.awesome.mockito.AwesomeMockMaker</code> that
- *         extends the <code>MockMaker</code>.
- *     </li>
- *     <li>
- *         A file "<code>mockito-extensions/org.mockito.plugins.MockMaker</code>". The content of this file is
- *         exactly a <strong>one</strong> line with the qualified name:
- *         <code>org.awesome.mockito.AwesomeMockMaker</code>.
-*      </li>
- * </ol>
- * </p>
- *
- * <p>Note that if several <code>mockito-extensions/org.mockito.plugins.MockMaker</code> files exists in the classpath
- * Mockito will only use the first returned by the standard {@link ClassLoader#getResource} mechanism.
- *
- * @see org.mockito.mock.MockCreationSettings
- * @see org.mockito.invocation.MockHandler
- * @since 1.9.5
- */
-public interface MockMaker {
-
-    /**
-     * If you want to provide your own implementation of {@code MockMaker} this method should:
-     * <ul>
-     *     <li>Create a proxy object that implements {@code settings.typeToMock} and potentially also {@code settings.extraInterfaces}.</li>
-     *     <li>You may use the information from {@code settings} to create/configure your proxy object.</li>
-     *     <li>Your proxy object should carry the {@code handler} with it. For example, if you generate byte code
-     *     to create the proxy you could generate an extra field to keep the {@code handler} with the generated object.
-     *     Your implementation of {@code MockMaker} is required to provide this instance of {@code handler} when
-     *     {@link #getHandler(Object)} is called.
-     *     </li>
-     * </ul>
-     *
-     * @param settings Mock creation settings like type to mock, extra interfaces and so on.
-     * @param handler See {@link org.mockito.invocation.MockHandler}.
-     *                <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
-     *                {@link #getHandler(Object)} will return this instance.
-     * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
-     * @return The mock instance.
-     * @since 1.9.5
-     */
-    <T> T createMock(
-            MockCreationSettings<T> settings,
-            MockHandler handler
-    );
-
-    /**
-     * Returns the handler for the {@code mock}. <b>Do not</b> provide your own implementations at this time
-     * because the work on the {@link MockHandler} api is not completed.
-     * Use the instance provided to you by Mockito at {@link #createMock} or {@link #resetMock}.
-     *
-     * @param mock The mock instance.
-     * @return The mock handler, but may return null - it means that there is no handler attached to provided object.
-     *   This means the passed object is not really a Mockito mock.
-     * @since 1.9.5
-     */
-    MockHandler getHandler(Object mock);
-
-    /**
-     * Replaces the existing handler on {@code mock} with {@code newHandler}.
-     *
-     * <p>The invocation handler actually store invocations to achieve
-     * stubbing and verification. In order to reset the mock, we pass
-     * a new instance of the invocation handler.</p>
-     *
-     * <p>Your implementation should make sure the {@code newHandler} is correctly associated to passed {@code mock}</p>
-     *
-     * @param mock The mock instance whose invocation handler is to be replaced.
-     * @param newHandler The new invocation handler instance.
-     * @param settings The mock settings - should you need to access some of the mock creation details.
-     * @since 1.9.5
-     */
-    void resetMock(
-            Object mock,
-            MockHandler newHandler,
-            MockCreationSettings settings
-    );
-
-    /**
-     * Indicates if the given type can be mocked by this mockmaker.
-     *
-     * <p>Mockmaker may have different capabilities in term of mocking, typically
-     * Mockito 1.x's internal mockmaker cannot mock final types. Other implementations, may
-     * have different limitations.</p>
-     *
-     * @param type The type inspected for mockability.
-     * @return object that carries the information about mockability of given type.
-     * @since 2.1.0
-     */
-    @Incubating
-    TypeMockability isTypeMockable(Class<?> type);
-
-    /**
-     * Carries the mockability information
-     *
-     * @since 2.1.0
-     */
-    @Incubating
-    interface TypeMockability {
-        /**
-         * informs if type is mockable
-         */
-        boolean mockable();
-
-        /**
-         * informs why type is not mockable
-         */
-        String nonMockableReason();
-    }
-}
diff --git a/src/main/java/org/mockito/plugins/MockitoPlugins.java b/src/main/java/org/mockito/plugins/MockitoPlugins.java
deleted file mode 100644
index d911077fdf..0000000000
--- a/src/main/java/org/mockito/plugins/MockitoPlugins.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.plugins;
-
-import org.mockito.Mockito;
-import org.mockito.MockitoFramework;
-
-/**
- * Instance of this interface is available via {@link MockitoFramework#getPlugins()}.
- * This object enables framework integrators to get access to default Mockito plugins.
- * <p>
- * Example use case: one needs to implement custom {@link MockMaker}
- * and delegate some behavior to the default Mockito implementation.
- * The interface was introduced to help framework integrations.
- *
- * @since 2.10.0
- */
-public interface MockitoPlugins {
-
-    /**
-     * Returns the default plugin implementation used by Mockito.
-     * Mockito plugins are stateless so it is recommended to keep hold of the returned plugin implementation
-     * rather than calling this method multiple times.
-     * Each time this method is called, new instance of the plugin is created.
-     *
-     * @param pluginType type of the plugin, for example {@link MockMaker}.
-     * @return the plugin instance
-     * @since 2.10.0
-     */
-    <T> T getDefaultPlugin(Class<T> pluginType);
-
-    /**
-     * Returns inline mock maker, an optional mock maker that is bundled with Mockito distribution.
-     * This method is needed because {@link #getDefaultPlugin(Class)} does not provide an instance of inline mock maker.
-     * Creates new instance each time is called so it is recommended to keep hold of the resulting object for future invocations.
-     * For more information about inline mock maker see the javadoc for main {@link Mockito} class.
-     *
-     * @return instance of inline mock maker
-     * @since 2.10.0
-     */
-    MockMaker getInlineMockMaker();
-}
diff --git a/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java b/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java
deleted file mode 100644
index ede608bbad..0000000000
--- a/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.runners;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.runner.Description;
-import org.junit.runner.Runner;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.Filterable;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.Failure;
-import org.junit.runner.notification.RunListener;
-import org.junit.runner.notification.RunNotifier;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.debugging.WarningsCollector;
-import org.mockito.internal.runners.InternalRunner;
-import org.mockito.internal.runners.RunnerFactory;
-import org.mockito.plugins.MockitoLogger;
-
-/**
- * @deprecated as of 2.1.0. Use the {@link org.mockito.junit.MockitoJUnitRunner} runner instead
- * which contains support for detecting unused stubs.
- * <p>
- * If you still prefer using this runner, tell us why (create ticket in our issue tracker).
- */
-@Deprecated
-public class ConsoleSpammingMockitoJUnitRunner extends Runner implements Filterable {
-
-    private final MockitoLogger logger;
-    private final InternalRunner runner;
-
-    public ConsoleSpammingMockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
-        this(Plugins.getMockitoLogger(), new RunnerFactory().create(klass));
-    }
-
-    ConsoleSpammingMockitoJUnitRunner(MockitoLogger logger, InternalRunner runner) {
-        this.runner = runner;
-        this.logger = logger;
-    }
-
-    @Override
-    public void run(RunNotifier notifier) {
-        RunListener listener = new RunListener() {
-            WarningsCollector warningsCollector;
-
-            @Override
-            public void testStarted(Description description) throws Exception {
-                warningsCollector = new WarningsCollector();
-            }
-
-            @Override public void testFailure(Failure failure) throws Exception {
-                logger.log(warningsCollector.getWarnings());
-            }
-        };
-
-        notifier.addListener(listener);
-
-        runner.run(notifier);
-    }
-
-    @Override
-    public Description getDescription() {
-        return runner.getDescription();
-    }
-
-    public void filter(Filter filter) throws NoTestsRemainException {
-        //filter is required because without it UnrootedTests show up in Eclipse
-        runner.filter(filter);
-    }
-}
diff --git a/src/main/java/org/mockito/runners/MockitoJUnitRunner.java b/src/main/java/org/mockito/runners/MockitoJUnitRunner.java
deleted file mode 100644
index 38522ce168..0000000000
--- a/src/main/java/org/mockito/runners/MockitoJUnitRunner.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.runners;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.runner.Description;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.RunNotifier;
-
-
-/**
- * Runner moved to a new place see {@link org.mockito.junit.MockitoJUnitRunner}
- *
- * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner}, this class will be removed with Mockito 4
- */
-@Deprecated
-public class MockitoJUnitRunner extends org.mockito.junit.MockitoJUnitRunner {
-
-    /**
-     * Silent runner moved to a new place see {@link org.mockito.junit.MockitoJUnitRunner.Silent}
-     *
-     * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner.Silent}, this class will be removed with Mockito 3
-     */
-    @Deprecated
-    public static class Silent extends MockitoJUnitRunner {
-        public Silent(Class<?> klass) throws InvocationTargetException {
-            super(klass);
-        }
-    }
-
-    /**
-     * Silent runner moved to a new place see {@link org.mockito.junit.MockitoJUnitRunner.Strict}
-     *
-     * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner.Strict}, this class will be removed with Mockito 3
-     */
-    @Deprecated
-    public static class Strict extends MockitoJUnitRunner {
-        public Strict(Class<?> klass) throws InvocationTargetException {
-            super(klass);
-        }
-    }
-
-    public MockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
-        super(klass);
-    }
-
-    @Deprecated
-    @Override
-    public void run(final RunNotifier notifier) {
-        super.run(notifier);
-    }
-
-    @Deprecated
-    @Override
-    public Description getDescription() {
-        return super.getDescription();
-    }
-
-    @Deprecated
-    public void filter(Filter filter) throws NoTestsRemainException {
-        super.filter(filter);
-    }
-}
diff --git a/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java b/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java
deleted file mode 100644
index 7a6f4d77e4..0000000000
--- a/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.runners;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.runner.Description;
-import org.junit.runner.Runner;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.Filterable;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.Failure;
-import org.junit.runner.notification.RunListener;
-import org.junit.runner.notification.RunNotifier;
-import org.mockito.internal.debugging.WarningsCollector;
-import org.mockito.internal.junit.util.JUnitFailureHacker;
-import org.mockito.internal.runners.InternalRunner;
-import org.mockito.internal.runners.RunnerFactory;
-
-/**
- * @deprecated as of 2.1.0. Use the {@link org.mockito.junit.MockitoJUnitRunner} runner instead
- * which contains support for detecting unused stubs.
- * <p>
- * If you still prefer using this runner, tell us why (create ticket in our issue tracker).
- */
-@Deprecated
-public class VerboseMockitoJUnitRunner extends Runner implements Filterable {
-
-    private final InternalRunner runner;
-
-    public VerboseMockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
-        this(new RunnerFactory().create(klass));
-    }
-
-    VerboseMockitoJUnitRunner(InternalRunner runner) {
-        this.runner = runner;
-    }
-
-    @Override
-    public void run(RunNotifier notifier) {
-
-        //a listener that changes the failure's exception in a very hacky way...
-        RunListener listener = new RunListener() {
-
-            WarningsCollector warningsCollector;
-
-            @Override
-            public void testStarted(Description description) throws Exception {
-                warningsCollector = new WarningsCollector();
-            }
-
-            @Override
-            @SuppressWarnings("deprecation")
-            public void testFailure(final Failure failure) throws Exception {
-                String warnings = warningsCollector.getWarnings();
-                new JUnitFailureHacker().appendWarnings(failure, warnings);
-            }
-        };
-
-        notifier.addFirstListener(listener);
-
-        runner.run(notifier);
-    }
-
-    @Override
-    public Description getDescription() {
-        return runner.getDescription();
-    }
-
-    public void filter(Filter filter) throws NoTestsRemainException {
-        //filter is required because without it UnrootedTests show up in Eclipse
-        runner.filter(filter);
-    }
-}
diff --git a/src/main/java/org/mockito/runners/package-info.java b/src/main/java/org/mockito/runners/package-info.java
deleted file mode 100644
index ab2fb8cb0e..0000000000
--- a/src/main/java/org/mockito/runners/package-info.java
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-/**
- * JUnit runners.
- */
-@Deprecated
-package org.mockito.runners;
diff --git a/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java b/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java
deleted file mode 100644
index 55437f12f6..0000000000
--- a/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.concurrentmockito;
-
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-//this test exposes the problem most of the time
-public class ThreadVerifiesContinuouslyInteractingMockTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    @Test
-    public void shouldAllowVerifyingInThreads() throws Exception {
-        for(int i = 0; i < 100; i++) {
-            performTest();
-        }
-    }
-
-    private void performTest() throws InterruptedException {
-        mock.simpleMethod();
-        final Thread[] listeners = new Thread[2];
-        for (int i = 0; i < listeners.length; i++) {
-            final int x = i;
-            listeners[i] = new Thread() {
-                @Override
-                public void run() {
-                    try {
-                        Thread.sleep(x * 10);
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                    mock.simpleMethod();
-                }
-            };
-            listeners[i].start();
-        }
-
-        verify(mock, atLeastOnce()).simpleMethod();
-
-        for (Thread listener : listeners) {
-            listener.join();
-        }
-    }
-}
diff --git a/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java b/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
deleted file mode 100644
index 66ffaa33b2..0000000000
--- a/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.concurrentmockito;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.notification.Failure;
-import org.mockito.MockitoTest;
-import org.mockito.exceptions.base.MockitoAssertionErrorTest;
-import org.mockito.exceptions.base.MockitoExceptionTest;
-import org.mockito.internal.AllInvocationsFinderTest;
-import org.mockito.internal.InvalidStateDetectionTest;
-import org.mockito.internal.creation.bytebuddy.TypeCachingMockBytecodeGeneratorTest;
-import org.mockito.internal.exceptions.ReporterTest;
-import org.mockito.internal.handler.MockHandlerImplTest;
-import org.mockito.internal.invocation.InvocationMatcherTest;
-import org.mockito.internal.invocation.InvocationsFinderTest;
-import org.mockito.internal.matchers.ComparableMatchersTest;
-import org.mockito.internal.matchers.EqualsTest;
-import org.mockito.internal.matchers.MatchersToStringTest;
-import org.mockito.internal.progress.MockingProgressImplTest;
-import org.mockito.internal.progress.TimesTest;
-import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValuesTest;
-import org.mockito.internal.stubbing.defaultanswers.ReturnsGenericDeepStubsTest;
-import org.mockito.internal.util.MockUtilTest;
-import org.mockito.internal.util.collections.ListUtilTest;
-import org.mockito.internal.verification.DefaultRegisteredInvocationsTest;
-import org.mockito.internal.verification.checkers.MissingInvocationCheckerTest;
-import org.mockito.internal.verification.checkers.MissingInvocationInOrderCheckerTest;
-import org.mockito.internal.verification.checkers.NumberOfInvocationsCheckerTest;
-import org.mockito.internal.verification.checkers.NumberOfInvocationsInOrderCheckerTest;
-import org.mockitousage.basicapi.ReplacingObjectMethodsTest;
-import org.mockitousage.basicapi.ResetTest;
-import org.mockitousage.basicapi.UsingVarargsTest;
-import org.mockitousage.examples.use.ExampleTest;
-import org.mockitousage.matchers.CustomMatchersTest;
-import org.mockitousage.matchers.InvalidUseOfMatchersTest;
-import org.mockitousage.matchers.MatchersTest;
-import org.mockitousage.matchers.VerificationAndStubbingUsingMatchersTest;
-import org.mockitousage.misuse.InvalidUsageTest;
-import org.mockitousage.puzzlers.BridgeMethodPuzzleTest;
-import org.mockitousage.puzzlers.OverloadingPuzzleTest;
-import org.mockitousage.stacktrace.ClickableStackTracesTest;
-import org.mockitousage.stacktrace.PointingStackTraceToActualInvocationTest;
-import org.mockitousage.stacktrace.StackTraceFilteringTest;
-import org.mockitousage.stubbing.BasicStubbingTest;
-import org.mockitousage.stubbing.ReturningDefaultValuesTest;
-import org.mockitousage.stubbing.StubbingWithThrowablesTest;
-import org.mockitousage.verification.*;
-import org.mockitoutil.TestBase;
-
-public class ThreadsRunAllTestsHalfManualTest extends TestBase {
-
-    private static class AllTestsRunner extends Thread {
-
-        private Set<Class<?>> failed = new HashSet<Class<?>>();
-
-        public void run() {
-            Result result = JUnitCore.runClasses(
-                    EqualsTest.class,
-                    ListUtilTest.class,
-                    MockingProgressImplTest.class,
-                    TimesTest.class,
-                    MockHandlerImplTest.class,
-                    AllInvocationsFinderTest.class,
-                    ReturnsEmptyValuesTest.class,
-                    NumberOfInvocationsCheckerTest.class,
-                    DefaultRegisteredInvocationsTest.class,
-                    MissingInvocationCheckerTest.class,
-                    NumberOfInvocationsInOrderCheckerTest.class,
-                    MissingInvocationInOrderCheckerTest.class,
-                    TypeCachingMockBytecodeGeneratorTest.class,
-                    InvocationMatcherTest.class,
-                    InvocationsFinderTest.class,
-                    MockitoTest.class,
-                    MockUtilTest.class,
-                    ReporterTest.class,
-                    MockitoAssertionErrorTest.class,
-                    MockitoExceptionTest.class,
-                    StackTraceFilteringTest.class,
-                    BridgeMethodPuzzleTest.class,
-                    OverloadingPuzzleTest.class,
-                    InvalidUsageTest.class,
-                    UsingVarargsTest.class,
-                    CustomMatchersTest.class,
-                    ComparableMatchersTest.class,
-                    InvalidUseOfMatchersTest.class,
-                    MatchersTest.class,
-                    MatchersToStringTest.class,
-                    VerificationAndStubbingUsingMatchersTest.class,
-                    BasicStubbingTest.class,
-                    ReturningDefaultValuesTest.class,
-                    StubbingWithThrowablesTest.class,
-                    AtMostXVerificationTest.class,
-                    BasicVerificationTest.class,
-                    ExactNumberOfTimesVerificationTest.class,
-                    VerificationInOrderTest.class,
-                    NoMoreInteractionsVerificationTest.class,
-                    SelectedMocksInOrderVerificationTest.class,
-                    VerificationOnMultipleMocksUsingMatchersTest.class,
-                    VerificationUsingMatchersTest.class,
-                    RelaxedVerificationInOrderTest.class,
-                    DescriptiveMessagesWhenVerificationFailsTest.class,
-                    DescriptiveMessagesWhenTimesXVerificationFailsTest.class,
-                    BasicVerificationInOrderTest.class,
-                    VerificationInOrderMixedWithOrdiraryVerificationTest.class,
-                    DescriptiveMessagesOnVerificationInOrderErrorsTest.class,
-                    InvalidStateDetectionTest.class,
-                    ReplacingObjectMethodsTest.class,
-                    ClickableStackTracesTest.class,
-                    ExampleTest.class,
-                    PointingStackTraceToActualInvocationTest.class,
-                    VerificationInOrderFromMultipleThreadsTest.class,
-                    ResetTest.class,
-                    ReturnsGenericDeepStubsTest.class
-                );
-
-                if (!result.wasSuccessful()) {
-                    System.err.println("Thread[" + Thread.currentThread().getId() + "]: error!");
-                    List<Failure> failures = result.getFailures();
-                    System.err.println(failures.size());
-                    for (Failure failure : failures) {
-                        System.err.println(failure.getTrace());
-                        failed.add(failure.getDescription().getTestClass());
-                    }
-                }
-        }
-
-        public Set<Class<?>> getFailed() {
-            return failed;
-        }
-    }
-
-    @Test
-    public void shouldRunInMultipleThreads() throws Exception {
-        //this test ALWAYS fails if there is a single failing unit
-        assertEquals("Run in multiple thread failed for tests", Collections.emptySet(), runInMultipleThreads(3));
-    }
-
-    public static Set<Class<?>> runInMultipleThreads(int numberOfThreads) throws Exception {
-        List<AllTestsRunner> threads = new LinkedList<AllTestsRunner>();
-        for (int i = 1; i <= numberOfThreads; i++) {
-            threads.add(new AllTestsRunner());
-        }
-
-        for (Thread t : threads) {
-            t.start();
-        }
-
-        Set<Class<?>> failed = new HashSet<Class<?>>();
-        for (AllTestsRunner t : threads) {
-            t.join();
-            failed.addAll(t.getFailed());
-        }
-
-        return failed;
-    }
-
-    public static void main(String[] args) throws Exception {
-        int numberOfThreads = 20;
-        long before = System.currentTimeMillis();
-        Set<Class<?>> failed = runInMultipleThreads(numberOfThreads);
-        long after = System.currentTimeMillis();
-        long executionTime = (after-before)/1000;
-        System.out.println("Finished tests in " + numberOfThreads + " threads in " + executionTime + " seconds. (" + failed.size() + " tests failed)");
-    }
-}
diff --git a/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java b/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
deleted file mode 100644
index 23ecdf129c..0000000000
--- a/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.concurrentmockito;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import org.junit.Test;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-//this test always passes but please keep looking sys err
-//this test should be run 10 times, manually
-public class ThreadsShareGenerouslyStubbedMockTest extends TestBase {
-
-    private IMethods mock;
-
-    @Test
-    public void shouldAllowVerifyingInThreads() throws Exception {
-        for(int i = 0; i < 50; i++) {
-            performTest();
-        }
-    }
-
-    private void performTest() throws InterruptedException {
-        mock = mock(IMethods.class);
-
-        when(mock.simpleMethod("foo"))
-            .thenReturn("foo")
-            .thenReturn("bar")
-            .thenReturn("baz")
-            .thenReturn("foo")
-            .thenReturn("bar")
-            .thenReturn("baz");
-
-        final Thread[] listeners = new Thread[100];
-        for (int i = 0; i < listeners.length; i++) {
-            listeners[i] = new Thread() {
-                @Override
-                public void run() {
-                    try {
-                        mock.simpleMethod("foo");
-                        mock.simpleMethod("foo");
-                        mock.simpleMethod("foo");
-                        mock.simpleMethod("foo");
-                        mock.simpleMethod("foo");
-                        mock.simpleMethod("foo");
-                    } catch (Exception e) {
-                        throw new RuntimeException(e);
-                    }
-                }
-            };
-            listeners[i].start();
-        }
-        for (Thread listener : listeners) {
-            listener.join();
-        }
-    }
-}
diff --git a/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java b/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
deleted file mode 100644
index b30d21a573..0000000000
--- a/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.concurrentmockito;
-
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockitoutil.TestBase;
-
-public class VerificationInOrderFromMultipleThreadsTest extends TestBase {
-
-    @Test
-    public void shouldVerifyInOrderWhenMultipleThreadsInteractWithMock() throws Exception {
-        final Foo testInf = mock(Foo.class);
-
-        Thread threadOne = new Thread(new Runnable(){
-            public void run() {
-                testInf.methodOne();
-            }
-        });
-        threadOne.start();
-        threadOne.join();
-
-        Thread threadTwo = new Thread(new Runnable(){
-            public void run() {
-                testInf.methodTwo();
-            }
-        });
-        threadTwo.start();
-        threadTwo.join();
-
-        InOrder inOrder = inOrder(testInf);
-        inOrder.verify(testInf).methodOne();
-        inOrder.verify(testInf).methodTwo();
-    }
-
-    public interface Foo {
-        void methodOne();
-        void methodTwo();
-    }
-}
diff --git a/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java b/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
deleted file mode 100644
index 145e23c6a7..0000000000
--- a/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static java.lang.annotation.ElementType.*;
-
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.mock;
-
-import java.lang.annotation.Annotation;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-
-public class AnnotationsAreCopiedFromMockedTypeTest {
-
-    @Test
-    public void mock_should_have_annotations_copied_from_mocked_type_at_class_level() {
-        AnnotationWithDefaultValue onClassDefaultValue = mock(OnClass.class).getClass().getAnnotation(AnnotationWithDefaultValue.class);
-        AnnotationWithCustomValue onClassCustomValue = mock(OnClass.class).getClass().getAnnotation(AnnotationWithCustomValue.class);
-
-        assumeTrue("Annotation copying does not apply for inline mocks", mock(OnClass.class).getClass() != OnClass.class);
-
-        Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
-        Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
-    }
-
-    @Test
-    public void mock_should_have_annotations_copied_from_mocked_type_on_methods() {
-        AnnotationWithDefaultValue onClassDefaultValue = method("method", mock(OnMethod.class)).getAnnotation(AnnotationWithDefaultValue.class);
-        AnnotationWithCustomValue onClassCustomValue = method("method", mock(OnMethod.class)).getAnnotation(AnnotationWithCustomValue.class);
-
-        Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
-        Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
-    }
-
-    @Test
-    public void mock_should_have_annotations_copied_from_mocked_type_on_method_parameters() {
-        AnnotationWithDefaultValue onClassDefaultValue = firstParamOf(method("method", mock(OnMethod.class))).getAnnotation(AnnotationWithDefaultValue.class);
-        AnnotationWithCustomValue onClassCustomValue = firstParamOf(method("method", mock(OnMethod.class))).getAnnotation(AnnotationWithCustomValue.class);
-
-        Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
-        Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
-    }
-
-    private AnnotatedElement firstParamOf(Method method) {
-        final Annotation[] firstParamAnnotations = method.getParameterAnnotations()[0];
-
-        return new AnnotatedElement() {
-            @Override
-            public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
-                return getAnnotation(annotationClass) != null;
-            }
-
-            @Override
-            @SuppressWarnings("unchecked")
-            public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-                for (Annotation firstParamAnnotation : firstParamAnnotations) {
-                    if (annotationClass.isAssignableFrom(firstParamAnnotation.annotationType())) {
-                        return (T) firstParamAnnotation;
-                    }
-                }
-                return null;
-            }
-
-            @Override
-            public Annotation[] getAnnotations() {
-                return firstParamAnnotations;
-            }
-
-            @Override
-            public Annotation[] getDeclaredAnnotations() {
-                return firstParamAnnotations;
-            }
-        };
-    }
-
-    private Method method(String methodName, Object mock) {
-        for (Method method : mock.getClass().getDeclaredMethods()) {
-            if(methodName.equals(method.getName())) {
-                return method;
-            }
-        }
-        throw new IllegalArgumentException("method name not found : " + methodName);
-    }
-
-    private Field field(String fieldName, Object mock) {
-        for (Field field : mock.getClass().getDeclaredFields()) {
-            if(fieldName.equals(field.getName())) {
-                return field;
-            }
-        }
-        throw new IllegalArgumentException("method name not found : " + fieldName);
-    }
-
-    @AnnotationWithDefaultValue
-    @AnnotationWithCustomValue("yay")
-    public class OnClass { }
-
-
-    public class OnMethod {
-        @AnnotationWithDefaultValue
-        @AnnotationWithCustomValue("yay")
-        public String method(
-                @AnnotationWithDefaultValue
-                @AnnotationWithCustomValue("yay")
-                String ignored
-        ) { return ""; }
-    }
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @Target({TYPE, METHOD, PARAMETER, FIELD})
-    public @interface AnnotationWithDefaultValue {
-        String value() default "yup";
-    }
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @Target({TYPE, METHOD, PARAMETER, FIELD})
-    public @interface AnnotationWithCustomValue {
-        String value() default "";
-    }
-}
diff --git a/src/test/java/org/mockito/ArgumentCaptorTest.java b/src/test/java/org/mockito/ArgumentCaptorTest.java
deleted file mode 100644
index 77ecf0d3be..0000000000
--- a/src/test/java/org/mockito/ArgumentCaptorTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.validateMockitoUsage;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
-
-public class ArgumentCaptorTest {
-
-    /**
-     * Clean up the internal Mockito-Stubbing state
-     */
-    @After
-    public void tearDown() {
-        try {
-            validateMockitoUsage();
-        } catch (InvalidUseOfMatchersException ignore) {
-        }
-
-    }
-
-    @Test
-    public void tell_handy_return_values_to_return_value_for() throws Exception {
-
-        ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(Object.class);
-        assertThat(captor.capture()).isNull();
-
-    }
-
-}
diff --git a/src/test/java/org/mockito/InvocationFactoryTest.java b/src/test/java/org/mockito/InvocationFactoryTest.java
deleted file mode 100644
index 229fbcb38f..0000000000
--- a/src/test/java/org/mockito/InvocationFactoryTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.withSettings;
-
-import java.util.concurrent.Callable;
-
-import org.junit.Test;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationFactory;
-import org.mockitoutil.TestBase;
-
-public class InvocationFactoryTest extends TestBase {
-    static class TestClass {
-        public String testMethod() throws Throwable {
-            return "un-mocked";
-        }
-    }
-
-    final TestClass mock = spy(TestClass.class);
-
-    @Test
-    public void call_method_that_throws_a_throwable() throws Throwable {
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
-            withSettings().build(TestClass.class),
-            TestClass.class.getDeclaredMethod("testMethod"),
-            new InvocationFactory.RealMethodBehavior() {
-            @Override
-            public Object call() throws Throwable {
-                throw new Throwable("mocked");
-            }
-        });
-
-        try {
-            Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
-        } catch (Throwable t) {
-            assertEquals("mocked", t.getMessage());
-            return;
-        }
-
-        fail();
-    }
-
-    @Test
-    public void call_method_that_returns_a_string() throws Throwable {
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
-            withSettings().build(TestClass.class),
-            TestClass.class.getDeclaredMethod("testMethod"),
-            new InvocationFactory.RealMethodBehavior() {
-                @Override
-                public Object call() throws Throwable {
-                    return "mocked";
-                }
-            });
-
-        Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
-        assertEquals("mocked", ret);
-    }
-
-    @Test
-    public void deprecated_api_still_works() throws Throwable {
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
-            withSettings().build(TestClass.class),
-            TestClass.class.getDeclaredMethod("testMethod"),
-            new Callable() {
-                public Object call() throws Exception {
-                    return "mocked";
-                }
-            });
-
-        Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
-        assertEquals("mocked", ret);
-    }
-}
diff --git a/src/test/java/org/mockito/MockitoTest.java b/src/test/java/org/mockito/MockitoTest.java
deleted file mode 100644
index fb75024a27..0000000000
--- a/src/test/java/org/mockito/MockitoTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.times;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.exceptions.misusing.NullInsteadOfMockException;
-import org.mockito.internal.creation.MockSettingsImpl;
-
-@SuppressWarnings("unchecked")
-public class MockitoTest {
-
-    @Test
-    public void shouldRemoveStubbableFromProgressAfterStubbing() {
-        List mock = Mockito.mock(List.class);
-        Mockito.when(mock.add("test")).thenReturn(true);
-        //TODO Consider to move to separate test
-        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));
-    }
-
-    @Test(expected=NotAMockException.class)
-    public void shouldValidateMockWhenVerifyingNoMoreInteractions() {
-        Mockito.verifyNoMoreInteractions("notMock");
-    }
-
-    @Test(expected=NotAMockException.class)
-    public void shouldValidateMockWhenVerifyingZeroInteractions() {
-        Mockito.verifyZeroInteractions("notMock");
-    }
-
-    @Test(expected=NotAMockException.class)
-    public void shouldValidateMockWhenVerifyingNoInteractions() {
-        Mockito.verifyNoInteractions("notMock");
-    }
-
-    @Test(expected=NullInsteadOfMockException.class)
-    public void shouldValidateNullMockWhenVerifyingNoInteractions() {
-        Mockito.verifyNoInteractions(new Object[] { null });
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test(expected=NotAMockException.class)
-    public void shouldValidateMockWhenCreatingInOrderObject() {
-        Mockito.inOrder("notMock");
-    }
-
-    @Test
-    public void shouldStartingMockSettingsContainDefaultBehavior() {
-        //when
-        MockSettingsImpl<?> settings = (MockSettingsImpl<?>) Mockito.withSettings();
-
-        //then
-        assertThat(Mockito.RETURNS_DEFAULTS).isEqualTo(settings.getDefaultAnswer());
-    }
-
-}
diff --git a/src/test/java/org/mockito/StaticMockingExperimentTest.java b/src/test/java/org/mockito/StaticMockingExperimentTest.java
deleted file mode 100644
index 59401c8794..0000000000
--- a/src/test/java/org/mockito/StaticMockingExperimentTest.java
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationFactory;
-import org.mockito.invocation.MockHandler;
-import org.mockitoutil.TestBase;
-
-/**
- * This test is an experimental use of Mockito API to simulate static mocking.
- * Other frameworks can use it to build good support for static mocking.
- * Keep in mind that clean code never needs to mock static methods.
- * This test is a documentation how it can be done using current public API of Mockito.
- * This test is not only an experiment it also provides coverage for
- * some of the advanced public API exposed for framework integrators.
- * <p>
- * For more rationale behind this experimental test
- * <a href="https://www.linkedin.com/pulse/mockito-vs-powermock-opinionated-dogmatic-static-mocking-faber">see the article</a>.
- */
-public class StaticMockingExperimentTest extends TestBase {
-
-    Foo mock = Mockito.mock(Foo.class);
-    MockHandler handler = Mockito.mockingDetails(mock).getMockHandler();
-    Method staticMethod;
-    InvocationFactory.RealMethodBehavior realMethod = new InvocationFactory.RealMethodBehavior() {
-        @Override
-        public Object call() throws Throwable {
-            return null;
-        }
-    };
-
-    @Before public void before() throws Throwable {
-        staticMethod = Foo.class.getDeclaredMethod("staticMethod", String.class);
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test
-    public void verify_static_method() throws Throwable {
-        //register staticMethod call on mock
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "some arg");
-        handler.handle(invocation);
-
-        //verify staticMethod on mock
-        //Mockito cannot capture static methods so we will simulate this scenario in 3 steps:
-        //1. Call standard 'verify' method. Internally, it will add verificationMode to the thread local state.
-        //  Effectively, we indicate to Mockito that right now we are about to verify a method call on this mock.
-        verify(mock);
-        //2. Create the invocation instance using the new public API
-        //  Mockito cannot capture static methods but we can create an invocation instance of that static invocation
-        Invocation verification = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "some arg");
-        //3. Make Mockito handle the static method invocation
-        //  Mockito will find verification mode in thread local state and will try verify the invocation
-        handler.handle(verification);
-
-        //verify zero times, method with different argument
-        verify(mock, times(0));
-        Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "different arg");
-        handler.handle(differentArg);
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test
-    public void verification_failure_static_method() throws Throwable {
-        //register staticMethod call on mock
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "foo");
-        handler.handle(invocation);
-
-        //verify staticMethod on mock
-        verify(mock);
-        Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "different arg");
-
-        try {
-            handler.handle(differentArg);
-            fail();
-        } catch (ArgumentsAreDifferent e) {}
-    }
-
-    @Test
-    public void stubbing_static_method() throws Throwable {
-        //register staticMethod call on mock
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "foo");
-        handler.handle(invocation);
-
-        //register stubbing
-        when(null).thenReturn("hey");
-
-        //validate stubbed return value
-        assertEquals("hey", handler.handle(invocation));
-        assertEquals("hey", handler.handle(invocation));
-
-        //default null value is returned if invoked with different argument
-        Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "different arg");
-        assertEquals(null, handler.handle(differentArg));
-    }
-
-    @Test
-    public void do_answer_stubbing_static_method() throws Throwable {
-        //register stubbed return value
-        doReturn("hey").when(mock);
-
-        //complete stubbing by triggering an invocation that needs to be stubbed
-        Invocation invocation = Mockito.framework().getInvocationFactory()
-            .createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod, "foo");
-        handler.handle(invocation);
-
-        //validate stubbed return value
-        assertEquals("hey", handler.handle(invocation));
-        assertEquals("hey", handler.handle(invocation));
-
-        //default null value is returned if invoked with different argument
-        Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "different arg");
-        assertEquals(null, handler.handle(differentArg));
-    }
-
-    @Test
-    public void verify_no_more_interactions() throws Throwable {
-        //works for now because there are not interactions
-        verifyNoMoreInteractions(mock);
-
-        //register staticMethod call on mock
-        Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
-            "foo");
-        handler.handle(invocation);
-
-        //fails now because we have one static invocation recorded
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void stubbing_new() throws Throwable {
-        Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
-        Method adapter = ConstructorMethodAdapter.class.getDeclaredMethods()[0];
-
-        //stub constructor
-        doReturn(new Foo("hey!")).when(mock);
-        Invocation constructor = Mockito.framework().getInvocationFactory().createInvocation(
-            mock, withSettings().build(Foo.class), adapter, realMethod, ctr, "foo");
-        handler.handle(constructor);
-
-        //test stubbing
-        Object result = handler.handle(constructor);
-        assertEquals("foo:hey!", result.toString());
-
-        //stubbing miss
-        Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class),
-            adapter, realMethod, ctr, "different arg");
-        Object result2 = handler.handle(differentArg);
-        assertEquals(null, result2);
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test
-    public void verifying_new() throws Throwable {
-        Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
-        Method adapter = ConstructorMethodAdapter.class.getDeclaredMethods()[0];
-
-        //invoke constructor
-        Invocation constructor = Mockito.framework().getInvocationFactory().createInvocation(
-            mock, withSettings().build(Foo.class), adapter, realMethod, ctr, "matching arg");
-        handler.handle(constructor);
-
-        //verify successfully
-        verify(mock);
-        handler.handle(constructor);
-
-        //verification failure
-        verify(mock);
-        Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class),
-            adapter, realMethod, ctr, "different arg");
-        try {
-            handler.handle(differentArg);
-            fail();
-        } catch (WantedButNotInvoked e) {
-            assertThat(e.getMessage())
-                .contains("matching arg")
-                .contains("different arg");
-        }
-    }
-
-    static class Foo {
-
-        private final String arg;
-
-        public Foo(String arg) {
-            this.arg = arg;
-        }
-
-        public static String staticMethod(String arg) {
-            return "";
-        }
-
-        @Override
-        public String toString() {
-            return "foo:" + arg;
-        }
-    }
-
-    /**
-     * Adapts constructor to method calls needed to work with Mockito API.
-     */
-    interface ConstructorMethodAdapter {
-        Object construct(Constructor constructor, Object... args);
-    }
-}
diff --git a/src/test/java/org/mockito/configuration/MockitoConfiguration.java b/src/test/java/org/mockito/configuration/MockitoConfiguration.java
deleted file mode 100644
index bc7df845b4..0000000000
--- a/src/test/java/org/mockito/configuration/MockitoConfiguration.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.configuration;
-
-import org.mockito.stubbing.Answer;
-import org.mockitousage.configuration.CustomizedAnnotationForSmartMockTest;
-
-public class MockitoConfiguration extends DefaultMockitoConfiguration implements IMockitoConfiguration {
-
-    private Answer<Object> overriddenDefaultAnswer = null;
-
-    private boolean cleansStackTrace;
-
-    private AnnotationEngine overriddenEngine;
-
-    private boolean enableClassCache = true;
-
-    //for testing purposes, allow to override the configuration
-    public void overrideDefaultAnswer(Answer<Object> defaultAnswer) {
-        this.overriddenDefaultAnswer = defaultAnswer;
-    }
-
-    //for testing purposes, allow to override the configuration
-    public void overrideCleansStackTrace(boolean cleansStackTrace) {
-        this.cleansStackTrace = cleansStackTrace;
-    }
-
-    //for testing purposes, allow to override the annotation engine
-    public void overrideAnnotationEngine(AnnotationEngine engine) {
-        this.overriddenEngine = engine;
-    }
-
-    //for testing purposes, allow to override the annotation engine
-    public void overrideEnableClassCache(boolean enableClassCache) {
-        this.enableClassCache = enableClassCache;
-    }
-
-    @Override
-    public Answer<Object> getDefaultAnswer() {
-        if (overriddenDefaultAnswer == null) {
-            return super.getDefaultAnswer();
-        } else {
-            return overriddenDefaultAnswer;
-        }
-    }
-
-    @Override
-    public AnnotationEngine getAnnotationEngine() {
-        if (this.overriddenEngine != null) {
-            return this.overriddenEngine;
-        }
-        return new CustomizedAnnotationForSmartMockTest.CustomInjectingAnnotationEngine();
-    }
-
-    @Override
-    public boolean cleansStackTrace() {
-        return cleansStackTrace;
-    }
-
-    @Override
-    public boolean enableClassCache() {
-        return enableClassCache;
-    }
-
-}
diff --git a/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java b/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
deleted file mode 100644
index 0aa961ee06..0000000000
--- a/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.exceptions.base;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.util.Arrays;
-
-import org.junit.Test;
-import org.mockito.internal.configuration.ConfigurationAccess;
-
-public class MockitoSerializationIssueTest {
-
-    @Test
-    public void should_filter_out_test_class_from_stacktrace_when_clean_flag_is_true() {
-        // given
-        ConfigurationAccess.getConfig().overrideCleansStackTrace(true);
-
-        // when
-        MockitoSerializationIssue issue = new MockitoSerializationIssue("msg", new Exception("cause"));
-
-        // then
-        assertThat(Arrays.toString(issue.getUnfilteredStackTrace())).contains("MockitoSerializationIssueTest");
-        assertThat(Arrays.toString(issue.getStackTrace())).doesNotContain("MockitoSerializationIssueTest");
-    }
-
-    @Test
-    public void should_keep_executing_class_in_stacktrace_when_clean_flag_is_false() {
-        // given
-        ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
-
-        // when
-        MockitoSerializationIssue issue = new MockitoSerializationIssue("msg", new Exception("cause"));
-
-        // then
-        assertThat(Arrays.toString(issue.getUnfilteredStackTrace())).contains("MockitoSerializationIssueTest");
-        assertThat(Arrays.toString(issue.getStackTrace())).contains("MockitoSerializationIssueTest");
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java b/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
deleted file mode 100644
index 035e108c2e..0000000000
--- a/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-
-import org.junit.Test;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class ClassPathLoaderTest extends TestBase {
-
-    @Test
-    public void shouldReadConfigurationClassFromClassPath() {
-        ConfigurationAccess.getConfig().overrideDefaultAnswer(new Answer<Object>() {
-            public Object answer(InvocationOnMock invocation) {
-                return "foo";
-            }});
-
-        IMethods mock = mock(IMethods.class);
-        assertEquals("foo", mock.simpleMethod());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java b/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
deleted file mode 100644
index b8d0a5612a..0000000000
--- a/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import net.bytebuddy.ByteBuddy;
-import org.assertj.core.api.Assertions;
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.configuration.AnnotationEngine;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockitoutil.ClassLoaders;
-import org.objenesis.Objenesis;
-
-public class GlobalConfigurationTest {
-    @Test
-    public void returns_mockito_configuration_annotation_engine_if_non_default() throws Exception {
-        ConfigurationAccess.getConfig().overrideAnnotationEngine(new CustomAnnotationEngine());
-        assertThat(new GlobalConfiguration().getAnnotationEngine()).isInstanceOf(CustomAnnotationEngine.class);
-        assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine()).isInstanceOf(CustomAnnotationEngine.class);
-    }
-
-    @Test
-    public void returns_mockito_annotation_engine_of_Plugins_if_no_MockitoConfiguration() throws Throwable {
-        ClassLoader anotherWorld = ClassLoaders.isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, Objenesis.class)
-                .withPrivateCopyOf("org.mockito", "net.bytebuddy", "org.objenesis")
-                .withCodeSourceUrlOf(Assertions.class)
-                .withPrivateCopyOf("org.assertj")
-                .without("org.mockito.configuration.MockitoConfiguration")
-                .build();
-
-        ClassLoaders.using(anotherWorld).execute(new Runnable() {
-            @Override
-            public void run() {
-                assertThat(new GlobalConfiguration().getAnnotationEngine()).isInstanceOf(Plugins.getAnnotationEngine().getClass());
-                assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine()).isInstanceOf(Plugins.getAnnotationEngine().getClass());
-            }
-        });
-    }
-
-    @After
-    public void reset_annotation_engine() {
-        ConfigurationAccess.getConfig().overrideAnnotationEngine(null);
-    }
-
-    private static class CustomAnnotationEngine implements AnnotationEngine {
-        @Override public void process(Class<?> clazz, Object testInstance) { }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java b/src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java
deleted file mode 100644
index 7a8b064f68..0000000000
--- a/src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.mockito.junit.MockitoJUnitRunner;
-
-class I { }
-
-@RunWith(MockitoJUnitRunner.class)
-public class InjectingAnnotationEngineTest extends I {
-    @InjectMocks
-    Target target;
-    @Mock
-    Foo foo;
-    @Spy
-    Bar bar = new Bar();
-
-    /*
-     If the test case has super classes, the @InjectMocks field has a field that not listed in the constructor argument
-     will fill by setter/property injection .
-
-     https://github.com/mockito/mockito/issues/1631
-    */
-    @Test
-    public void injectMocks() {
-        Assert.assertEquals(foo, target.getFoo());
-        Assert.assertNotNull(target.getBar());
-    }
-
-    public static class Target {
-        private final Foo foo;
-        private Bar bar;
-
-        public Target(Foo foo) {
-            this.foo = foo;
-        }
-
-        public Foo getFoo() {
-            return foo;
-        }
-
-        public Bar getBar() {
-            return bar;
-        }
-    }
-
-    public static class Foo {
-    }
-
-    public static class Bar {
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java b/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
deleted file mode 100644
index 4bd16c3c23..0000000000
--- a/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
-import java.lang.reflect.Field;
-import java.util.Collections;
-import java.util.Observer;
-import java.util.Set;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.internal.configuration.injection.MockInjection;
-
-@SuppressWarnings("unchecked")
-public class MockInjectionTest {
-
-    private AnObjectWithConstructor withConstructor;
-    private AnObjectWithoutConstructor withoutConstructor;
-
-    @After
-    public void reset() throws Exception {
-        withConstructor = null;
-        withoutConstructor = null;
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void should_not_allow_null_on_field() {
-        MockInjection.onField((Field) null, this);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void should_not_allow_null_on_fields() {
-        MockInjection.onFields((Set<Field>) null, this);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void should_not_allow_null_on_instance_owning_the_field() throws Exception {
-        MockInjection.onField(field("withConstructor"), null);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void should_not_allow_null_on_mocks() throws Exception {
-        MockInjection.onField(field("withConstructor"), this).withMocks(null);
-    }
-
-
-    @Test
-    public void can_try_constructor_injection() throws Exception {
-        MockInjection.onField(field("withConstructor"), this).withMocks(oneSetMock()).tryConstructorInjection().apply();
-
-        assertThat(withConstructor.initializedWithConstructor).isEqualTo(true);
-    }
-
-    @Test
-    public void should_not_fail_if_constructor_injection_is_not_possible() throws Exception {
-        MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryConstructorInjection().apply();
-
-        assertThat(withoutConstructor).isNull();
-    }
-
-    @Test
-    public void can_try_property_or_setter_injection() throws Exception {
-        MockInjection.onField(field("withoutConstructor"), this).withMocks(oneSetMock()).tryPropertyOrFieldInjection().apply();
-
-        assertThat(withoutConstructor.theSet).isNotNull();
-    }
-
-    @Test
-    public void should_not_fail_if_property_or_field_injection_is_not_possible() throws Exception {
-        MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryPropertyOrFieldInjection().apply();
-
-        assertThat(withoutConstructor.theSet).isNull();
-    }
-
-    private Set oneSetMock() {
-        return Collections.singleton(mock(Set.class));
-    }
-
-    private Set otherKindOfMocks() {
-        return Collections.singleton(mock(Observer.class));
-    }
-
-    private Field field(String field) throws NoSuchFieldException {
-        return getClass().getDeclaredField(field);
-    }
-
-
-    public static class AnObjectWithConstructor {
-        public boolean initializedWithConstructor = false;
-        public AnObjectWithConstructor(Set<String> strings) {
-            initializedWithConstructor = true;
-        }
-    }
-
-    public static class AnObjectWithoutConstructor {
-        private Set<?> theSet;
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java b/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java
deleted file mode 100644
index 70f5b497f3..0000000000
--- a/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.injection;
-
-import static org.junit.Assert.*;
-
-import java.io.ByteArrayOutputStream;
-import java.io.OutputStream;
-import java.util.*;
-
-import org.junit.Test;
-
-public class SimpleArgumentResolverTest {
-
-    @Test
-    public void should_return_object_matching_given_types() throws Exception {
-        ConstructorInjection.SimpleArgumentResolver resolver =
-                new ConstructorInjection.SimpleArgumentResolver(newSetOf(new HashSet<Long>(), new ByteArrayOutputStream(), new HashMap<String, String>()));
-
-        Object[] resolvedInstance = resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
-
-        assertEquals(3, resolvedInstance.length);
-        assertTrue(resolvedInstance[0] instanceof Set);
-        assertTrue(resolvedInstance[1] instanceof Map);
-        assertTrue(resolvedInstance[2] instanceof OutputStream);
-    }
-
-    @Test
-    public void should_return_null_when_match_is_not_possible_on_given_types() throws Exception {
-        ConstructorInjection.SimpleArgumentResolver resolver =
-                new ConstructorInjection.SimpleArgumentResolver(newSetOf(new HashSet<Float>(), new ByteArrayOutputStream()));
-
-        Object[] resolvedInstance = resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
-
-        assertEquals(3, resolvedInstance.length);
-        assertTrue(resolvedInstance[0] instanceof Set);
-        assertNull(resolvedInstance[1]);
-        assertTrue(resolvedInstance[2] instanceof OutputStream);
-    }
-
-    @Test
-    public void should_return_null_when_types_are_primitives() throws Exception {
-        ConstructorInjection.SimpleArgumentResolver resolver =
-                new ConstructorInjection.SimpleArgumentResolver(newSetOf(new HashMap<Integer, String>(), new TreeSet<Integer>()));
-
-        Object[] resolvedInstance = resolver.resolveTypeInstances(Set.class, Map.class, Boolean.class);
-
-        assertEquals(3, resolvedInstance.length);
-        assertTrue(resolvedInstance[0] instanceof Set);
-        assertTrue(resolvedInstance[1] instanceof Map);
-        assertNull(resolvedInstance[2]);
-    }
-
-    private Set<Object> newSetOf(Object... objects) {
-        return new HashSet<Object>(Arrays.asList(objects));
-    }
-
-
-}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java b/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
deleted file mode 100644
index 1324cc8289..0000000000
--- a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import static org.junit.Assert.*;
-import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.INLINE_ALIAS;
-
-import org.junit.Test;
-import org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker;
-import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
-import org.mockito.internal.util.ConsoleMockitoLogger;
-import org.mockito.plugins.InstantiatorProvider;
-import org.mockito.plugins.InstantiatorProvider2;
-import org.mockito.plugins.MockMaker;
-import org.mockito.plugins.MockitoLogger;
-import org.mockitoutil.TestBase;
-
-public class DefaultMockitoPluginsTest extends TestBase {
-
-    private DefaultMockitoPlugins plugins = new DefaultMockitoPlugins();
-
-    @Test
-    public void provides_plugins() throws Exception {
-        assertEquals("org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker",
-            plugins.getDefaultPluginClass(INLINE_ALIAS));
-        assertEquals(InlineByteBuddyMockMaker.class, plugins.getInlineMockMaker().getClass());
-        assertEquals(ByteBuddyMockMaker.class, plugins.getDefaultPlugin(MockMaker.class).getClass());
-        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider.class));
-        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
-        assertEquals(ConsoleMockitoLogger.class, plugins.getDefaultPlugin(MockitoLogger.class).getClass());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java b/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
deleted file mode 100644
index b922dddd57..0000000000
--- a/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import static java.util.Arrays.asList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.when;
-
-import java.io.File;
-import java.net.URL;
-import java.util.Collections;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.internal.util.io.IOUtil;
-import org.mockito.plugins.PluginSwitch;
-import org.mockitoutil.TestBase;
-
-public class PluginFinderTest extends TestBase {
-
-    @Mock
-    PluginSwitch switcher;
-    @InjectMocks PluginFinder finder;
-    public @Rule TemporaryFolder tmp = new TemporaryFolder();
-
-    @Test public void empty_resources() {
-        assertNull(finder.findPluginClass(Collections.<URL>emptyList()));
-    }
-
-    @Test public void no_valid_impl() throws Exception {
-        File f = tmp.newFile();
-
-        //when
-        IOUtil.writeText("  \n  ", f);
-
-        //then
-        assertNull(finder.findPluginClass(asList(f.toURI().toURL())));
-    }
-
-    @Test public void single_implementation() throws Exception {
-        File f = tmp.newFile();
-        when(switcher.isEnabled("foo.Foo")).thenReturn(true);
-
-        //when
-        IOUtil.writeText("  foo.Foo  ", f);
-
-        //then
-        assertEquals("foo.Foo", finder.findPluginClass(asList(f.toURI().toURL())));
-    }
-
-    @Test public void single_implementation_disabled() throws Exception {
-        File f = tmp.newFile();
-        when(switcher.isEnabled("foo.Foo")).thenReturn(false);
-
-        //when
-        IOUtil.writeText("  foo.Foo  ", f);
-
-        //then
-        assertEquals(null, finder.findPluginClass(asList(f.toURI().toURL())));
-    }
-
-    @Test public void multiple_implementations_only_one_enabled() throws Exception {
-        File f1 = tmp.newFile(); File f2 = tmp.newFile();
-
-        when(switcher.isEnabled("Bar")).thenReturn(true);
-
-        //when
-        IOUtil.writeText("Foo", f1); IOUtil.writeText("Bar", f2);
-
-        //then
-        assertEquals("Bar", finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
-    }
-
-    @Test public void multiple_implementations_only_one_useful() throws Exception {
-        File f1 = tmp.newFile(); File f2 = tmp.newFile();
-
-        when(switcher.isEnabled(anyString())).thenReturn(true);
-
-        //when
-        IOUtil.writeText("   ", f1); IOUtil.writeText("X", f2);
-
-        //then
-        assertEquals("X", finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
-    }
-
-    @Test public void multiple_empty_implementations() throws Exception {
-        File f1 = tmp.newFile(); File f2 = tmp.newFile();
-
-        when(switcher.isEnabled(anyString())).thenReturn(true);
-
-        //when
-        IOUtil.writeText("   ", f1); IOUtil.writeText("\n", f2);
-
-        //then
-        assertEquals(null, finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
-    }
-
-    @Test public void problems_loading_impl() throws Exception {
-        when(switcher.isEnabled(anyString())).thenThrow(new RuntimeException("Boo!"));
-
-        try {
-            //when
-            finder.findPluginClass(asList(new File("xxx").toURI().toURL()));
-            //then
-            fail();
-        } catch(Exception e) {
-            assertThat(e).hasMessageContaining("xxx");
-            e.getCause().getMessage().equals("Boo!");
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java b/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
deleted file mode 100644
index cae06b40c6..0000000000
--- a/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.configuration.plugins;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
-import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.when;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.quality.Strictness;
-
-public class PluginLoaderTest {
-
-    @Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
-
-    @Mock PluginInitializer initializer;
-    @Mock DefaultMockitoPlugins plugins;
-    @InjectMocks PluginLoader loader;
-
-    @Test
-    public void loads_plugin() {
-        when(initializer.loadImpl(FooPlugin.class)).thenReturn(new FooPlugin());
-
-        //when
-        FooPlugin plugin = loader.loadPlugin(FooPlugin.class);
-
-        //then
-        assertNotNull(plugin);
-    }
-
-    @Test
-    public void loads_alternative_plugin() {
-        willReturn(null).given(initializer).loadImpl(FooPlugin.class);
-        BarPlugin expected = new BarPlugin();
-        willReturn(expected).given(initializer).loadImpl(BarPlugin.class);
-
-        //when
-        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
-
-        //then
-        assertSame(plugin, expected);
-    }
-
-    @Test
-    public void loads_default_plugin() {
-        willReturn(null).given(initializer).loadImpl(FooPlugin.class);
-        willReturn(null).given(initializer).loadImpl(BarPlugin.class);
-        FooPlugin expected = new FooPlugin();
-        willReturn(expected).given(plugins).getDefaultPlugin(FooPlugin.class);
-
-        //when
-        Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
-
-        //then
-        assertSame(plugin, expected);
-    }
-
-    @Test
-    public void fails_to_load_plugin() {
-        RuntimeException cause = new RuntimeException("Boo!");
-        when(initializer.loadImpl(Foo.class)).thenThrow(cause);
-
-        //when
-        final Foo plugin = loader.loadPlugin(Foo.class);
-
-        //then
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            @Override
-            public void call() throws Throwable {
-                plugin.toString(); //call any method on the plugin
-            }
-        }).isInstanceOf(IllegalStateException.class)
-            .hasMessage("Could not initialize plugin: interface org.mockito.internal.configuration.plugins.PluginLoaderTest$Foo (alternate: null)")
-            .hasCause(cause);
-    }
-
-    static class FooPlugin {}
-    static class BarPlugin {}
-    static interface Foo {}
-}
diff --git a/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java b/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
deleted file mode 100644
index fe0c20188f..0000000000
--- a/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-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.List;
-import java.util.Set;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.debugging.VerboseMockInvocationLogger;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.StubbingLookupListener;
-import org.mockitoutil.TestBase;
-
-public class MockSettingsImplTest extends TestBase {
-
-    private MockSettingsImpl<?> mockSettingsImpl = new MockSettingsImpl<Object>();
-
-    @Mock private InvocationListener invocationListener;
-    @Mock private StubbingLookupListener stubbingLookupListener;
-
-    @Test(expected=MockitoException.class)
-    @SuppressWarnings("unchecked")
-    public void shouldNotAllowSettingNullInterface() {
-        mockSettingsImpl.extraInterfaces(List.class, null);
-    }
-
-    @Test(expected=MockitoException.class)
-    @SuppressWarnings("unchecked")
-    public void shouldNotAllowNonInterfaces() {
-        mockSettingsImpl.extraInterfaces(List.class, LinkedList.class);
-    }
-
-    @Test(expected=MockitoException.class)
-    @SuppressWarnings("unchecked")
-    public void shouldNotAllowUsingTheSameInterfaceAsExtra() {
-        mockSettingsImpl.extraInterfaces(List.class, LinkedList.class);
-    }
-
-    @Test(expected=MockitoException.class)
-    @SuppressWarnings("unchecked")
-    public void shouldNotAllowEmptyExtraInterfaces() {
-        mockSettingsImpl.extraInterfaces();
-    }
-
-    @Test(expected=MockitoException.class)
-    @SuppressWarnings("unchecked")
-    public void shouldNotAllowNullArrayOfExtraInterfaces() {
-        mockSettingsImpl.extraInterfaces((Class<?>[]) null);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldAllowMultipleInterfaces() {
-        //when
-        mockSettingsImpl.extraInterfaces(List.class, Set.class);
-
-        //then
-        assertEquals(2, mockSettingsImpl.getExtraInterfaces().size());
-        assertTrue(mockSettingsImpl.getExtraInterfaces().contains(List.class));
-        assertTrue(mockSettingsImpl.getExtraInterfaces().contains(Set.class));
-    }
-
-    @Test
-    public void shouldSetMockToBeSerializable() throws Exception {
-        //when
-        mockSettingsImpl.serializable();
-
-        //then
-        assertTrue(mockSettingsImpl.isSerializable());
-    }
-
-    @Test
-    public void shouldKnowIfIsSerializable() throws Exception {
-        //given
-        assertFalse(mockSettingsImpl.isSerializable());
-
-        //when
-        mockSettingsImpl.serializable();
-
-        //then
-        assertTrue(mockSettingsImpl.isSerializable());
-    }
-
-    @Test
-    public void shouldAddVerboseLoggingListener() {
-        //given
-        assertFalse(mockSettingsImpl.hasInvocationListeners());
-
-        //when
-        mockSettingsImpl.verboseLogging();
-
-        //then
-        assertThat(mockSettingsImpl.getInvocationListeners()).extracting("class").contains(VerboseMockInvocationLogger.class);
-    }
-
-    @Test
-    public void shouldAddVerboseLoggingListenerOnlyOnce() {
-        //given
-        assertFalse(mockSettingsImpl.hasInvocationListeners());
-
-        //when
-        mockSettingsImpl.verboseLogging().verboseLogging();
-
-        //then
-        Assertions.assertThat(mockSettingsImpl.getInvocationListeners()).hasSize(1);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldAddInvocationListener() {
-        //given
-        assertFalse(mockSettingsImpl.hasInvocationListeners());
-
-        //when
-        mockSettingsImpl.invocationListeners(invocationListener);
-
-        //then
-        Assertions.assertThat(mockSettingsImpl.getInvocationListeners()).contains(invocationListener);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void canAddDuplicateInvocationListeners_ItsNotOurBusinessThere() {
-        //given
-        assertFalse(mockSettingsImpl.hasInvocationListeners());
-
-        //when
-        mockSettingsImpl.invocationListeners(invocationListener, invocationListener).invocationListeners(invocationListener);
-
-        //then
-        Assertions.assertThat(mockSettingsImpl.getInvocationListeners()).containsSequence(invocationListener, invocationListener, invocationListener);
-    }
-
-    @Test
-    public void validates_listeners() {
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.addListeners(new Object[] {}, new LinkedList<Object>(), "myListeners");
-            }
-        }).hasMessageContaining("myListeners() requires at least one listener");
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.addListeners(null, new LinkedList<Object>(), "myListeners");
-            }
-        }).hasMessageContaining("myListeners() does not accept null vararg array");
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.addListeners(new Object[] {null}, new LinkedList<Object>(), "myListeners");
-            }
-        }).hasMessageContaining("myListeners() does not accept null listeners");
-    }
-
-
-    @Test
-    public void validates_stubbing_lookup_listeners() {
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.stubbingLookupListeners(new StubbingLookupListener[] {});
-            }
-        }).hasMessageContaining("stubbingLookupListeners() requires at least one listener");
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.stubbingLookupListeners(null);
-            }
-        }).hasMessageContaining("stubbingLookupListeners() does not accept null vararg array");
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.stubbingLookupListeners(new StubbingLookupListener[] {null});
-            }
-        }).hasMessageContaining("stubbingLookupListeners() does not accept null listeners");
-    }
-
-    @Test
-    public void validates_invocation_listeners() {
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.invocationListeners(new InvocationListener[] {});
-            }
-        }).hasMessageContaining("invocationListeners() requires at least one listener");
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.invocationListeners(null);
-            }
-        }).hasMessageContaining("invocationListeners() does not accept null vararg array");
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                mockSettingsImpl.invocationListeners(new InvocationListener[] {null});
-            }
-        }).hasMessageContaining("invocationListeners() does not accept null listeners");
-    }
-
-    @Test
-    public void addListeners_has_empty_listeners_by_default() {
-        assertTrue(mockSettingsImpl.getInvocationListeners().isEmpty());
-        assertTrue(mockSettingsImpl.getStubbingLookupListeners().isEmpty());
-    }
-
-    @Test
-    public void addListeners_shouldAddMockObjectListeners() {
-        //when
-        mockSettingsImpl.invocationListeners(invocationListener);
-        mockSettingsImpl.stubbingLookupListeners(stubbingLookupListener);
-
-        //then
-        assertThat(mockSettingsImpl.getInvocationListeners()).contains(invocationListener);
-        assertThat(mockSettingsImpl.getStubbingLookupListeners()).contains(stubbingLookupListener);
-    }
-
-    @Test
-    public void addListeners_canAddDuplicateMockObjectListeners_ItsNotOurBusinessThere() {
-        //when
-        mockSettingsImpl.stubbingLookupListeners(stubbingLookupListener)
-                        .stubbingLookupListeners(stubbingLookupListener)
-                        .invocationListeners(invocationListener)
-                        .invocationListeners(invocationListener);
-
-        //then
-        assertThat(mockSettingsImpl.getInvocationListeners())
-            .containsSequence(invocationListener, invocationListener);
-        assertThat(mockSettingsImpl.getStubbingLookupListeners())
-            .containsSequence(stubbingLookupListener, stubbingLookupListener);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
deleted file mode 100644
index a50a45b913..0000000000
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockitoutil.ClassLoaders.coverageTool;
-
-import java.io.Serializable;
-import java.util.List;
-
-import net.bytebuddy.ByteBuddy;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.internal.handler.MockHandlerImpl;
-import org.mockito.internal.stubbing.answers.CallsRealMethods;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationContainer;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.SerializableMode;
-import org.mockito.plugins.MockMaker;
-import org.mockito.stubbing.Answer;
-import org.mockitoutil.ClassLoaders;
-import org.mockitoutil.SimpleSerializationUtil;
-import org.objenesis.ObjenesisStd;
-
-public abstract class AbstractByteBuddyMockMakerTest<MM extends MockMaker> {
-
-    protected final MM mockMaker;
-
-    public AbstractByteBuddyMockMakerTest(MM mockMaker) {
-        this.mockMaker = mockMaker;
-    }
-
-    protected abstract Class<?> mockTypeOf(Class<?> type);
-
-    @Test
-    public void should_create_mock_from_interface() throws Exception {
-        SomeInterface proxy = mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
-
-        Class<?> superClass = proxy.getClass().getSuperclass();
-        assertThat(superClass).isEqualTo(Object.class);
-    }
-
-
-    @Test
-    public void should_create_mock_from_class() throws Exception {
-        ClassWithoutConstructor proxy = mockMaker.createMock(settingsFor(ClassWithoutConstructor.class), dummyHandler());
-
-        Class<?> superClass = mockTypeOf(proxy.getClass());
-        assertThat(superClass).isEqualTo(ClassWithoutConstructor.class);
-    }
-
-    @Test
-    public void should_create_mock_from_class_even_when_constructor_is_dodgy() throws Exception {
-        try {
-            new ClassWithDodgyConstructor();
-            fail();
-        } catch (Exception expected) {}
-
-        ClassWithDodgyConstructor mock = mockMaker.createMock(settingsFor(ClassWithDodgyConstructor.class), dummyHandler());
-        assertThat(mock).isNotNull();
-    }
-
-    @Test
-    public void should_mocks_have_different_interceptors() throws Exception {
-        SomeClass mockOne = mockMaker.createMock(settingsFor(SomeClass.class), dummyHandler());
-        SomeClass mockTwo = mockMaker.createMock(settingsFor(SomeClass.class), dummyHandler());
-
-        MockHandler handlerOne = mockMaker.getHandler(mockOne);
-        MockHandler handlerTwo = mockMaker.getHandler(mockTwo);
-
-
-        assertThat(handlerOne).isNotSameAs(handlerTwo);
-    }
-
-    @Test
-    public void should_use_ancillary_Types() {
-        SomeClass mock = mockMaker.createMock(settingsFor(SomeClass.class, SomeInterface.class), dummyHandler());
-
-        assertThat(mock).isInstanceOf(SomeInterface.class);
-    }
-
-    @Test
-    public void should_create_class_by_constructor() {
-        OtherClass mock = mockMaker.createMock(settingsWithConstructorFor(OtherClass.class), dummyHandler());
-        assertThat(mock).isNotNull();
-    }
-
-    @Test
-    public void should_allow_serialization() throws Exception {
-        SerializableClass proxy = mockMaker.createMock(serializableSettingsFor(SerializableClass.class, SerializableMode.BASIC), dummyHandler());
-
-        SerializableClass serialized = SimpleSerializationUtil.serializeAndBack(proxy);
-        assertThat(serialized).isNotNull();
-
-        MockHandler handlerOne = mockMaker.getHandler(proxy);
-        MockHandler handlerTwo = mockMaker.getHandler(serialized);
-
-        assertThat(handlerOne).isNotSameAs(handlerTwo);
-    }
-
-    @Test
-    public void should_create_mock_from_class_with_super_call_to_final_method() throws Exception {
-        MockCreationSettings<CallingSuperMethodClass> settings = settingsWithSuperCall(CallingSuperMethodClass.class);
-        SampleClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<CallingSuperMethodClass>(settings));
-        assertThat(proxy.foo()).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_reset_mock_and_set_new_handler() throws Throwable {
-        MockCreationSettings<SampleClass> settings = settingsWithSuperCall(SampleClass.class);
-        SampleClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<SampleClass>(settings));
-
-        MockHandler handler = new MockHandlerImpl<SampleClass>(settings);
-        mockMaker.resetMock(proxy, handler, settings);
-        assertThat(mockMaker.getHandler(proxy)).isSameAs(handler);
-    }
-
-    class SomeClass {}
-    interface SomeInterface {}
-    static class OtherClass {}
-    static class SerializableClass implements Serializable {}
-
-    private class ClassWithoutConstructor {}
-
-    private class ClassWithDodgyConstructor {
-        public ClassWithDodgyConstructor() {
-            throw new RuntimeException();
-        }
-    }
-
-    @Test
-    public void instantiate_fine_when_objenesis_on_the_classpath() throws Exception {
-        // given
-        ClassLoader classpath_with_objenesis = ClassLoaders.excludingClassLoader()
-                .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, ObjenesisStd.class)
-                .withCodeSourceUrlOf(coverageTool())
-                .build();
-
-        Class<?> mock_maker_class_loaded_fine_until = Class.forName(
-                "org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker",
-                true,
-                classpath_with_objenesis
-        );
-
-        // when
-        mock_maker_class_loaded_fine_until.newInstance();
-
-        // then everything went fine
-    }
-
-    private static <T> MockCreationSettings<T> settingsFor(Class<T> type, Class<?>... extraInterfaces) {
-        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
-        mockSettings.setTypeToMock(type);
-        if(extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
-        return mockSettings;
-    }
-
-    private static <T> MockCreationSettings<T> serializableSettingsFor(Class<T> type, SerializableMode serializableMode) {
-        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
-        mockSettings.serializable(serializableMode);
-        mockSettings.setTypeToMock(type);
-        return mockSettings;
-    }
-
-    private static <T> MockCreationSettings<T> settingsWithConstructorFor(Class<T> type) {
-        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
-        mockSettings.setTypeToMock(type);
-        return mockSettings;
-    }
-
-    private static <T> MockCreationSettings<T> settingsWithSuperCall(Class<T> type) {
-        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
-        mockSettings.setTypeToMock(type);
-        mockSettings.defaultAnswer(new CallsRealMethods());
-        return mockSettings;
-    }
-
-    protected static MockHandler dummyHandler() {
-        return new DummyMockHandler();
-    }
-
-    private static class DummyMockHandler implements MockHandler<Object> {
-        public Object handle(Invocation invocation) throws Throwable { return null; }
-        public MockCreationSettings<Object> getMockSettings() { return null; }
-        public InvocationContainer getInvocationContainer() { return null; }
-        public void setAnswersForStubbing(List<Answer<?>> list) { }
-    }
-
-    private static class SampleClass {
-        public String foo() {
-            return "foo";
-        }
-    }
-
-    private static class CallingSuperMethodClass extends SampleClass {
-        @Override
-        public String foo() {
-            return super.foo();
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
deleted file mode 100644
index 2620cca7f2..0000000000
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
+++ /dev/null
@@ -1,426 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static net.bytebuddy.ClassFileVersion.JAVA_V11;
-import static net.bytebuddy.ClassFileVersion.JAVA_V8;
-import static net.bytebuddy.matcher.ElementMatchers.named;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-import static org.junit.Assume.assumeTrue;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Observable;
-import java.util.Observer;
-import java.util.Set;
-import java.util.concurrent.Callable;
-import java.util.regex.Pattern;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.ClassFileVersion;
-import net.bytebuddy.description.modifier.Visibility;
-import net.bytebuddy.description.type.TypeDescription;
-import net.bytebuddy.implementation.FixedValue;
-import net.bytebuddy.implementation.StubMethod;
-import net.bytebuddy.utility.JavaConstant;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.handler.MockHandlerImpl;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.internal.util.collections.Sets;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.SerializableMode;
-import org.mockito.plugins.MockMaker;
-
-public class InlineByteBuddyMockMakerTest extends AbstractByteBuddyMockMakerTest<InlineByteBuddyMockMaker> {
-
-    public InlineByteBuddyMockMakerTest() {
-        super(new InlineByteBuddyMockMaker());
-    }
-
-    @Override
-    protected Class<?> mockTypeOf(Class<?> type) {
-        return type;
-    }
-
-    @Test
-    public void should_create_mock_from_final_class() throws Exception {
-        MockCreationSettings<FinalClass> settings = settingsFor(FinalClass.class);
-        FinalClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
-        assertThat(proxy.foo()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_create_mock_from_final_class_in_the_JDK() throws Exception {
-        MockCreationSettings<Pattern> settings = settingsFor(Pattern.class);
-        Pattern proxy = mockMaker.createMock(settings, new MockHandlerImpl<Pattern>(settings));
-        assertThat(proxy.pattern()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_create_mock_from_abstract_class_with_final_method() throws Exception {
-        MockCreationSettings<FinalMethodAbstractType> settings = settingsFor(FinalMethodAbstractType.class);
-        FinalMethodAbstractType proxy = mockMaker.createMock(settings, new MockHandlerImpl<FinalMethodAbstractType>(settings));
-        assertThat(proxy.foo()).isEqualTo("bar");
-        assertThat(proxy.bar()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_create_mock_from_final_class_with_interface_methods() throws Exception {
-        MockCreationSettings<FinalMethod> settings = settingsFor(FinalMethod.class, SampleInterface.class);
-        FinalMethod proxy = mockMaker.createMock(settings, new MockHandlerImpl<FinalMethod>(settings));
-        assertThat(proxy.foo()).isEqualTo("bar");
-        assertThat(((SampleInterface) proxy).bar()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_detect_non_overridden_generic_method_of_supertype() throws Exception {
-        MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
-        GenericSubClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
-        assertThat(proxy.value()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_create_mock_from_hashmap() throws Exception {
-        MockCreationSettings<HashMap> settings = settingsFor(HashMap.class);
-        HashMap proxy = mockMaker.createMock(settings, new MockHandlerImpl<HashMap>(settings));
-        assertThat(proxy.get(null)).isEqualTo("bar");
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void should_throw_exception_redefining_unmodifiable_class() {
-        MockCreationSettings settings = settingsFor(int.class);
-        try {
-            mockMaker.createMock(settings, new MockHandlerImpl(settings));
-            fail("Expected a MockitoException");
-        } catch (MockitoException e) {
-            e.printStackTrace();
-            assertThat(e).hasMessageContaining("Could not modify all classes");
-        }
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void should_throw_exception_redefining_array() {
-        int[] array = new int[5];
-        MockCreationSettings<? extends int[]> settings = settingsFor(array.getClass());
-        try {
-            mockMaker.createMock(settings, new MockHandlerImpl(settings));
-            fail("Expected a MockitoException");
-        } catch (MockitoException e) {
-            assertThat(e).hasMessageContaining("Arrays cannot be mocked");
-        }
-    }
-
-    @Test
-    public void should_create_mock_from_enum() throws Exception {
-        MockCreationSettings<EnumClass> settings = settingsFor(EnumClass.class);
-        EnumClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<EnumClass>(settings));
-        assertThat(proxy.foo()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_fail_at_creating_a_mock_of_a_final_class_with_explicit_serialization() throws Exception {
-        MockCreationSettings<FinalClass> settings = new CreationSettings<FinalClass>()
-                .setTypeToMock(FinalClass.class)
-                .setSerializableMode(SerializableMode.BASIC);
-
-        try {
-            mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
-            fail("Expected a MockitoException");
-        } catch (MockitoException e) {
-            assertThat(e)
-                    .hasMessageContaining("Unsupported settings")
-                    .hasMessageContaining("serialization")
-                    .hasMessageContaining("extra interfaces");
-        }
-    }
-
-    @Test
-    public void should_fail_at_creating_a_mock_of_a_final_class_with_extra_interfaces() throws Exception {
-        MockCreationSettings<FinalClass> settings = new CreationSettings<FinalClass>()
-                .setTypeToMock(FinalClass.class)
-                .setExtraInterfaces(Sets.<Class<?>>newSet(List.class));
-
-        try {
-            mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
-            fail("Expected a MockitoException");
-        } catch (MockitoException e) {
-            assertThat(e)
-                    .hasMessageContaining("Unsupported settings")
-                    .hasMessageContaining("serialization")
-                    .hasMessageContaining("extra interfaces");
-        }
-    }
-
-    @Test
-    public void should_mock_interface() {
-        MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
-        mockSettings.setTypeToMock(Set.class);
-        mockSettings.defaultAnswer(new Returns(10));
-        Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
-
-        assertThat(proxy.size()).isEqualTo(10);
-    }
-
-    @Test
-    public void should_mock_interface_to_string() {
-        MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
-        mockSettings.setTypeToMock(Set.class);
-        mockSettings.defaultAnswer(new Returns("foo"));
-        Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
-
-        assertThat(proxy.toString()).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_remove_recursive_self_call_from_stack_trace() throws Exception {
-        StackTraceElement[] stack = new StackTraceElement[]{
-                new StackTraceElement("foo", "", "", -1),
-                new StackTraceElement(SampleInterface.class.getName(), "", "", -1),
-                new StackTraceElement("qux", "", "", -1),
-                new StackTraceElement("bar", "", "", -1),
-                new StackTraceElement("baz", "", "", -1)
-        };
-
-        Throwable throwable = new Throwable();
-        throwable.setStackTrace(stack);
-        throwable = MockMethodAdvice.hideRecursiveCall(throwable, 2, SampleInterface.class);
-
-        assertThat(throwable.getStackTrace()).isEqualTo(new StackTraceElement[]{
-                new StackTraceElement("foo", "", "", -1),
-                new StackTraceElement("bar", "", "", -1),
-                new StackTraceElement("baz", "", "", -1)
-        });
-    }
-
-    @Test
-    public void should_handle_missing_or_inconsistent_stack_trace() throws Exception {
-        Throwable throwable = new Throwable();
-        throwable.setStackTrace(new StackTraceElement[0]);
-        assertThat(MockMethodAdvice.hideRecursiveCall(throwable, 0, SampleInterface.class)).isSameAs(throwable);
-    }
-
-    @Test
-    public void should_provide_reason_for_wrapper_class() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Integer.class);
-        assertThat(mockable.nonMockableReason()).isEqualTo("Cannot mock wrapper types, String.class or Class.class");
-    }
-
-    @Test
-    public void should_provide_reason_for_vm_unsupported() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int[].class);
-        assertThat(mockable.nonMockableReason()).isEqualTo("VM does not support modification of given type");
-    }
-
-    @Test
-    public void should_mock_method_of_package_private_class() throws Exception {
-        MockCreationSettings<NonPackagePrivateSubClass> settings = settingsFor(NonPackagePrivateSubClass.class);
-        NonPackagePrivateSubClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<NonPackagePrivateSubClass>(settings));
-        assertThat(proxy.value()).isEqualTo("bar");
-    }
-
-    @Test
-    public void is_type_mockable_excludes_String() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(String.class);
-        assertThat(mockable.mockable()).isFalse();
-        assertThat(mockable.nonMockableReason()).contains("Cannot mock wrapper types, String.class or Class.class");
-    }
-
-    @Test
-    public void is_type_mockable_excludes_Class() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Class.class);
-        assertThat(mockable.mockable()).isFalse();
-        assertThat(mockable.nonMockableReason()).contains("Cannot mock wrapper types, String.class or Class.class");
-    }
-
-    @Test
-    public void is_type_mockable_excludes_primitive_classes() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
-        assertThat(mockable.mockable()).isFalse();
-        assertThat(mockable.nonMockableReason()).contains("primitive");
-    }
-
-    @Test
-    public void is_type_mockable_allows_anonymous() {
-        Observer anonymous = new Observer() {
-            @Override
-            public void update(Observable o, Object arg) {
-            }
-        };
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
-        assertThat(mockable.mockable()).isTrue();
-        assertThat(mockable.nonMockableReason()).contains("");
-    }
-
-    @Test
-    public void is_type_mockable_give_empty_reason_if_type_is_mockable() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(SomeClass.class);
-        assertThat(mockable.mockable()).isTrue();
-        assertThat(mockable.nonMockableReason()).isEqualTo("");
-    }
-
-    @Test
-    public void is_type_mockable_give_allow_final_mockable_from_JDK() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Pattern.class);
-        assertThat(mockable.mockable()).isTrue();
-        assertThat(mockable.nonMockableReason()).isEqualTo("");
-    }
-
-    @Test
-    public void test_parameters_retention() throws Exception {
-        assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(JAVA_V8));
-
-        Class<?> typeWithParameters = new ByteBuddy()
-                .subclass(Object.class)
-                .defineMethod("foo", void.class, Visibility.PUBLIC)
-                .withParameter(String.class, "bar")
-                .intercept(StubMethod.INSTANCE)
-                .make()
-                .load(null)
-                .getLoaded();
-
-        MockCreationSettings<?> settings = settingsFor(typeWithParameters);
-        @SuppressWarnings("unchecked")
-        Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
-
-        assertThat(proxy.getClass()).isEqualTo(typeWithParameters);
-        assertThat(new TypeDescription.ForLoadedType(typeWithParameters).getDeclaredMethods().filter(named("foo"))
-                .getOnly().getParameters().getOnly().getName()).isEqualTo("bar");
-    }
-
-    @Test
-    public void test_constant_dynamic_compatibility() throws Exception {
-        assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(JAVA_V11));
-
-        Class<?> typeWithCondy = new ByteBuddy()
-                .subclass(Callable.class)
-                .method(named("call"))
-                .intercept(FixedValue.value(JavaConstant.Dynamic.ofNullConstant()))
-                .make()
-                .load(null)
-                .getLoaded();
-
-        MockCreationSettings<?> settings = settingsFor(typeWithCondy);
-        @SuppressWarnings("unchecked")
-        Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
-
-        assertThat(proxy.getClass()).isEqualTo(typeWithCondy);
-    }
-
-    @Test
-    public void test_clear_mock_clears_handler() {
-        MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
-        GenericSubClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
-        assertThat(mockMaker.getHandler(proxy)).isNotNull();
-
-        //when
-        mockMaker.clearMock(proxy);
-
-        //then
-        assertThat(mockMaker.getHandler(proxy)).isNull();
-    }
-
-    @Test
-    public void test_clear_all_mock_clears_handler() {
-        MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
-        GenericSubClass proxy1 = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
-        assertThat(mockMaker.getHandler(proxy1)).isNotNull();
-
-        settings = settingsFor(GenericSubClass.class);
-        GenericSubClass proxy2 = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
-        assertThat(mockMaker.getHandler(proxy1)).isNotNull();
-
-        //when
-        mockMaker.clearAllMocks();
-
-        //then
-        assertThat(mockMaker.getHandler(proxy1)).isNull();
-        assertThat(mockMaker.getHandler(proxy2)).isNull();
-    }
-
-    private static <T> MockCreationSettings<T> settingsFor(Class<T> type, Class<?>... extraInterfaces) {
-        MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
-        mockSettings.setTypeToMock(type);
-        mockSettings.defaultAnswer(new Returns("bar"));
-        if (extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
-        return mockSettings;
-    }
-
-    @Test
-    public void testMockDispatcherIsRelocated() throws Exception {
-        assertThat(InlineByteBuddyMockMaker.class.getClassLoader()
-            .getResource("org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.raw"))
-            .isNotNull();
-    }
-
-    private static final class FinalClass {
-
-        public String foo() {
-            return "foo";
-        }
-    }
-
-    private enum EnumClass {
-
-        INSTANCE;
-
-        public String foo() {
-            return "foo";
-        }
-    }
-
-    private abstract static class FinalMethodAbstractType {
-
-        public final String foo() {
-            return "foo";
-        }
-
-        public abstract String bar();
-    }
-
-    private static class FinalMethod {
-
-        public final String foo() {
-            return "foo";
-        }
-    }
-
-    private interface SampleInterface {
-
-        String bar();
-    }
-
-    /*package-private*/ abstract class PackagePrivateSuperClass {
-
-        public abstract String indirect();
-
-        public String value() {
-            return indirect() + "qux";
-        }
-    }
-
-    public class NonPackagePrivateSubClass extends PackagePrivateSuperClass {
-
-        @Override
-        public String indirect() {
-            return "foo";
-        }
-    }
-
-    public static class GenericClass<T> {
-
-        public T value() {
-            return null;
-        }
-    }
-
-    public static class GenericSubClass extends GenericClass<String> {
-    }
-}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
deleted file mode 100644
index 819e62c2c5..0000000000
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.Observable;
-import java.util.Observer;
-
-import org.junit.Test;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.plugins.MockMaker;
-
-public class SubclassByteBuddyMockMakerTest extends AbstractByteBuddyMockMakerTest<SubclassByteBuddyMockMaker> {
-
-    public SubclassByteBuddyMockMakerTest() {
-        super(new SubclassByteBuddyMockMaker());
-    }
-
-    @Test
-    public void is_type_mockable_excludes_primitive_wrapper_classes() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Integer.class);
-        assertThat(mockable.mockable()).isFalse();
-        assertThat(mockable.nonMockableReason()).contains("final");
-    }
-
-    @Test
-    public void is_type_mockable_excludes_primitive_classes() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
-        assertThat(mockable.mockable()).isFalse();
-        assertThat(mockable.nonMockableReason()).contains("primitive");
-    }
-
-    @Test
-    public void is_type_mockable_allow_anonymous() {
-        Observer anonymous = new Observer() {
-            @Override public void update(Observable o, Object arg) { }
-        };
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
-        assertThat(mockable.mockable()).isTrue();
-        assertThat(mockable.nonMockableReason()).contains("");
-    }
-
-    @Test
-    public void is_type_mockable_give_empty_reason_if_type_is_mockable() {
-        MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(SomeClass.class);
-        assertThat(mockable.mockable()).isTrue();
-        assertThat(mockable.nonMockableReason()).isEqualTo("");
-    }
-
-    @Test
-    public void mock_type_with_annotations() throws Exception {
-        MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<ClassWithAnnotation>();
-        mockSettings.setTypeToMock(ClassWithAnnotation.class);
-
-        ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
-
-        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isTrue();
-        assertThat(proxy.getClass().getAnnotation(SampleAnnotation.class).value()).isEqualTo("foo");
-
-        assertThat(proxy.getClass().getMethod("sampleMethod").isAnnotationPresent(SampleAnnotation.class)).isTrue();
-        assertThat(proxy.getClass().getMethod("sampleMethod").getAnnotation(SampleAnnotation.class).value()).isEqualTo("bar");
-    }
-
-    @Test
-    public void mock_type_without_annotations() throws Exception {
-        MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<ClassWithAnnotation>();
-        mockSettings.setTypeToMock(ClassWithAnnotation.class);
-        mockSettings.withoutAnnotations();
-
-        ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
-
-        assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isFalse();
-        assertThat(proxy.getClass().getMethod("sampleMethod").isAnnotationPresent(SampleAnnotation.class)).isFalse();
-    }
-
-    @Override
-    protected Class<?> mockTypeOf(Class<?> type) {
-        return type.getSuperclass();
-    }
-
-    @Retention(RetentionPolicy.RUNTIME)
-    public @interface SampleAnnotation {
-
-        String value();
-    }
-
-    @SampleAnnotation("foo")
-    public static class ClassWithAnnotation {
-
-        @SampleAnnotation("bar")
-        public void sampleMethod() {
-            throw new UnsupportedOperationException();
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
deleted file mode 100644
index a75062ae0a..0000000000
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.creation.bytebuddy.MockFeatures.withMockFeatures;
-import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
-import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
-
-import java.lang.ref.PhantomReference;
-import java.lang.ref.Reference;
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.WeakReference;
-import java.util.Collections;
-import java.util.WeakHashMap;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.mock.SerializableMode;
-import org.mockitoutil.VmArgAssumptions;
-
-public class TypeCachingMockBytecodeGeneratorTest {
-
-    @Before
-    public void ensure_disable_gc_is_activated() throws Exception {
-        VmArgAssumptions.assumeVmArgNotPresent("-XX:+DisableExplicitGC");
-    }
-
-    @Test
-    public void ensure_cache_is_cleared_if_no_reference_to_classloader_and_classes() throws Exception {
-        // given
-        ClassLoader classloader_with_life_shorter_than_cache = inMemoryClassLoader()
-                .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
-                .build();
-
-        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
-
-        Class<?> the_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
-                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
-                Collections.<Class<?>>emptySet(),
-                SerializableMode.NONE,
-                false
-        ));
-
-        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
-        Reference<Object> typeReference = new PhantomReference<Object>(the_mock_type, referenceQueue);
-
-        // when
-        classloader_with_life_shorter_than_cache = is_no_more_referenced();
-        the_mock_type = is_no_more_referenced();
-
-        System.gc();
-        ensure_gc_happened();
-
-        // then
-        assertThat(referenceQueue.poll()).isEqualTo(typeReference);
-    }
-
-    @Test
-    public void ensure_cache_returns_same_instance() throws Exception {
-        // given
-        ClassLoader classloader_with_life_shorter_than_cache = inMemoryClassLoader()
-                .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
-                .build();
-
-        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
-        Class<?> the_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
-                        classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
-                        Collections.<Class<?>>emptySet(),
-                        SerializableMode.NONE,
-                        false
-                ));
-
-        Class<?> other_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
-                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
-                Collections.<Class<?>>emptySet(),
-                SerializableMode.NONE,
-                false
-        ));
-
-        assertThat(other_mock_type).isSameAs(the_mock_type);
-
-        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
-        Reference<Object> typeReference = new PhantomReference<Object>(the_mock_type, referenceQueue);
-
-        // when
-        classloader_with_life_shorter_than_cache = is_no_more_referenced();
-        the_mock_type = is_no_more_referenced();
-        other_mock_type = is_no_more_referenced();
-
-        System.gc();
-        ensure_gc_happened();
-
-        // then
-        assertThat(referenceQueue.poll()).isEqualTo(typeReference);
-    }
-
-    @Test
-    public void ensure_cache_returns_different_instance_serializableMode() throws Exception {
-        // given
-        ClassLoader classloader_with_life_shorter_than_cache = inMemoryClassLoader()
-                .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
-                .build();
-
-        TypeCachingBytecodeGenerator cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
-        Class<?> the_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
-                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
-                Collections.<Class<?>>emptySet(),
-                SerializableMode.NONE,
-                false
-        ));
-
-        Class<?> other_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
-                classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
-                Collections.<Class<?>>emptySet(),
-                SerializableMode.BASIC,
-                false
-        ));
-
-        assertThat(other_mock_type).isNotSameAs(the_mock_type);
-    }
-
-    @Test
-    public void validate_simple_code_idea_where_weakhashmap_with_classloader_as_key_get_GCed_when_no_more_references() throws Exception {
-        // given
-        WeakHashMap<ClassLoader, Object> cache = new WeakHashMap<ClassLoader, Object>();
-        ClassLoader short_lived_classloader = inMemoryClassLoader()
-                .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
-                .build();
-
-        cache.put(short_lived_classloader, new HoldingAReference(new WeakReference<Class<?>>(short_lived_classloader.loadClass("foo.Bar"))));
-
-        assertThat(cache).hasSize(1);
-
-        // when
-        short_lived_classloader = is_no_more_referenced();
-
-        System.gc();
-        ensure_gc_happened();
-
-        // then
-        assertThat(cache).isEmpty();
-    }
-
-    static class HoldingAReference {
-        final WeakReference<Class<?>> a;
-
-        HoldingAReference(WeakReference<Class<?>> a) {
-            this.a = a;
-        }
-    }
-
-
-    private static <T> T is_no_more_referenced() {
-        return null;
-    }
-
-    private static void ensure_gc_happened() throws InterruptedException {
-        // wait in order to make sure the GC happened
-        Thread.sleep(500);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java b/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
deleted file mode 100644
index 07deae8aa6..0000000000
--- a/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.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.mockito.internal.creation.instance;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-public class ConstructorInstantiatorTest extends TestBase {
-
-    static class SomeClass {
-
-    }
-
-    class SomeInnerClass {
-
-    }
-
-    class ChildOfThis extends ConstructorInstantiatorTest {
-
-    }
-
-    static class SomeClass2 {
-
-        SomeClass2(String x) {
-        }
-    }
-
-    static class SomeClass3 {
-
-        SomeClass3(int i) {
-
-        }
-    }
-
-    @Test
-    public void creates_instances() {
-        assertEquals(new ConstructorInstantiator(false, new Object[0]).newInstance(SomeClass.class).getClass(), SomeClass.class);
-    }
-
-    @Test
-    public void creates_instances_of_inner_classes() {
-        assertEquals(new ConstructorInstantiator(true, this).newInstance(SomeInnerClass.class).getClass(), SomeInnerClass.class);
-        assertEquals(new ConstructorInstantiator(true, new ChildOfThis()).newInstance(SomeInnerClass.class).getClass(), SomeInnerClass.class);
-    }
-
-    @Test
-    public void creates_instances_with_arguments() {
-        assertEquals(new ConstructorInstantiator(false, "someString").newInstance(SomeClass2.class).getClass(), SomeClass2.class);
-    }
-
-    @Test
-    public void creates_instances_with_null_arguments() {
-        assertEquals(new ConstructorInstantiator(false, new Object[]{null}).newInstance(SomeClass2.class).getClass(), SomeClass2.class);
-    }
-
-    @Test
-    public void creates_instances_with_primitive_arguments() {
-        assertEquals(new ConstructorInstantiator(false, 123).newInstance(SomeClass3.class).getClass(), SomeClass3.class);
-    }
-
-    @Test(expected = org.mockito.creation.instance.InstantiationException.class)
-    public void fails_when_null_is_passed_for_a_primitive() {
-        assertEquals(new ConstructorInstantiator(false, new Object[]{null}).newInstance(SomeClass3.class).getClass(), SomeClass3.class);
-    }
-
-    @Test
-    public void explains_when_constructor_cannot_be_found() {
-        try {
-            new ConstructorInstantiator(false, new Object[0]).newInstance(SomeClass2.class);
-            fail();
-        } catch (org.mockito.creation.instance.InstantiationException e) {
-            assertThat(e).hasMessageContaining("Unable to create instance of 'SomeClass2'.\n" +
-                    "Please ensure that the target class has a 0-arg constructor.");
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java b/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
deleted file mode 100644
index b7eda71294..0000000000
--- a/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockitoutil.TestBase;
-
-public class LoggingListenerTest extends TestBase {
-
-    @Test
-    public void may_not_have_any_information() {
-        //given
-        LoggingListener listener = new LoggingListener(true);
-
-        //expect
-        assertEquals("", listener.getStubbingInfo());
-    }
-
-    @Test
-    public void informs_about_unused_stubs() {
-        //given
-        LoggingListener listener = new LoggingListener(false);
-
-        //when
-        listener.foundUnusedStub(invocationAt("at com.FooTest:30"));
-        listener.foundUnusedStub(invocationAt("at com.FooTest:32"));
-
-        //then
-        assertEquals(
-            "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
-            "[Mockito]\n" +
-            "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n" +
-            "[Mockito]\n" +
-            "[Mockito] 1. at com.FooTest:30\n" +
-            "[Mockito] 2. at com.FooTest:32", listener.getStubbingInfo());
-    }
-
-    @Test
-    public void calculates_indexes_for_clean_output() {
-        assertEquals(1, LoggingListener.indexOfNextPair(0));
-        assertEquals(2, LoggingListener.indexOfNextPair(2));
-        assertEquals(3, LoggingListener.indexOfNextPair(4));
-        assertEquals(4, LoggingListener.indexOfNextPair(6));
-    }
-
-    @Test
-    public void informs_about_unused_stubs_due_arg_mismatch() {
-        //given
-        LoggingListener listener = new LoggingListener(false);
-
-        //when
-        listener.foundStubCalledWithDifferentArgs(invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
-        listener.foundStubCalledWithDifferentArgs(invocationAt("at com.FooTest:21"), invocationMatcherAt("at com.Foo:121"));
-
-        //then
-        assertEquals(
-            "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
-            "[Mockito]\n" +
-            "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n" +
-            "[Mockito]\n" +
-            "[Mockito] 1. Stubbed at com.FooTest:20\n" +
-            "[Mockito]    Invoked at com.Foo:100\n" +
-            "[Mockito] 2. Stubbed at com.FooTest:21\n" +
-            "[Mockito]    Invoked at com.Foo:121", listener.getStubbingInfo());
-    }
-
-    @Test
-    public void informs_about_various_kinds_of_stubs() {
-        //given
-        LoggingListener listener = new LoggingListener(true);
-
-        //when
-        listener.foundUnusedStub(invocationAt("at com.FooTest:30"));
-        listener.foundStubCalledWithDifferentArgs(invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
-        listener.foundUnstubbed(invocationMatcherAt("at com.Foo:96"));
-
-        //then
-        assertEquals(
-            "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
-            "[Mockito]\n" +
-            "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n" +
-            "[Mockito]\n" +
-            "[Mockito] 1. Stubbed at com.FooTest:20\n" +
-            "[Mockito]    Invoked at com.Foo:100\n" +
-            "[Mockito]\n" +
-            "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n" +
-            "[Mockito]\n" +
-            "[Mockito] 1. at com.FooTest:30\n" +
-            "[Mockito]\n" +
-            "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):\n" +
-            "[Mockito]\n" +
-            "[Mockito] 1. at com.Foo:96", listener.getStubbingInfo());
-    }
-
-    @Test
-    public void hides_unstubbed() {
-        //given
-        LoggingListener listener = new LoggingListener(false);
-
-        //when
-        listener.foundUnstubbed(new InvocationBuilder().toInvocationMatcher());
-
-        //then
-        assertEquals("", listener.getStubbingInfo());
-    }
-
-    @Test
-    public void informs_about_unstubbed() {
-        //given
-        LoggingListener listener = new LoggingListener(true);
-
-        //when
-        listener.foundUnstubbed(invocationMatcherAt("com.Foo:20"));
-
-        //then
-        assertEquals(
-                "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
-                "[Mockito]\n" +
-                "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):\n" +
-                "[Mockito]\n" +
-                "[Mockito] 1. com.Foo:20", listener.getStubbingInfo());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java b/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
deleted file mode 100644
index 97d7242dd3..0000000000
--- a/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.debugging;
-
-import static java.util.Arrays.asList;
-
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-
-import java.util.Arrays;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class WarningsFinderTest extends TestBase {
-
-    @Mock private IMethods mock;
-    @Mock private FindingsListener listener;
-
-    @Test
-    public void shouldPrintUnusedStub() {
-        // given
-        Invocation unusedStub = new InvocationBuilder().simpleMethod().toInvocation();
-
-        // when
-        WarningsFinder finder = new WarningsFinder(asList(unusedStub), Arrays.<InvocationMatcher>asList());
-        finder.find(listener);
-
-        // then
-        verify(listener, only()).foundUnusedStub(unusedStub);
-    }
-
-    @Test
-    public void shouldPrintUnstubbedInvocation() {
-        // given
-        InvocationMatcher unstubbedInvocation = new InvocationBuilder().differentMethod().toInvocationMatcher();
-
-        // when
-        WarningsFinder finder = new WarningsFinder(Arrays.<Invocation>asList(), Arrays.<InvocationMatcher>asList(unstubbedInvocation));
-        finder.find(listener);
-
-        // then
-        verify(listener, only()).foundUnstubbed(unstubbedInvocation);
-    }
-
-    @Test
-    public void shouldPrintStubWasUsedWithDifferentArgs() {
-        // given
-        Invocation stub = new InvocationBuilder().arg("foo").mock(mock).toInvocation();
-        InvocationMatcher wrongArg = new InvocationBuilder().arg("bar").mock(mock).toInvocationMatcher();
-
-        // when
-        WarningsFinder finder = new WarningsFinder(Arrays.<Invocation> asList(stub), Arrays.<InvocationMatcher> asList(wrongArg));
-        finder.find(listener);
-
-        // then
-        verify(listener, only()).foundStubCalledWithDifferentArgs(stub, wrongArg);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/exceptions/ReporterTest.java b/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
deleted file mode 100644
index 1519bdc347..0000000000
--- a/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.exceptions;
-
-import static org.mockito.Mockito.mock;
-
-import java.lang.reflect.Field;
-import java.util.Collections;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.TooFewActualInvocations;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class ReporterTest extends TestBase {
-
-    @Test(expected = TooFewActualInvocations.class)
-    public void should_let_passing_null_last_actual_stack_trace() throws Exception {
-        throw Reporter.tooFewActualInvocations(new org.mockito.internal.reporting.Discrepancy(1, 2), new InvocationBuilder().toInvocation(), null);
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_throw_correct_exception_for_null_invocation_listener() throws Exception {
-        throw Reporter.methodDoesNotAcceptParameter("invocationListeners", "null vararg array");
-    }
-
-    @Test(expected = NoInteractionsWanted.class)
-    public void can_use_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted() throws Exception {
-        Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
-        throw Reporter.noMoreInteractionsWanted(invocation_with_bogus_default_answer, Collections.<VerificationAwareInvocation>emptyList());
-    }
-
-    @Test(expected = VerificationInOrderFailure.class)
-    public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted_in_order() throws Exception {
-        Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
-        throw Reporter.noMoreInteractionsWantedInOrder(invocation_with_bogus_default_answer);
-    }
-
-    @Test(expected = MockitoException.class)
-    public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_invalid_argument_position() throws Exception {
-        Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
-        throw Reporter.invalidArgumentPositionRangeAtInvocationTime(invocation_with_bogus_default_answer, true, 0);
-    }
-
-    @Test(expected = MockitoException.class)
-    public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_wrong_argument_to_return() throws Exception {
-        Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
-        throw Reporter.wrongTypeOfArgumentToReturn(invocation_with_bogus_default_answer, "", String.class, 0);
-    }
-
-    @Test(expected = MockitoException.class)
-    public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_dont_exists() throws Exception {
-        Invocation dumb_invocation = new InvocationBuilder().toInvocation();
-        IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
-        throw Reporter.delegatedMethodDoesNotExistOnDelegate(dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class);
-    }
-
-    @Test(expected = MockitoException.class)
-    public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_has_wrong_return_type() throws Exception {
-        Invocation dumb_invocation = new InvocationBuilder().toInvocation();
-        IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
-        throw Reporter.delegatedMethodHasWrongReturnType(dumb_invocation.getMethod(), dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class);
-    }
-
-    @Test(expected = MockitoException.class)
-    public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_injection_failure() throws Exception {
-        IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
-        throw Reporter.cannotInjectDependency(someField(), mock_with_bogus_default_answer, new Exception());
-    }
-
-    private Field someField() {
-        return Mockito.class.getDeclaredFields()[0];
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
deleted file mode 100644
index 26872fb01d..0000000000
--- a/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.exceptions.stacktrace;
-
-import static org.mockitoutil.Conditions.onlyThoseClassesInStackTrace;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.base.TraceBuilder;
-import org.mockito.internal.configuration.ConfigurationAccess;
-import org.mockitoutil.TestBase;
-
-public class ConditionalStackTraceFilterTest extends TestBase {
-
-    private ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
-
-    @Test
-    public void shouldNotFilterWhenConfigurationSaysNo() {
-        ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
-
-        Throwable t = new TraceBuilder().classes(
-                "org.test.MockitoSampleTest",
-                "org.mockito.Mockito"
-        ).toThrowable();
-
-        filter.filter(t);
-
-        Assertions.assertThat(t).has(onlyThoseClassesInStackTrace("org.mockito.Mockito", "org.test.MockitoSampleTest"));
-    }
-
-    @Test
-    public void shouldFilterWhenConfigurationSaysYes() {
-        ConfigurationAccess.getConfig().overrideCleansStackTrace(true);
-
-        Throwable t = new TraceBuilder().classes(
-                "org.test.MockitoSampleTest",
-                "org.mockito.Mockito"
-        ).toThrowable();
-
-        filter.filter(t);
-
-        Assertions.assertThat(t).has(onlyThoseClassesInStackTrace("org.test.MockitoSampleTest"));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
deleted file mode 100644
index 78e026795b..0000000000
--- a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.exceptions.stacktrace;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockitoutil.Conditions.onlyThoseClasses;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.base.TraceBuilder;
-import org.mockitoutil.TestBase;
-
-public class StackTraceFilterTest extends TestBase {
-
-    private final StackTraceFilter filter = new StackTraceFilter();
-
-    @Test
-    public void shouldFilterOutCglibGarbage() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-            "MockitoExampleTest",
-            "List$$EnhancerByMockitoWithCGLIB$$2c406024"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest"));
-    }
-
-    @Test
-    public void shouldFilterOutByteBuddyGarbage() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "MockitoExampleTest",
-                "org.testcase.MockedClass$MockitoMock$1882975947.doSomething(Unknown Source)"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest"));
-    }
-
-
-    @Test
-    public void shouldFilterOutMockitoPackage() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-            "org.test.MockitoSampleTest",
-            "org.mockito.Mockito"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest"));
-    }
-
-    @Test
-    public void shouldNotFilterOutTracesMiddleGoodTraces() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "org.test.MockitoSampleTest",
-                "org.test.TestSupport",
-                "org.mockito.Mockito",
-                "org.test.TestSupport",
-                "org.mockito.Mockito"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.TestSupport", "org.test.TestSupport", "org.test.MockitoSampleTest"));
-    }
-
-    @Test
-    public void shouldKeepRunners() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "org.mockito.runners.Runner",
-                "junit.stuff",
-                "org.test.MockitoSampleTest",
-                "org.mockito.Mockito"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner"));
-    }
-
-    @Test
-    public void shouldNotFilterElementsAboveMockitoJUnitRule() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)",
-                "org.mockito.runners.Runner",
-                "junit.stuff",
-                "org.test.MockitoSampleTest",
-                "org.mockito.internal.MockitoCore.verifyNoMoreInteractions",
-                "org.mockito.internal.debugging.LocationImpl"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner","org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)"));
-    }
-
-    @Test
-    public void shouldKeepInternalRunners() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "org.mockito.internal.runners.Runner",
-                "org.test.MockitoSampleTest"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, false);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "org.mockito.internal.runners.Runner"));
-    }
-
-    @Test
-    public void shouldStartFilteringAndKeepTop() {
-        //given
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "org.test.Good",
-                "org.mockito.internal.Bad",
-                "org.test.MockitoSampleTest"
-        ).toTraceArray();
-
-        //when
-        StackTraceElement[] filtered = filter.filter(t, true);
-
-        //then
-        Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "org.test.Good"));
-    }
-
-    @Test
-    public void shouldKeepGoodTraceFromTheTopBecauseRealImplementationsOfSpiesSometimesThrowExceptions() {
-        StackTraceElement[] t = new TraceBuilder().classes(
-                "org.good.Trace",
-                "org.yet.another.good.Trace",
-                "org.mockito.internal.to.be.Filtered",
-                "org.test.MockitoSampleTest"
-        ).toTraceArray();
-
-        StackTraceElement[] filtered = filter.filter(t, true);
-
-        Assertions.assertThat(filtered).has(onlyThoseClasses(
-                "org.test.MockitoSampleTest",
-                "org.yet.another.good.Trace",
-                "org.good.Trace"
-                ));
-    }
-
-    @Test
-    public void shouldReturnEmptyArrayWhenInputIsEmpty() throws Exception {
-        //when
-        StackTraceElement[] filtered = filter.filter(new StackTraceElement[0], false);
-        //then
-        assertEquals(0, filtered.length);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
deleted file mode 100644
index a17ec7f713..0000000000
--- a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.framework;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.withSettings;
-import static org.mockitoutil.ThrowableAssert.assertThat;
-
-import java.util.List;
-import java.util.Set;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.ArgumentMatchers;
-import org.mockito.MockSettings;
-import org.mockito.StateMaster;
-import org.mockito.exceptions.misusing.RedundantListenerException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.listeners.MockCreationListener;
-import org.mockito.listeners.MockitoListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InlineMockMaker;
-import org.mockitoutil.TestBase;
-
-public class DefaultMockitoFrameworkTest extends TestBase {
-
-    private DefaultMockitoFramework framework = new DefaultMockitoFramework();
-
-    @After public void clearListeners() {
-        new StateMaster().clearMockitoListeners();
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void prevents_adding_null_listener() {
-        framework.addListener(null);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void prevents_removing_null_listener() {
-        framework.removeListener(null);
-    }
-
-    @Test
-    public void ok_to_remove_unknown_listener() {
-        //it is safe to remove listener that was not added before
-        framework.removeListener(new MockitoListener() {});
-    }
-
-    @Test
-    public void ok_to_remove_listener_multiple_times() {
-        MockitoListener listener = new MockitoListener() {};
-
-        //when
-        framework.addListener(listener);
-
-        //then it is ok to:
-        framework.removeListener(listener);
-        framework.removeListener(listener);
-    }
-
-    @Test
-    public void adds_creation_listener() {
-        //given creation listener is added
-        MockCreationListener listener = mock(MockCreationListener.class);
-        framework.addListener(listener);
-
-        //when
-        MockSettings settings = withSettings().name("my list");
-        List mock = mock(List.class, settings);
-        Set mock2 = mock(Set.class);
-
-        //then
-        verify(listener).onMockCreated(eq(mock), any(MockCreationSettings.class));
-        verify(listener).onMockCreated(eq(mock2), any(MockCreationSettings.class));
-        verifyNoMoreInteractions(listener);
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test
-    public void removes_creation_listener() {
-        //given creation listener is added
-        MockCreationListener listener = mock(MockCreationListener.class);
-        framework.addListener(listener);
-
-        //and hooked up correctly
-        mock(List.class);
-        verify(listener).onMockCreated(ArgumentMatchers.any(), any(MockCreationSettings.class));
-
-        //when
-        framework.removeListener(listener);
-        mock(Set.class);
-
-        //then
-        verifyNoMoreInteractions(listener);
-    }
-
-    @Test public void prevents_duplicate_listeners_of_the_same_type() {
-        //given creation listener is added
-        framework.addListener(new MyListener());
-
-        assertThat(new Runnable() {
-            @Override
-            public void run() {
-                framework.addListener(new MyListener());
-            }
-        })  .throwsException(RedundantListenerException.class)
-            .throwsMessage("\n" +
-                    "Problems adding Mockito listener.\n" +
-                    "Listener of type 'MyListener' has already been added and not removed.\n" +
-                    "It indicates that previous listener was not removed according to the API.\n" +
-                    "When you add a listener, don't forget to remove the listener afterwards:\n" +
-                    "  Mockito.framework().removeListener(myListener);\n" +
-                    "For more information, see the javadoc for RedundantListenerException class.");
-    }
-
-    @Test
-    public void clearing_all_mocks_is_safe_regardless_of_mock_maker_type() {
-        List mock = mock(List.class);
-
-        //expect
-        assertTrue(mockingDetails(mock).isMock());
-        framework.clearInlineMocks();
-    }
-
-    @Test
-    public void clears_all_mocks() {
-        //clearing mocks only works with inline mocking
-        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
-
-        //given
-        List list1 = mock(List.class);
-        assertTrue(mockingDetails(list1).isMock());
-        List list2 = mock(List.class);
-        assertTrue(mockingDetails(list2).isMock());
-
-        //when
-        framework.clearInlineMocks();
-
-        //then
-        assertFalse(mockingDetails(list1).isMock());
-        assertFalse(mockingDetails(list2).isMock());
-    }
-
-    @Test
-    public void clears_mock() {
-        //clearing mocks only works with inline mocking
-        assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
-
-        //given
-        List list1 = mock(List.class);
-        assertTrue(mockingDetails(list1).isMock());
-        List list2 = mock(List.class);
-        assertTrue(mockingDetails(list2).isMock());
-
-        //when
-        framework.clearInlineMock(list1);
-
-        //then
-        assertFalse(mockingDetails(list1).isMock());
-        assertTrue(mockingDetails(list2).isMock());
-    }
-
-    private static class MyListener implements MockitoListener {}
-}
diff --git a/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java b/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
deleted file mode 100644
index 25cc68c58c..0000000000
--- a/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.hamcrest;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.hamcrest.MatcherGenericTypeExtractor.genericTypeOfMatcher;
-
-import java.io.Serializable;
-import java.util.HashMap;
-
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-public class MatcherGenericTypeExtractorTest extends TestBase {
-
-    //traditional inner class for matcher
-    private class IntMatcher extends BaseMatcher<Integer> {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeTo(Description description) {}
-    }
-
-    //static class with matcher
-    private static class StaticIntMatcher extends BaseMatcher<Integer> {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeTo(Description description) {}
-    }
-
-    //static subclass
-    private static class StaticIntMatcherSubclass extends StaticIntMatcher {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeTo(Description description) {}
-    }
-
-    //non-generic
-    @SuppressWarnings("rawtypes")
-    private static class NonGenericMatcher extends BaseMatcher {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeTo(Description description) {}
-    }
-
-    //Matcher interface implementation (instead of the BaseMatcher)
-    private class IntMatcherFromInterface extends BaseMatcher<Integer> {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeMismatch(Object item, Description mismatchDescription) {}
-        public void describeTo(Description description) {}
-    }
-
-    //Static Matcher interface implementation (instead of the BaseMatcher)
-    private static class StaticIntMatcherFromInterface extends BaseMatcher<Integer> {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeMismatch(Object item, Description mismatchDescription) {}
-        public void describeTo(Description description) {}
-    }
-
-    //non-generic matcher implementing the interface
-    @SuppressWarnings("rawtypes")
-    private static class NonGenericMatcherFromInterface extends BaseMatcher {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeMismatch(Object item, Description mismatchDescription) {}
-        public void describeTo(Description description) {}
-    }
-
-    private interface IMatcher extends Matcher<Integer> {}
-
-    //non-generic matcher implementing the interface
-    private static class SubclassGenericMatcherFromInterface extends BaseMatcher<Integer> implements Serializable, Cloneable, IMatcher {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeMismatch(Object item, Description mismatchDescription) {}
-        public void describeTo(Description description) {}
-    }
-
-    //I refuse to comment on the sanity of this case
-    private static class InsaneEdgeCase extends SubclassGenericMatcherFromInterface {}
-
-    @Test
-    public void findsGenericType() {
-        assertEquals(Integer.class, genericTypeOfMatcher(IntMatcher.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcher.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(IntMatcherFromInterface.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcherSubclass.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(IntMatcherFromInterface.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcherFromInterface.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(SubclassGenericMatcherFromInterface.class));
-        assertEquals(Integer.class, genericTypeOfMatcher(InsaneEdgeCase.class));
-
-        assertEquals(Integer.class, genericTypeOfMatcher(new BaseMatcher<Integer>() {
-            public void describeTo(Description description) {
-            }
-
-            public boolean matches(Object o) {
-                return false;
-            }
-        }.getClass()));
-        assertEquals(Integer.class, genericTypeOfMatcher(new BaseMatcher<Integer>() {
-            public void describeTo(Description description) {
-            }
-
-            public boolean matches(Object o) {
-                return false;
-            }
-
-            public void describeMismatch(Object item, Description mismatchDescription) {
-            }
-        }.getClass()));
-
-        assertEquals(Object.class, genericTypeOfMatcher(Object.class));
-        assertEquals(Object.class, genericTypeOfMatcher(String.class));
-        assertEquals(Object.class, genericTypeOfMatcher(HashMap.class));
-        assertEquals(Object.class, genericTypeOfMatcher(new HashMap<String, String>() {
-        }.getClass()));
-        assertEquals(Object.class, genericTypeOfMatcher(NonGenericMatcher.class));
-        assertEquals(Object.class, genericTypeOfMatcher(NonGenericMatcherFromInterface.class));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java b/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
deleted file mode 100644
index c9c17afb55..0000000000
--- a/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.handler;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willThrow;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-import java.text.ParseException;
-import java.util.ArrayList;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.invocation.Invocation;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.MethodInvocationReport;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.stubbing.Answer;
-
-
-@RunWith(MockitoJUnitRunner.class)
-@SuppressWarnings("unchecked")
-public class InvocationNotifierHandlerTest {
-    private static final String SOME_LOCATION = "some location";
-    private static final RuntimeException SOME_EXCEPTION = new RuntimeException();
-    private static final OutOfMemoryError SOME_ERROR = new OutOfMemoryError();
-    private static final Answer<?> SOME_ANSWER = mock(Answer.class);
-
-
-    @Mock private InvocationListener listener1;
-    @Mock private InvocationListener listener2;
-    @Spy private CustomListener customListener;
-
-    @Mock private Invocation invocation;
-    @Mock private MockHandlerImpl<ArrayList<Answer<?>>> mockHandler;
-
-    private InvocationNotifierHandler<ArrayList<Answer<?>>> notifier;
-
-    @Before
-    public void setUp() throws Exception {
-        notifier = new InvocationNotifierHandler<ArrayList<Answer<?>>>(
-                mockHandler,
-                (MockCreationSettings<ArrayList<Answer<?>>>) new MockSettingsImpl<ArrayList<Answer<?>>>().invocationListeners(customListener, listener1, listener2)
-        );
-    }
-
-    @Test
-    public void should_notify_all_listeners_when_calling_delegate_handler() throws Throwable {
-        // given
-        given(mockHandler.handle(invocation)).willReturn("returned value");
-
-        // when
-        notifier.handle(invocation);
-
-        // then
-        verify(listener1).reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
-        verify(listener2).reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
-    }
-
-    @Test
-    public void should_notify_all_listeners_when_called_delegate_handler_returns_ex() throws Throwable {
-        // given
-        Exception computedException = new Exception("computed");
-        given(mockHandler.handle(invocation)).willReturn(computedException);
-
-        // when
-        notifier.handle(invocation);
-
-        // then
-        verify(listener1).reportInvocation(new NotifiedMethodInvocationReport(invocation, (Object) computedException));
-        verify(listener2).reportInvocation(new NotifiedMethodInvocationReport(invocation, (Object) computedException));
-    }
-
-    @Test(expected = ParseException.class)
-    public void should_notify_all_listeners_when_called_delegate_handler_throws_exception_and_rethrow_it() throws Throwable {
-        // given
-        ParseException parseException = new ParseException("", 0);
-        given(mockHandler.handle(invocation)).willThrow(parseException);
-
-        // when
-        try {
-            notifier.handle(invocation);
-            fail();
-        } finally {
-            // then
-            verify(listener1).reportInvocation(new NotifiedMethodInvocationReport(invocation, parseException));
-            verify(listener2).reportInvocation(new NotifiedMethodInvocationReport(invocation, parseException));
-        }
-    }
-
-    @Test
-    public void should_report_listener_exception() throws Throwable {
-        willThrow(new NullPointerException()).given(customListener).reportInvocation(any(MethodInvocationReport.class));
-
-        try {
-            notifier.handle(invocation);
-            fail();
-        } catch (MockitoException me) {
-            assertThat(me.getMessage())
-                    .contains("invocation listener")
-                    .contains("CustomListener")
-                    .contains("threw an exception")
-                    .contains("NullPointerException");
-        }
-    }
-
-    @Test
-    public void should_delegate_all_MockHandlerInterface_to_the_parameterized_MockHandler() throws Exception {
-        notifier.getInvocationContainer();
-        notifier.getMockSettings();
-
-        verify(mockHandler).getInvocationContainer();
-        verify(mockHandler).getMockSettings();
-    }
-
-    private static class CustomListener implements InvocationListener {
-        public void reportInvocation(MethodInvocationReport methodInvocationReport) {
-            // nop
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java b/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
deleted file mode 100644
index 9b999740ed..0000000000
--- a/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.handler;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-/**
- * by Szczepan Faber, created at: 5/22/12
- */
-public class MockHandlerFactoryTest extends TestBase {
-
-    private final IMethods mock = Mockito.mock(IMethods.class);
-
-    @Test
-    //see issue 331
-    public void handle_result_must_not_be_null_for_primitives() throws Throwable {
-        //given:
-        MockCreationSettings<?> settings = (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(null));
-        MockHandler<?> handler = createMockHandler(settings);
-
-        mock.intReturningMethod();
-        Invocation invocation = super.getLastInvocation();
-
-        //when:
-        Object result = handler.handle(invocation);
-
-        //then null value is not a valid result for a primitive
-        assertNotNull(result);
-        assertEquals(0, result);
-    }
-
-    @Test
-    //see issue 331
-    public void valid_handle_result_is_permitted() throws Throwable {
-        //given:
-        MockCreationSettings<?> settings = (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(123));
-        MockHandler<?> handler =  createMockHandler(settings);
-
-        mock.intReturningMethod();
-        Invocation invocation = super.getLastInvocation();
-
-        //when:
-        Object result = handler.handle(invocation);
-
-        //then
-        assertEquals(123, result);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java b/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
deleted file mode 100644
index 853de46f12..0000000000
--- a/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.handler;
-
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
-import java.util.Arrays;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
-import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.invocation.MatchersBinder;
-import org.mockito.internal.progress.ArgumentMatcherStorage;
-import org.mockito.internal.stubbing.InvocationContainerImpl;
-import org.mockito.internal.stubbing.StubbedInvocationMatcher;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.internal.verification.VerificationModeFactory;
-import org.mockito.invocation.Invocation;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.MethodInvocationReport;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings({"unchecked", "serial"})
-public class MockHandlerImplTest extends TestBase {
-
-    private StubbedInvocationMatcher stubbedInvocationMatcher = mock(StubbedInvocationMatcher.class);
-    private Invocation invocation = mock(Invocation.class);
-
-    @Test
-    public void should_remove_verification_mode_even_when_invalid_matchers() throws Throwable {
-        // given
-        Invocation invocation = new InvocationBuilder().toInvocation();
-        @SuppressWarnings("rawtypes")
-        MockHandlerImpl<?> handler = new MockHandlerImpl(new MockSettingsImpl());
-        mockingProgress().verificationStarted(VerificationModeFactory.atLeastOnce());
-        handler.matchersBinder = new MatchersBinder() {
-            public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
-                throw new InvalidUseOfMatchersException();
-            }
-        };
-
-        try {
-            // when
-            handler.handle(invocation);
-
-            // then
-            fail();
-        } catch (InvalidUseOfMatchersException ignored) {
-        }
-
-        assertNull(mockingProgress().pullVerificationMode());
-    }
-
-
-    @Test(expected = MockitoException.class)
-    public void should_throw_mockito_exception_when_invocation_handler_throws_anything() throws Throwable {
-        // given
-        InvocationListener throwingListener = mock(InvocationListener.class);
-        doThrow(new Throwable()).when(throwingListener).reportInvocation(any(MethodInvocationReport.class));
-        MockHandlerImpl<?> handler = create_correctly_stubbed_handler(throwingListener);
-
-        // when
-        handler.handle(invocation);
-    }
-
-    @Test(expected = WrongTypeOfReturnValue.class)
-    public void should_report_bogus_default_answer() throws Throwable {
-        MockSettingsImpl mockSettings = mock(MockSettingsImpl.class);
-        MockHandlerImpl<?> handler = new MockHandlerImpl(mockSettings);
-        given(mockSettings.getDefaultAnswer()).willReturn(new Returns(AWrongType.WRONG_TYPE));
-
-        @SuppressWarnings("unused") // otherwise cast is not done
-        String there_should_not_be_a_CCE_here = (String) handler.handle(
-                new InvocationBuilder().method(Object.class.getDeclaredMethod("toString")).toInvocation()
-        );
-    }
-
-    private MockHandlerImpl<?> create_correctly_stubbed_handler(InvocationListener throwingListener) {
-        MockHandlerImpl<?> handler = create_handler_with_listeners(throwingListener);
-        stub_ordinary_invocation_with_given_return_value(handler);
-        return handler;
-    }
-
-    private void stub_ordinary_invocation_with_given_return_value(MockHandlerImpl<?> handler) {
-        stub_ordinary_invocation_with_invocation_matcher(handler, stubbedInvocationMatcher);
-    }
-
-
-    private void stub_ordinary_invocation_with_invocation_matcher(MockHandlerImpl<?> handler, StubbedInvocationMatcher value) {
-        handler.invocationContainer = mock(InvocationContainerImpl.class);
-        given(handler.invocationContainer.findAnswerFor(any(Invocation.class))).willReturn(value);
-    }
-
-
-    private MockHandlerImpl<?> create_handler_with_listeners(InvocationListener... listener) {
-        @SuppressWarnings("rawtypes")
-        MockHandlerImpl<?> handler = new MockHandlerImpl(mock(MockSettingsImpl.class));
-        handler.matchersBinder = mock(MatchersBinder.class);
-        given(handler.getMockSettings().getInvocationListeners()).willReturn(Arrays.asList(listener));
-        return handler;
-    }
-
-    private static class AWrongType {
-        public static final AWrongType WRONG_TYPE = new AWrongType();
-    }
-}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java b/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
deleted file mode 100644
index 8c5fedbb50..0000000000
--- a/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import static java.util.Arrays.asList;
-
-import static org.mockito.internal.invocation.InterceptedInvocation.NO_OP;
-
-import java.lang.reflect.Method;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mockito.Mockito;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.invocation.mockref.MockReference;
-import org.mockito.internal.invocation.mockref.MockStrongReference;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockitousage.IMethods;
-
-/**
- * Build an invocation.
- */
-@SuppressWarnings("unchecked")
-public class InvocationBuilder {
-
-    private String methodName = "simpleMethod";
-    private int sequenceNumber = 0;
-    private Object[] args = new Object[]{};
-    private Object mock = Mockito.mock(IMethods.class);
-    private Method method;
-    private boolean verified;
-    private List<Class<?>> argTypes;
-    private Location location;
-
-    /**
-     * Build the invocation
-     * <p>
-     * If the method was not specified, use IMethods methods.
-     *
-     * @return invocation
-     */
-    public Invocation toInvocation() {
-        if (method == null) {
-            if (argTypes == null) {
-                argTypes = new LinkedList<Class<?>>();
-                for (Object arg : args) {
-                    if (arg == null) {
-                        argTypes.add(Object.class);
-                    } else {
-                        argTypes.add(arg.getClass());
-                    }
-                }
-            }
-
-            try {
-                method = IMethods.class.getMethod(methodName, argTypes.toArray(new Class[argTypes.size()]));
-            } catch (Exception e) {
-                throw new RuntimeException("builder only creates invocations of IMethods interface", e);
-            }
-        }
-
-        Invocation i = createInvocation(new MockStrongReference<Object>(mock, false),
-            new SerializableMethod(method),
-            args,
-            NO_OP,
-            location == null ? new LocationImpl() : location,
-            1);
-        if (verified) {
-            i.markVerified();
-        }
-        return i;
-    }
-
-    protected Invocation createInvocation(MockReference<Object> mockRef, MockitoMethod mockitoMethod, Object[] arguments,
-                                          RealMethod realMethod, Location location, int sequenceNumber) {
-        return new InterceptedInvocation(mockRef, mockitoMethod, arguments, realMethod, location, sequenceNumber);
-    }
-
-    public InvocationBuilder method(String methodName) {
-        this.methodName = methodName;
-        return this;
-    }
-
-    public InvocationBuilder seq(int sequenceNumber) {
-        this.sequenceNumber = sequenceNumber;
-        return this;
-    }
-
-    public InvocationBuilder args(Object... args) {
-        this.args = args;
-        return this;
-    }
-
-    public InvocationBuilder arg(Object o) {
-        this.args = new Object[]{o};
-        return this;
-    }
-
-    public InvocationBuilder mock(Object mock) {
-        this.mock = mock;
-        return this;
-    }
-
-    public InvocationBuilder method(Method method) {
-        this.method = method;
-        return this;
-    }
-
-    public InvocationBuilder verified() {
-        this.verified = true;
-        return this;
-    }
-
-    public InvocationMatcher toInvocationMatcher() {
-        return new InvocationMatcher(toInvocation());
-    }
-
-    public InvocationBuilder simpleMethod() {
-        return this.method("simpleMethod");
-    }
-
-    public InvocationBuilder differentMethod() {
-        return this.method("differentMethod");
-    }
-
-    public InvocationBuilder argTypes(Class<?>... argTypes) {
-        this.argTypes = asList(argTypes);
-        return this;
-    }
-
-    public InvocationBuilder location(final String location) {
-        this.location = new Location() {
-            public String toString() {
-                return location;
-            }
-            public String getSourceFile() {
-                return "SomeClass";
-            }
-        };
-        return this;
-    }
-}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java b/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
deleted file mode 100644
index 5434ce35f2..0000000000
--- a/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import static java.util.Arrays.asList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.internal.matchers.Any.ANY;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Mock;
-import org.mockito.internal.matchers.CapturingMatcher;
-import org.mockito.internal.matchers.Equals;
-import org.mockito.internal.matchers.NotNull;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class InvocationMatcherTest extends TestBase {
-
-    private InvocationMatcher simpleMethod;
-    @Mock private IMethods mock;
-
-    @Before
-    public void setup() {
-        simpleMethod = new InvocationBuilder().mock(mock).simpleMethod().toInvocationMatcher();
-    }
-
-    @Test
-    public void should_be_a_citizen_of_hashes() throws Exception {
-        Invocation invocation = new InvocationBuilder().toInvocation();
-        Invocation invocationTwo = new InvocationBuilder().args("blah").toInvocation();
-
-        Map<InvocationMatcher, String> map = new HashMap<InvocationMatcher, String>();
-        map.put(new InvocationMatcher(invocation), "one");
-        map.put(new InvocationMatcher(invocationTwo), "two");
-
-        assertEquals(2, map.size());
-    }
-
-    @Test
-    public void should_not_equal_if_number_of_arguments_differ() throws Exception {
-        InvocationMatcher withOneArg = new InvocationMatcher(new InvocationBuilder().args("test").toInvocation());
-        InvocationMatcher withTwoArgs = new InvocationMatcher(new InvocationBuilder().args("test", 100).toInvocation());
-
-        assertFalse(withOneArg.equals(null));
-        assertFalse(withOneArg.equals(withTwoArgs));
-    }
-
-    @Test
-    public void should_to_string_with_matchers() throws Exception {
-        ArgumentMatcher m = NotNull.NOT_NULL;
-        InvocationMatcher notNull = new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(m));
-        ArgumentMatcher mTwo = new Equals('x');
-        InvocationMatcher equals = new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(mTwo));
-
-        assertThat(notNull.toString()).contains("simpleMethod(notNull())");
-        assertThat(equals.toString()).contains("simpleMethod('x')");
-    }
-
-    @Test
-    public void should_know_if_is_similar_to() throws Exception {
-        Invocation same = new InvocationBuilder().mock(mock).simpleMethod().toInvocation();
-        assertTrue(simpleMethod.hasSimilarMethod(same));
-
-        Invocation different = new InvocationBuilder().mock(mock).differentMethod().toInvocation();
-        assertFalse(simpleMethod.hasSimilarMethod(different));
-    }
-
-    @Test
-    public void should_not_be_similar_to_verified_invocation() throws Exception {
-        Invocation verified = new InvocationBuilder().simpleMethod().verified().toInvocation();
-        assertFalse(simpleMethod.hasSimilarMethod(verified));
-    }
-
-    @Test
-    public void should_not_be_similar_if_mocks_are_different() throws Exception {
-        Invocation onDifferentMock = new InvocationBuilder().simpleMethod().mock("different mock").toInvocation();
-        assertFalse(simpleMethod.hasSimilarMethod(onDifferentMock));
-    }
-
-    @Test
-    public void should_not_be_similar_if_is_overloaded_but_used_with_the_same_arg() throws Exception {
-        Method method = IMethods.class.getMethod("simpleMethod", String.class);
-        Method overloadedMethod = IMethods.class.getMethod("simpleMethod", Object.class);
-
-        String sameArg = "test";
-
-        InvocationMatcher invocation = new InvocationBuilder().method(method).arg(sameArg).toInvocationMatcher();
-        Invocation overloadedInvocation = new InvocationBuilder().method(overloadedMethod).arg(sameArg).toInvocation();
-
-        assertFalse(invocation.hasSimilarMethod(overloadedInvocation));
-    }
-
-    @Test
-    public void should_be_similar_if_is_overloaded_but_used_with_different_arg() throws Exception {
-        Method method = IMethods.class.getMethod("simpleMethod", String.class);
-        Method overloadedMethod = IMethods.class.getMethod("simpleMethod", Object.class);
-
-        InvocationMatcher invocation = new InvocationBuilder().mock(mock).method(method).arg("foo").toInvocationMatcher();
-        Invocation overloadedInvocation = new InvocationBuilder().mock(mock).method(overloadedMethod).arg("bar").toInvocation();
-
-        assertTrue(invocation.hasSimilarMethod(overloadedInvocation));
-    }
-
-    @Test
-    public void should_capture_arguments_from_invocation() throws Exception {
-        //given
-        Invocation invocation = new InvocationBuilder().args("1", 100).toInvocation();
-        CapturingMatcher capturingMatcher = new CapturingMatcher();
-        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(new Equals("1"), capturingMatcher));
-
-        //when
-        invocationMatcher.captureArgumentsFrom(invocation);
-
-        //then
-        assertEquals(1, capturingMatcher.getAllValues().size());
-        assertEquals(100, capturingMatcher.getLastValue());
-    }
-
-    @Test
-    public void should_match_varargs_using_any_varargs() throws Exception {
-        //given
-        mock.varargs("1", "2");
-        Invocation invocation = getLastInvocation();
-        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(ANY));
-
-        //when
-        boolean match = invocationMatcher.matches(invocation);
-
-        //then
-        assertTrue(match);
-    }
-
-    @Test
-    public void should_capture_varargs_as_vararg() throws Exception {
-        //given
-        mock.mixedVarargs(1, "a", "b");
-        Invocation invocation = getLastInvocation();
-        CapturingMatcher m = new CapturingMatcher();
-        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, Arrays.<ArgumentMatcher>asList(new Equals(1), m));
-
-        //when
-        invocationMatcher.captureArgumentsFrom(invocation);
-
-        //then
-        Assertions.assertThat(m.getAllValues()).containsExactly("a", "b");
-    }
-
-    @Test  // like using several time the captor in the vararg
-    public void should_capture_arguments_when_args_count_does_NOT_match() throws Exception {
-        //given
-        mock.varargs();
-        Invocation invocation = getLastInvocation();
-
-        //when
-        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation,(List) asList(ANY));
-
-        //then
-        invocationMatcher.captureArgumentsFrom(invocation);
-    }
-
-    @Test
-    public void should_create_from_invocations() throws Exception {
-        //given
-        Invocation i = new InvocationBuilder().toInvocation();
-        //when
-        List<InvocationMatcher> out = InvocationMatcher.createFrom(asList(i));
-        //then
-        assertEquals(1, out.size());
-        assertEquals(i, out.get(0).getInvocation());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
deleted file mode 100644
index d962d8a75c..0000000000
--- a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.internal.verification.InOrderContextImpl;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-
-public class InvocationsFinderTest extends TestBase {
-
-    private LinkedList<Invocation> invocations = new LinkedList<Invocation>();
-    private Invocation simpleMethodInvocation;
-    private Invocation simpleMethodInvocationTwo;
-    private Invocation differentMethodInvocation;
-
-
-    private final InOrderContext context = new InOrderContextImpl();
-
-    @Mock private IMethods mock;
-
-    @Before
-    public void setup() throws Exception {
-        simpleMethodInvocation = new InvocationBuilder().mock(mock).simpleMethod().seq(1).toInvocation();
-        simpleMethodInvocationTwo = new InvocationBuilder().mock(mock).simpleMethod().seq(2).toInvocation();
-        differentMethodInvocation = new InvocationBuilder().mock(mock).differentMethod().seq(3).toInvocation();
-        invocations.addAll(Arrays.asList(simpleMethodInvocation, simpleMethodInvocationTwo, differentMethodInvocation));
-
-    }
-
-    @Test
-    public void shouldFindActualInvocations() throws Exception {
-        List<Invocation> actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(simpleMethodInvocation));
-        Assertions.assertThat(actual).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
-
-        actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(differentMethodInvocation));
-        Assertions.assertThat(actual).containsSequence(differentMethodInvocation);
-    }
-
-    @Test
-    public void shouldFindFirstUnverifiedInvocation() throws Exception {
-        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverified(invocations));
-
-        simpleMethodInvocationTwo.markVerified();
-        simpleMethodInvocation.markVerified();
-
-        assertSame(differentMethodInvocation, InvocationsFinder.findFirstUnverified(invocations));
-
-        differentMethodInvocation.markVerified();
-        assertNull(InvocationsFinder.findFirstUnverified(invocations));
-    }
-
-    @Test
-    public void shouldFindFirstUnverifiedInOrder() throws Exception {
-        //given
-        InOrderContextImpl context = new InOrderContextImpl();
-        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
-
-        //when
-        context.markVerified(simpleMethodInvocationTwo);
-        context.markVerified(simpleMethodInvocation);
-
-        //then
-        assertSame(differentMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
-
-        //when
-        context.markVerified(differentMethodInvocation);
-
-        //then
-        assertNull(InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
-    }
-
-    @Test
-    public void shouldFindFirstUnverifiedInOrderAndRespectSequenceNumber() throws Exception {
-        //given
-        InOrderContextImpl context = new InOrderContextImpl();
-        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
-
-        //when
-        //skipping verification of first invocation, then:
-        context.markVerified(simpleMethodInvocationTwo);
-        context.markVerified(differentMethodInvocation);
-
-        //then
-        assertSame(null, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
-    }
-
-    @Test
-    public void shouldFindFirstUnverifiedInvocationOnMock() throws Exception {
-        assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverified(invocations, simpleMethodInvocation.getMock()));
-        assertNull(InvocationsFinder.findFirstUnverified(invocations, "different mock"));
-    }
-
-    @Test
-    public void shouldFindFirstSimilarInvocationByName() throws Exception {
-        Invocation overloadedSimpleMethod = new InvocationBuilder().mock(mock).simpleMethod().arg("test").toInvocation();
-
-        Invocation found = InvocationsFinder.findSimilarInvocation(invocations, new InvocationMatcher(overloadedSimpleMethod));
-        assertSame(found, simpleMethodInvocation);
-    }
-
-    @Test
-    public void shouldFindInvocationWithTheSameMethod() throws Exception {
-        Invocation overloadedDifferentMethod = new InvocationBuilder().differentMethod().arg("test").toInvocation();
-
-        invocations.add(overloadedDifferentMethod);
-
-        Invocation found = InvocationsFinder.findSimilarInvocation(invocations, new InvocationMatcher(overloadedDifferentMethod));
-        assertSame(found, overloadedDifferentMethod);
-    }
-
-    @Test
-    public void shouldGetLastStackTrace() throws Exception {
-        Location last = InvocationsFinder.getLastLocation(invocations);
-        assertSame(differentMethodInvocation.getLocation(), last);
-
-        assertNull(InvocationsFinder.getLastLocation(Collections.<Invocation>emptyList()));
-    }
-
-    @Test
-    public void shouldFindAllMatchingUnverifiedChunks() throws Exception {
-        List<Invocation> allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
-        Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
-
-        context.markVerified(simpleMethodInvocation);
-        allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
-        Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocationTwo);
-
-        context.markVerified(simpleMethodInvocationTwo);
-        allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
-        assertTrue(allMatching.isEmpty());
-    }
-
-    @Test
-    public void shouldFindMatchingChunk() throws Exception {
-        List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 2, context);
-        Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
-    }
-
-    @Test
-    public void shouldReturnAllChunksWhenModeIsAtLeastOnce() throws Exception {
-        Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
-        invocations.add(simpleMethodInvocationThree);
-
-        List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
-        Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree);
-    }
-
-    @Test
-    public void shouldReturnAllChunksWhenWantedCountDoesntMatch() throws Exception {
-        Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
-        invocations.add(simpleMethodInvocationThree);
-
-        List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
-        Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree);
-    }
-
-    @Test
-    public void shouldFindPreviousInOrder() throws Exception {
-        Invocation previous = InvocationsFinder.findPreviousVerifiedInOrder(invocations, context);
-        assertNull(previous);
-
-        context.markVerified(simpleMethodInvocation);
-        context.markVerified(simpleMethodInvocationTwo);
-
-        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
deleted file mode 100644
index b29345984b..0000000000
--- a/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.invocation;
-
-import static java.util.Arrays.asList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.internal.invocation.MatcherApplicationStrategy.getMatcherApplicationStrategyFor;
-import static org.mockito.internal.matchers.Any.ANY;
-
-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;
-
-@SuppressWarnings("unchecked")
-public class MatcherApplicationStrategyTest extends TestBase {
-
-    @Mock
-    IMethods mock;
-    private Invocation invocation;
-    private List matchers;
-
-    private RecordingAction recordAction;
-
-    @Before
-    public void before() {
-        recordAction = new RecordingAction();
-    }
-
-    @Test
-    public void shouldKnowWhenActualArgsSizeIsDifferent1() {
-        // given
-        invocation = varargs("1");
-        matchers = asList(new Equals("1"));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_FALSE);
-
-        // then
-        assertFalse(match);
-    }
-
-    @Test
-    public void shouldKnowWhenActualArgsSizeIsDifferent2() {
-        // given
-        invocation = varargs("1");
-        matchers = asList(new Equals("1"));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
-
-        // then
-        assertTrue(match);
-    }
-
-    @Test
-    public void shouldKnowWhenActualArgsSizeIsDifferent() {
-        // given
-        invocation = varargs("1", "2");
-        matchers = asList(new Equals("1"));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
-
-        // then
-        assertFalse(match);
-    }
-
-    @Test
-    public void shouldKnowWhenMatchersSizeIsDifferent() {
-        // given
-        invocation = varargs("1");
-        matchers = asList(new Equals("1"), new Equals("2"));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
-
-        // then
-        assertFalse(match);
-    }
-
-    @Test
-    public void shouldKnowWhenVarargsMatch() {
-        // given
-        invocation = varargs("1", "2", "3");
-        matchers = asList(new Equals("1"), Any.ANY, new InstanceOf(String.class));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        assertTrue(match);
-    }
-
-    @Test
-    public void shouldAllowAnyVarargMatchEntireVararg() {
-        // given
-        invocation = varargs("1", "2");
-        matchers = asList(ANY);
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        assertTrue(match);
-    }
-
-    @Test
-    public void shouldNotAllowAnyObjectWithMixedVarargs() {
-        // given
-        invocation = mixedVarargs(1, "1", "2");
-        matchers = asList(new Equals(1));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        assertFalse(match);
-    }
-
-    @Test
-    public void shouldAllowAnyObjectWithMixedVarargs() {
-        // given
-        invocation = mixedVarargs(1, "1", "2");
-        matchers = asList(new Equals(1), ANY);
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        assertTrue(match);
-    }
-
-    @Test
-    public void shouldAnyObjectVarargDealWithDifferentSizeOfArgs() {
-        // given
-        invocation = mixedVarargs(1, "1", "2");
-        matchers = asList(new Equals(1));
-
-        // when
-        boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        assertFalse(match);
-
-        recordAction.assertIsEmpty();
-    }
-
-    @Test
-    public void shouldMatchAnyVarargEvenIfOneOfTheArgsIsNull() {
-        // given
-        invocation = mixedVarargs(null, null, "2");
-        matchers = asList(new Equals(null), ANY);
-
-        // when
-        getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        recordAction.assertContainsExactly(new Equals(null), ANY, ANY);
-
-    }
-
-    @Test
-    public void shouldMatchAnyVarargEvenIfMatcherIsDecorated() {
-        // given
-        invocation = varargs("1", "2");
-        matchers = asList(ANY);
-
-        // when
-        getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
-
-        // then
-        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();
-    }
-
-    private Invocation varargs(String... s) {
-        mock.varargs(s);
-        return getLastInvocation();
-    }
-
-    private class RecordingAction implements ArgumentMatcherAction {
-        private List<ArgumentMatcher<?>> matchers = new ArrayList<ArgumentMatcher<?>>();
-
-        @Override
-        public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
-            matchers.add(matcher);
-            return true;
-        }
-
-        public void assertIsEmpty() {
-            assertThat(matchers).isEmpty();
-        }
-
-        public void assertContainsExactly(ArgumentMatcher<?>... matchers) {
-            assertThat(this.matchers).containsExactly(matchers);
-        }
-    }
-
-    private static final ArgumentMatcherAction RETURN_ALWAYS_TRUE = new ArgumentMatcherAction() {
-        @Override
-        public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
-            return true;
-        }
-    };
-
-    private static final ArgumentMatcherAction RETURN_ALWAYS_FALSE = new ArgumentMatcherAction() {
-        @Override
-        public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
-            return false;
-        }
-    };
-
-}
diff --git a/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java b/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
deleted file mode 100644
index 2c1037bae2..0000000000
--- a/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockitoutil.ClassLoaders.excludingClassLoader;
-
-import java.lang.reflect.Method;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.mockito.exceptions.verification.ArgumentsAreDifferent;
-
-public class ExceptionFactoryTest {
-
-    private static ClassLoader classLoaderWithoutJUnitOrOpenTest = excludingClassLoader().withCodeSourceUrlOf(ExceptionFactory.class).without("org.junit", "junit", "org.opentest4j").build();
-    private static ClassLoader classLoaderWithoutOpenTest = excludingClassLoader().withCodeSourceUrlOf(ExceptionFactory.class, org.junit.ComparisonFailure.class).without("org.opentest4j").build();
-    private static ClassLoader currentClassLoader = ExceptionFactoryTest.class.getClassLoader();
-
-    /** loaded by the current classloader */
-    private static Class<?> opentestComparisonFailure;
-    private static Class<?> opentestArgumentsAreDifferent;
-
-    /** loaded by the classloader {@value #classLoaderWithoutOpenTest}, which excludes OpenTest4J classes */
-    private static Class<?> junit3ComparisonFailure;
-    private static Class<?> junit3ArgumentsAreDifferent;
-
-    /** loaded by the custom classloader {@value #classLoaderWithoutJUnitOrOpenTest}, which excludes JUnit and OpenTest4J classes */
-    private static Class<?> nonJunitArgumentsAreDifferent;
-
-    @BeforeClass
-    public static void init() throws ClassNotFoundException {
-        nonJunitArgumentsAreDifferent = classLoaderWithoutJUnitOrOpenTest.loadClass(ArgumentsAreDifferent.class.getName());
-        junit3ComparisonFailure = classLoaderWithoutOpenTest.loadClass(junit.framework.ComparisonFailure.class.getName());
-        junit3ArgumentsAreDifferent = classLoaderWithoutOpenTest.loadClass(org.mockito.exceptions.verification.junit.ArgumentsAreDifferent.class.getName());
-        opentestComparisonFailure = org.opentest4j.AssertionFailedError.class;
-        opentestArgumentsAreDifferent = org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent.class;
-    }
-
-    @Test
-    public void createArgumentsAreDifferentException_withoutJUnitOrOpenTest() throws Exception {
-        AssertionError e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
-
-        assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
-    }
-
-    @Test
-    public void createArgumentsAreDifferentException_withJUnit3_butNotOpenTest() throws Exception {
-        AssertionError e = invokeFactoryThroughLoader(classLoaderWithoutOpenTest);
-
-        assertThat(e).isExactlyInstanceOf(junit3ArgumentsAreDifferent).isInstanceOf(junit3ComparisonFailure);
-    }
-
-    @Test
-    public void createArgumentsAreDifferentException_withOpenTest() throws Exception {
-        AssertionError e = invokeFactoryThroughLoader(currentClassLoader);
-
-        assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent).isInstanceOf(opentestComparisonFailure);
-    }
-
-    @Test
-    public void createArgumentsAreDifferentException_withoutJUnitOrOpenTest_2x() throws Exception {
-        AssertionError e;
-
-        e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
-        assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
-
-        e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
-        assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
-    }
-
-    @Test
-    public void createArgumentsAreDifferentException_withJUnit3_2x() throws Exception {
-        AssertionError e;
-
-        e = invokeFactoryThroughLoader(classLoaderWithoutOpenTest);
-        assertThat(e).isExactlyInstanceOf(junit3ArgumentsAreDifferent);
-
-        e = invokeFactoryThroughLoader(classLoaderWithoutOpenTest);
-        assertThat(e).isExactlyInstanceOf(junit3ArgumentsAreDifferent);
-    }
-
-    @Test
-    public void createArgumentsAreDifferentException_withOpenTest_2x() throws Exception {
-        AssertionError e;
-
-        e = invokeFactoryThroughLoader(currentClassLoader);
-        assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent);
-
-        e = invokeFactoryThroughLoader(currentClassLoader);
-        assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent);
-    }
-
-    private static AssertionError invokeFactoryThroughLoader(ClassLoader loader) throws Exception {
-        Class<?> exceptionFactory = loader.loadClass(ExceptionFactory.class.getName());
-
-        Method m = exceptionFactory.getDeclaredMethod("createArgumentsAreDifferentException", String.class, String.class, String.class);
-        return (AssertionError) m.invoke(null, "message", "wanted", "actual");
-    }
-}
diff --git a/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java b/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
deleted file mode 100644
index beb94210e6..0000000000
--- a/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.invocation.Invocation;
-import org.mockitoutil.TestBase;
-
-public class StubbingArgMismatchesTest extends TestBase {
-
-    SimpleMockitoLogger logger = new SimpleMockitoLogger();
-    StubbingArgMismatches mismatches = new StubbingArgMismatches();
-
-    @Test
-    public void no_op_when_no_mismatches() throws Exception {
-        //when
-        mismatches.format("MyTest.myTestMethod", logger);
-
-        //then
-        assertTrue(logger.isEmpty());
-    }
-
-    @Test
-    public void logs_mismatch() throws Exception {
-        //given
-        mismatches.add(
-                new InvocationBuilder().args("a").location("-> at A.java").toInvocation(),
-                new InvocationBuilder().args("b").location("-> at B.java").toInvocation());
-
-        //when
-        mismatches.format("MyTest.myTestMethod", logger);
-
-        //then
-        assertEquals(
-            "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" +
-            "[MockitoHint] 1. Unused... -> at B.java\n" +
-            "[MockitoHint]  ...args ok? -> at A.java\n", logger.getLoggedInfo());
-    }
-
-    @Test
-    public void multiple_matching_invocations_per_stub_plus_some_other_invocation() throws Exception {
-        //given
-        Invocation stubbing = new InvocationBuilder().args("a").location("-> at A.java").toInvocation();
-        mismatches.add(new InvocationBuilder().args("x").location("-> at X.java").toInvocation(), stubbing);
-        mismatches.add(new InvocationBuilder().args("y").location("-> at Y.java").toInvocation(), stubbing);
-
-        mismatches.add(
-                new InvocationBuilder().method("differentMethod").args("n").location("-> at N.java").toInvocation(),
-                new InvocationBuilder().method("differentMethod").args("m").location("-> at M.java").toInvocation());
-
-        //when
-        mismatches.format("MyTest.myTestMethod", logger);
-
-        //then
-        assertEquals(
-            "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" +
-            "[MockitoHint] 1. Unused... -> at A.java\n" +
-            "[MockitoHint]  ...args ok? -> at X.java\n" +
-            "[MockitoHint]  ...args ok? -> at Y.java\n" +
-            "[MockitoHint] 2. Unused... -> at M.java\n" +
-            "[MockitoHint]  ...args ok? -> at N.java\n", logger.getLoggedInfo());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java b/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
deleted file mode 100644
index f169516e73..0000000000
--- a/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import org.junit.Test;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.stubbing.StubbedInvocationMatcher;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.stubbing.Stubbing;
-import org.mockitoutil.TestBase;
-
-public class UnusedStubbingsTest extends TestBase {
-
-    private SimpleMockitoLogger logger = new SimpleMockitoLogger();
-
-    @Test
-    public void no_unused_stubbings() throws Exception {
-        //given
-        UnusedStubbings stubbings = new UnusedStubbings(Collections.<Stubbing>emptyList());
-
-        //when
-        stubbings.format("MyTest.myTestMethod", logger);
-
-        //then
-        assertEquals("", logger.getLoggedInfo());
-    }
-
-    @Test
-    public void unused_stubbings() throws Exception {
-        //given
-        UnusedStubbings stubbings = new UnusedStubbings(Arrays.asList(
-            new StubbedInvocationMatcher(doesNothing(), new InvocationBuilder().toInvocationMatcher(), null),
-            new StubbedInvocationMatcher(doesNothing(), new InvocationBuilder().toInvocationMatcher(), null)
-        ));
-
-
-        //when
-        stubbings.format("MyTest.myTestMethod", logger);
-
-        //then
-        assertThat(filterLineNo(logger.getLoggedInfo())).isIn(
-            "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" +  //Java <9
-                                    "[MockitoHint] 1. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" +
-                                    "[MockitoHint] 2. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n",
-            "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" +  //Java 9
-                                    "[MockitoHint] 1. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" +
-                                    "[MockitoHint] 2. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n"
-        );
-    }
-}
diff --git a/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java b/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java
deleted file mode 100644
index 5da1ffad08..0000000000
--- a/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.junit.util;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.junit.runner.Description;
-import org.junit.runner.notification.Failure;
-import org.mockito.internal.exceptions.ExceptionIncludingMockitoWarnings;
-import org.mockitoutil.TestBase;
-
-public class JUnitFailureHackerTest extends TestBase {
-
-    JUnitFailureHacker hacker = new JUnitFailureHacker();
-
-    @Test
-    public void shouldReplaceException() throws Exception {
-        //given
-        RuntimeException actualExc = new RuntimeException("foo");
-        Failure failure = new Failure(Description.EMPTY, actualExc);
-
-        //when
-        hacker.appendWarnings(failure, "unused stubbing");
-
-        //then
-        assertEquals(ExceptionIncludingMockitoWarnings.class, failure.getException().getClass());
-        assertEquals(actualExc, failure.getException().getCause());
-        Assertions.assertThat(actualExc.getStackTrace()).isEqualTo(failure.getException().getStackTrace());
-    }
-
-    @Test
-    public void shouldAppendWarning() throws Exception {
-        Failure failure = new Failure(Description.EMPTY, new RuntimeException("foo"));
-
-        //when
-        hacker.appendWarnings(failure, "unused stubbing blah");
-
-        //then
-        assertThat(failure.getException()).hasMessageContaining("unused stubbing blah");
-    }
-
-    @Test
-    public void shouldNotAppendWhenNoWarnings() throws Exception {
-        RuntimeException ex = new RuntimeException("foo");
-        Failure failure = new Failure(Description.EMPTY, ex);
-
-        //when
-        hacker.appendWarnings(failure, "");
-
-        //then
-        assertEquals(ex, failure.getException());
-    }
-
-    @Test
-    public void shouldNotAppendWhenNullWarnings() throws Exception {
-        RuntimeException ex = new RuntimeException("foo");
-        Failure failure = new Failure(Description.EMPTY, ex);
-
-        //when
-        hacker.appendWarnings(failure, null);
-
-        //then
-        assertEquals(ex, failure.getException());
-    }
-
-    @Test
-    public void shouldPrintTheWarningSoICanSeeIt() throws Exception {
-        Failure failure = new Failure(Description.EMPTY, new RuntimeException("foo"));
-
-        //when
-        hacker.appendWarnings(failure, "unused stubbing blah");
-
-        //then
-        System.out.println(failure.getException());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java b/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
deleted file mode 100644
index 6c211950ff..0000000000
--- a/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.listeners;
-
-import static java.util.Collections.emptyList;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.withSettings;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.junit.Test;
-import org.mockito.MockingDetails;
-import org.mockitoutil.TestBase;
-
-public class VerificationStartedNotifierTest extends TestBase {
-
-    MockingDetails mockingDetails = mockingDetails(mock(List.class));
-
-    @Test
-    public void does_not_do_anything_when_list_is_empty() throws Exception {
-        //expect nothing to happen
-        VerificationStartedNotifier.notifyVerificationStarted((List) emptyList(), mockingDetails);
-    }
-
-    @Test
-    public void decent_exception_when_setting_non_mock() throws Exception {
-        VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails);
-
-        try {
-            //when
-            event.setMock("not a mock");
-            fail();
-        } catch (Exception e) {
-            //then
-            assertEquals("VerificationStartedEvent.setMock() does not accept parameter which is not a Mockito mock.\n" +
-                "  Received parameter: \"not a mock\".\n" +
-                "  See the Javadoc.", e.getMessage());
-        }
-    }
-
-    @Test
-    public void shows_clean_exception_message_when_illegal_null_arg_is_used() throws Exception {
-        VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails);
-
-        try {
-            //when
-            event.setMock(null);
-            fail();
-        } catch (Exception e) {
-            //then
-            assertEquals("VerificationStartedEvent.setMock() does not accept null parameter. See the Javadoc.", e.getMessage());
-        }
-    }
-
-    @Test
-    public void decent_exception_when_setting_mock_of_wrong_type() throws Exception {
-        final Set differentTypeMock = mock(Set.class);
-        VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails);
-
-        try {
-            //when
-            event.setMock(differentTypeMock);
-            fail();
-        } catch (Exception e) {
-            //then
-            assertEquals(filterHashCode("VerificationStartedEvent.setMock() does not accept parameter which is not the same type as the original mock.\n" +
-                "  Required type: java.util.List\n" +
-                "  Received parameter: Mock for Set, hashCode: xxx.\n" +
-                "  See the Javadoc."), filterHashCode(e.getMessage()));
-        }
-    }
-
-    @Test
-    public void decent_exception_when_setting_mock_that_does_not_implement_all_desired_interfaces() throws Exception {
-        final Set mock = mock(Set.class, withSettings().extraInterfaces(List.class));
-        final Set missingExtraInterface = mock(Set.class);
-        VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails(mock));
-
-        try {
-            //when setting mock that does not have all necessary interfaces
-            event.setMock(missingExtraInterface);
-            fail();
-        } catch (Exception e) {
-            //then
-            assertEquals(filterHashCode("VerificationStartedEvent.setMock() does not accept parameter which does not implement all extra interfaces of the original mock.\n" +
-                "  Required type: java.util.Set\n" +
-                "  Required extra interface: java.util.List\n" +
-                "  Received parameter: Mock for Set, hashCode: xxx.\n" +
-                "  See the Javadoc."), filterHashCode(e.getMessage()));
-        }
-    }
-
-    @Test
-    public void accepts_replacement_mock_if_all_types_are_compatible() throws Exception {
-        final Set mock = mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
-        final Set compatibleMock = mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
-        VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails(mock));
-
-        //when
-        event.setMock(compatibleMock);
-
-        //then
-        assertEquals(compatibleMock, event.getMock());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java b/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
deleted file mode 100644
index 19e85baa9b..0000000000
--- a/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.internal.matchers.text.MatchersPrinter;
-import org.mockito.internal.reporting.PrintSettings;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class MatchersPrinterTest extends TestBase {
-
-    private final MatchersPrinter printer = new MatchersPrinter();
-
-    @Test
-    public void shouldGetArgumentsLine() {
-        String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
-        assertEquals("(1, 2);", line);
-    }
-
-    @Test
-    public void shouldGetArgumentsBlock() {
-        String line = printer.getArgumentsBlock((List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
-        assertEquals("(\n    1,\n    2\n);", line);
-    }
-
-    @Test
-    public void shouldDescribeTypeInfoOnlyMarkedMatchers() {
-        //when
-        String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), new Equals(2)), PrintSettings.verboseMatchers(1));
-        //then
-        assertEquals("(1L, (Integer) 2);", line);
-    }
-
-    @Test
-    public void shouldDescribeStringMatcher() {
-        //when
-        String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), new Equals("x")), PrintSettings.verboseMatchers(1));
-        //then
-        assertEquals("(1L, (String) \"x\");", line);
-    }
-
-    @Test
-    public void shouldGetVerboseArgumentsInBlock() {
-        //when
-        String line = printer.getArgumentsBlock((List) Arrays.asList(new Equals(1L), new Equals(2)), PrintSettings.verboseMatchers(0, 1));
-        //then
-        assertEquals("(\n    (Long) 1L,\n    (Integer) 2\n);", line);
-    }
-
-    @Test
-    public void shouldGetVerboseArgumentsEvenIfSomeMatchersAreNotVerbose() {
-        //when
-        String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), NotNull.NOT_NULL), PrintSettings.verboseMatchers(0));
-        //then
-        assertEquals("((Long) 1L, notNull());", line);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java b/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
deleted file mode 100644
index 04906df218..0000000000
--- a/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers.text;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockitoutil.TestBase;
-
-public class MatcherToStringTest extends TestBase {
-
-    static class MatcherWithoutDescription implements ArgumentMatcher<Object> {
-        public boolean matches(Object argument) {
-            return false;
-        }
-    }
-
-    static class MatcherWithDescription implements ArgumentMatcher<Object> {
-        public boolean matches(Object argument) {
-            return false;
-        }
-        public String toString() {
-            return "*my custom description*";
-        }
-    }
-
-    static class MatcherWithInheritedDescription extends MatcherWithDescription {
-        public boolean matches(Object argument) {
-            return false;
-        }
-    }
-
-    @Test
-    public void better_toString_for_matchers() {
-        assertEquals("<Matcher without description>", MatcherToString.toString(new MatcherWithoutDescription()));
-        assertEquals("*my custom description*", MatcherToString.toString(new MatcherWithDescription()));
-        assertEquals("*my custom description*", MatcherToString.toString(new MatcherWithInheritedDescription()));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java b/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
deleted file mode 100644
index d717a7616f..0000000000
--- a/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.matchers.text;
-
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.internal.matchers.text.ValuePrinter.print;
-
-import java.util.LinkedHashMap;
-
-import org.junit.Test;
-
-public class ValuePrinterTest {
-
-    @Test
-    public void prints_values() {
-        assertThat(print(null)).isEqualTo("null");
-        assertThat(print("str")).isEqualTo("\"str\"");
-        assertThat(print("x\ny")).isEqualTo("\"x\ny\"");
-        assertThat(print(3)).isEqualTo("3");
-        assertThat(print(3L)).isEqualTo("3L");
-        assertThat(print(3.14d)).isEqualTo("3.14d");
-        assertThat(print(3.14f)).isEqualTo("3.14f");
-        assertThat(print(new int[]{1, 2})).isEqualTo("[1, 2]");
-        assertThat(print(new LinkedHashMap<String, Object>() {{
-            put("foo", 2L);
-        }})).isEqualTo("{\"foo\" = 2L}");
-        assertThat(print(new LinkedHashMap<String, Object>() {{
-            put("int passed as hex", 0x01);
-            put("byte", (byte) 0x01);
-            put("short", (short) 2);
-            put("int", 3);
-            put("long", 4L);
-            put("float", 2.71f);
-            put("double", 3.14d);
-        }})).isEqualTo("{\"int passed as hex\" = 1, \"byte\" = (byte) 0x01, \"short\" = (short) 2, \"int\" = 3, \"long\" = 4L, \"float\" = 2.71f, \"double\" = 3.14d}");
-        assertTrue(print(new UnsafeToString()).contains("UnsafeToString"));
-        assertThat(print(new ToString())).isEqualTo("ToString");
-        assertThat(print(new FormattedText("formatted"))).isEqualTo("formatted");
-    }
-
-    @Test
-    public void prints_chars() {
-        assertThat(print('a')).isEqualTo("'a'");
-        assertThat(print('\n')).isEqualTo("'\\n'");
-        assertThat(print('\t')).isEqualTo("'\\t'");
-        assertThat(print('\r')).isEqualTo("'\\r'");
-    }
-
-    static class ToString {
-        public String toString() {
-            return "ToString";
-        }
-
-    }
-    static class UnsafeToString {
-        public String toString() {
-            throw new RuntimeException("ka-boom!");
-        }
-
-    }
-}
diff --git a/src/test/java/org/mockito/internal/progress/TimesTest.java b/src/test/java/org/mockito/internal/progress/TimesTest.java
deleted file mode 100644
index 53cb1c5574..0000000000
--- a/src/test/java/org/mockito/internal/progress/TimesTest.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.progress;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.verification.VerificationModeFactory;
-
-
-public class TimesTest  {
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Test
-    public void shouldNotAllowNegativeNumberOfInvocations() throws Exception {
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Negative value is not allowed here");
-
-        VerificationModeFactory.times(-50);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java b/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
deleted file mode 100644
index 123ee2965e..0000000000
--- a/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.runners;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.*;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestRule;
-import org.junit.runner.Description;
-import org.junit.runner.notification.Failure;
-import org.junit.runner.notification.RunListener;
-import org.junit.runner.notification.RunNotifier;
-import org.junit.runners.model.Statement;
-import org.mockito.Mock;
-import org.mockito.internal.junit.MockitoTestListener;
-import org.mockito.internal.junit.TestFinishedEvent;
-import org.mockito.internal.util.Supplier;
-
-public class DefaultInternalRunnerTest {
-
-    private final RunListener runListener = mock(RunListener.class);
-    private final MockitoTestListener mockitoTestListener = mock(MockitoTestListener.class);
-    private final Supplier<MockitoTestListener> supplier = new Supplier<MockitoTestListener>() {
-        public MockitoTestListener get() {
-            return mockitoTestListener;
-        }
-    };
-
-    @Test
-    public void does_not_fail_when_tests_succeeds() throws Exception {
-        new DefaultInternalRunner(SuccessTest.class, supplier)
-            .run(newNotifier(runListener));
-
-        verifyTestFinishedSuccessfully();
-    }
-
-    @Test
-    public void does_not_fail_second_test_when_first_test_fail() throws Exception {
-        new DefaultInternalRunner(TestFailOnInitialization.class, supplier)
-            .run(newNotifier(runListener));
-
-        verify(runListener, times(1)).testFailure(any(Failure.class));
-        verify(runListener, times(1)).testFinished(any(Description.class));
-        verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
-
-        reset(runListener, mockitoTestListener);
-
-        new DefaultInternalRunner(SuccessTest.class, supplier)
-            .run(newNotifier(runListener));
-
-        verifyTestFinishedSuccessfully();
-    }
-
-    @Test
-    public void does_not_fail_when_rule_invokes_statement_multiple_times() throws Exception {
-        new DefaultInternalRunner(TestWithRepeatingRule.class, supplier)
-            .run(newNotifier(runListener));
-
-        verifyTestFinishedSuccessfully();
-    }
-
-    private void verifyTestFinishedSuccessfully() throws Exception {
-        verify(runListener, never()).testFailure(any(Failure.class));
-        verify(runListener, times(1)).testFinished(any(Description.class));
-        verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
-    }
-
-    private RunNotifier newNotifier(RunListener listener) {
-        RunNotifier notifier = new RunNotifier();
-        notifier.addListener(listener);
-        return notifier;
-    }
-
-    public static class SuccessTest {
-
-        @Test
-        public void this_test_is_NOT_supposed_to_fail() {
-            assertTrue(true);
-        }
-    }
-
-    public static final class TestFailOnInitialization {
-
-        @Mock
-        private System system;
-
-        @Test
-        public void this_test_is_supposed_to_fail() {
-            assertNotNull(system);
-        }
-    }
-
-    public static final class TestWithRepeatingRule extends SuccessTest {
-
-        @Rule
-        public TestRule rule = (base, description) -> new Statement() {
-            @Override
-            public void evaluate() throws Throwable {
-                base.evaluate();
-                base.evaluate();
-            }
-        };
-    }
-}
diff --git a/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java b/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
deleted file mode 100644
index fc30d933da..0000000000
--- a/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.session;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.when;
-import static org.mockito.quality.Strictness.WARN;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoSession;
-import org.mockito.StateMaster;
-import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
-import org.mockito.quality.Strictness;
-import org.mockito.session.MockitoSessionLogger;
-import org.mockitoutil.ThrowableAssert;
-
-public class DefaultMockitoSessionBuilderTest {
-
-    @After public void after() {
-        new StateMaster().clearMockitoListeners();
-    }
-
-    @Test public void creates_sessions() {
-        //no configuration is legal
-        new DefaultMockitoSessionBuilder().startMocking().finishMocking();
-
-        //passing null to configuration is legal, default value will be used
-        new DefaultMockitoSessionBuilder().initMocks((Object) null).startMocking().finishMocking();
-        new DefaultMockitoSessionBuilder().initMocks((Object[]) null).startMocking().finishMocking();
-        new DefaultMockitoSessionBuilder().initMocks(null, null).strictness(null).startMocking().finishMocking();
-        new DefaultMockitoSessionBuilder().strictness(null).startMocking().finishMocking();
-
-        //happy path
-        new DefaultMockitoSessionBuilder().initMocks(this).startMocking().finishMocking();
-        new DefaultMockitoSessionBuilder().initMocks(new Object()).startMocking().finishMocking();
-        new DefaultMockitoSessionBuilder().strictness(Strictness.LENIENT).startMocking().finishMocking();
-    }
-
-    @Test public void creates_sessions_for_multiple_test_class_instances_for_repeated_calls() {
-        TestClass testClass = new TestClass();
-        TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
-
-        new DefaultMockitoSessionBuilder().initMocks(testClass).initMocks(nestedTestClass).startMocking().finishMocking();
-
-        assertNotNull(testClass.set);
-        assertNotNull(nestedTestClass.list);
-    }
-
-    @Test public void creates_sessions_for_multiple_test_class_instances_for_varargs_call() {
-        TestClass testClass = new TestClass();
-        TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
-
-        new DefaultMockitoSessionBuilder().initMocks(testClass, nestedTestClass).startMocking().finishMocking();
-
-        assertNotNull(testClass.set);
-        assertNotNull(nestedTestClass.list);
-    }
-
-    @Test public void uses_logger_and_strictness() {
-        TestClass testClass = new TestClass();
-
-        final List<String> hints = new ArrayList<String>();
-        MockitoSession session = new DefaultMockitoSessionBuilder()
-            .initMocks(testClass)
-            .strictness(WARN)
-            .logger(new MockitoSessionLogger() {
-                @Override
-                public void log(String hint) {
-                    hints.add(hint);
-                }
-            })
-            .startMocking();
-
-        when(testClass.set.add(1)).thenReturn(true);
-
-        session.finishMocking();
-
-        assertFalse(hints.isEmpty());
-    }
-
-    @Test public void requires_finish_mocking() {
-        new DefaultMockitoSessionBuilder().startMocking();
-
-        ThrowableAssert.assertThat(new Runnable() {
-            public void run() {
-                new DefaultMockitoSessionBuilder().startMocking();
-            }
-        }).throwsException(UnfinishedMockingSessionException.class);
-    }
-
-    @Test public void auto_cleans_dirty_listeners() {
-        new DefaultMockitoSessionBuilder().startMocking();
-
-        ThrowableAssert.assertThat(new Runnable() {
-            public void run() {
-                new DefaultMockitoSessionBuilder().startMocking();
-            }
-        }).throwsException(UnfinishedMockingSessionException.class);
-    }
-
-    class TestClass {
-
-        @Mock public Set<Object> set;
-
-        class NestedTestClass {
-            @Mock public List<Object> list;
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
deleted file mode 100644
index 628af8cc8a..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-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;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues;
-import org.mockito.invocation.Invocation;
-import org.mockito.mock.MockCreationSettings;
-
-/**
- * Author: Szczepan Faber
- */
-public class InvocationContainerImplTest {
-
-    InvocationContainerImpl container = new InvocationContainerImpl( new MockSettingsImpl());
-    InvocationContainerImpl containerStubOnly =
-      new InvocationContainerImpl( (MockCreationSettings) new MockSettingsImpl().stubOnly());
-    Invocation invocation = new InvocationBuilder().toInvocation();
-    LinkedList<Throwable> exceptions = new LinkedList<Throwable>();
-
-    @Test
-    public void should_be_thread_safe() throws Throwable {
-        doShouldBeThreadSafe(container);
-    }
-
-    @Test
-    public void should_be_thread_safe_stub_only() throws Throwable {
-        doShouldBeThreadSafe(containerStubOnly);
-    }
-
-    //works 50% of the time
-    private void doShouldBeThreadSafe(final InvocationContainerImpl c) throws Throwable {
-        //given
-        Thread[] t = new Thread[200];
-        final CountDownLatch starter = new CountDownLatch(200);
-        for (int i = 0; i < t.length; i++ ) {
-            t[i] = new Thread() {
-                public void run() {
-                    try {
-                        starter.await(); //NOPMD
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                    c.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
-                    c.addAnswer(new Returns("foo"), null);
-                    c.findAnswerFor(invocation);
-                }
-            };
-            t[i].setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
-                public void uncaughtException(Thread t, Throwable e) {
-                    exceptions.add(e);
-                }
-            });
-            t[i].start();
-
-            starter.countDown();
-        }
-
-        //when
-        for (Thread aT : t) {
-            aT.join();
-        }
-
-        //then
-        if (exceptions.size() != 0) {
-            throw exceptions.getFirst();
-        }
-    }
-
-    @Test
-    public void should_return_invoked_mock() throws Exception {
-        container.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
-
-        assertEquals(invocation.getMock(), container.invokedMock());
-    }
-
-    @Test
-    public void should_return_invoked_mock_stub_only() throws Exception {
-        containerStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
-
-        assertEquals(invocation.getMock(), containerStubOnly.invokedMock());
-    }
-
-    @Test
-    public void should_tell_if_has_invocation_for_potential_stubbing() throws Exception {
-        container.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
-        assertTrue(container.hasInvocationForPotentialStubbing());
-
-        container.addAnswer(new ReturnsEmptyValues(), null);
-        assertFalse(container.hasInvocationForPotentialStubbing());
-    }
-
-    @Test
-    public void should_tell_if_has_invocation_for_potential_stubbing_stub_only() throws Exception {
-        containerStubOnly.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
-        assertTrue(containerStubOnly.hasInvocationForPotentialStubbing());
-
-        containerStubOnly.addAnswer(new ReturnsEmptyValues(), null);
-        assertFalse(containerStubOnly.hasInvocationForPotentialStubbing());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java b/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
deleted file mode 100644
index 488c1fcbc2..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.within;
-
-import java.util.Date;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.invocation.InvocationBuilder;
-
-public class AnswersWithDelayTest {
-    @Test
-    public void should_return_value() throws Throwable {
-        assertThat(new AnswersWithDelay(1, new Returns("value")).answer(new InvocationBuilder().method("oneArg").arg("A").toInvocation())).isEqualTo("value");
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_when_contained_answer_should_fail() throws Throwable {
-        new AnswersWithDelay(1, new Returns("one")).validateFor(new InvocationBuilder().method("voidMethod").toInvocation());
-    }
-
-    @Test
-    public void should_succeed_when_contained_answer_should_succeed() throws Throwable {
-        new AnswersWithDelay(1, new Returns("one")).validateFor(new InvocationBuilder().simpleMethod().toInvocation());
-    }
-
-    @Test
-    public void should_delay() throws Throwable {
-        final long sleepyTime = 500L;
-
-        final AnswersWithDelay testSubject = new AnswersWithDelay(sleepyTime, new Returns("value"));
-
-        final Date before = new Date();
-        testSubject.answer(new InvocationBuilder().method("oneArg").arg("A").toInvocation());
-        final Date after = new Date();
-
-        final long timePassed = after.getTime() - before.getTime();
-        assertThat(timePassed).isCloseTo(sleepyTime, within(15L));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java b/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
deleted file mode 100644
index 5f5f84d8d2..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.RETURNS_DEFAULTS;
-import static org.mockito.Mockito.mock;
-
-import java.util.ArrayList;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.MockitoCore;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.invocation.Invocation;
-
-public class CallsRealMethodsTest {
-
-    @Test
-    public void should_delegate_to_returns_default_when_abstract_method() throws Throwable {
-        Invocation abstractMethod = new InvocationBuilder().method("booleanReturningMethod").toInvocation();
-        assertThat(new CallsRealMethods().answer(abstractMethod)).isEqualTo(RETURNS_DEFAULTS.answer(abstractMethod));
-    }
-
-    @Test
-    public void should_fail_when_calling_real_method_on_interface() throws Throwable {
-        //given
-        Invocation invocationOnInterface = new InvocationBuilder().method("simpleMethod").toInvocation();
-        try {
-            //when
-            new CallsRealMethods().validateFor(invocationOnInterface);
-            //then
-            Assertions.fail("can not invoke interface");
-        } catch (MockitoException expected) {}
-    }
-
-    @Test
-    public void should_be_OK_when_calling_real_method_on_concrete_class() throws Throwable {
-        //given
-        ArrayList<?> mock = mock(ArrayList.class);
-        mock.clear();
-        Invocation invocationOnClass = new MockitoCore().getLastInvocation();
-        //when
-        new CallsRealMethods().validateFor(invocationOnClass);
-        //then no exception is thrown
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java b/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
deleted file mode 100644
index cdfb8a5ac0..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
-import org.junit.Test;
-import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
-import org.mockito.internal.invocation.InvocationBuilder;
-
-public class DefaultAnswerValidatorTest {
-
-    @Test
-    public void should_fail_if_returned_value_of_answer_is_incompatible_with_return_type() throws Throwable {
-        // given
-        class AWrongType {
-        }
-        try {
-            // when
-            DefaultAnswerValidator.validateReturnValueFor(new InvocationBuilder().method("toString").toInvocation(),
-                                                          new AWrongType());
-            fail("expected validation to fail");
-        } catch (WrongTypeOfReturnValue e) {
-            // then
-            assertThat(e.getMessage())
-                    .containsIgnoringCase("Default answer returned a result with the wrong type")
-                    .containsIgnoringCase("AWrongType cannot be returned by toString()")
-                    .containsIgnoringCase("toString() should return String");
-        }
-    }
-
-    @Test
-    public void should_not_fail_if_returned_value_of_answer_is_null() throws Throwable {
-        DefaultAnswerValidator.validateReturnValueFor(new InvocationBuilder().method("toString").toInvocation(),
-                                                      null);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java b/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
deleted file mode 100644
index b03898b6c9..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.mock;
-import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
-import static org.mockitoutil.TestBase.getLastInvocation;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-
-public class DoesNothingTest   {
-
-    private IMethods mock;
-    private Invocation invocation_Void;
-    private Invocation invocation_void;
-    private Invocation invocation_String;
-
-    @Before
-    public void init(){
-        mock = mock(IMethods.class);
-
-        mock.voidMethod();
-        invocation_Void = getLastInvocation();
-
-        mock.voidReturningMethod();
-        invocation_void = getLastInvocation();
-
-        mock.simpleMethod();
-        invocation_String = getLastInvocation();
-    }
-
-    @Test
-    public void answer_returnsNull() throws Throwable {
-        assertThat(doesNothing().answer(invocation_Void)).isNull();
-        assertThat(doesNothing().answer(invocation_void)).isNull();
-        assertThat(doesNothing().answer(invocation_String)).isNull();
-    }
-
-    @Test(expected = MockitoException.class)
-    public void validateFor_nonVoidReturnType_shouldFail()   {
-        doesNothing().validateFor(invocation_String);
-    }
-
-    @Test
-    public void validateFor_voidReturnType_shouldPass()   {
-        doesNothing().validateFor(invocation_void);
-    }
-
-    @Test
-    public void validateFor_voidObjectReturnType() throws Throwable {
-        doesNothing().validateFor(invocation_Void);
-    }
-
-    @Test
-    public void answer_returns_null_for_generic_parameter() {
-        SubclassWithGenericParameter mock = mock(SubclassWithGenericParameter.class);
-        doNothing().when(mock).methodReturningT();
-    }
-
-    static class SuperClassWithGenericParameter<T> {
-        T methodReturningT() {
-            return null;
-        }
-    }
-    static class SubclassWithGenericParameter extends SuperClassWithGenericParameter<Void> {}
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java b/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
deleted file mode 100644
index af193f27c3..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockitoutil.TestBase.getLastInvocation;
-
-import java.lang.reflect.Method;
-import java.nio.charset.CharacterCodingException;
-
-import org.junit.Test;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-
-public class InvocationInfoTest {
-
-    @Test
-    public void should_know_valid_throwables() throws Exception {
-        //when
-        Invocation invocation = new InvocationBuilder().method("canThrowException").toInvocation();
-        InvocationInfo info = new InvocationInfo(invocation);
-
-        //then
-        assertThat(info.isValidException(new Exception())).isFalse();
-        assertThat(info.isValidException(new CharacterCodingException())).isTrue();
-    }
-
-    @Test
-    public void should_know_valid_return_types() throws Exception {
-        assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isValidReturnType(Integer.class)).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isValidReturnType(int.class)).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).isValidReturnType(Integer.class)).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).isValidReturnType(int.class)).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isValidReturnType(String.class)).isFalse();
-    }
-
-    @Test
-    public void should_know_when_invocation_returns_primitive() {
-        assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).returnsPrimitive()).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).returnsPrimitive()).isFalse();
-    }
-
-    @Test
-    public void should_know_when_invocation_returns_void() {
-        assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).isVoid()).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isVoid()).isFalse();
-    }
-
-    @Test
-    public void should_read_the_method_name() {
-        assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).getMethodName()).isEqualTo("voidMethod");
-    }
-
-    @Test
-    public void should_read_the_method_return_name() {
-        assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).printMethodReturnType()).isEqualTo("void");
-        assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).printMethodReturnType()).isEqualTo("Integer");
-        assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).printMethodReturnType()).isEqualTo("int");
-    }
-
-    @Test
-    public void should_know_abstract_method() throws Exception { // To be extended with Java 8
-        assertThat(new InvocationInfo(new InvocationBuilder().method(iAmAbstract()).toInvocation()).isAbstract()).isTrue();
-        assertThat(new InvocationInfo(new InvocationBuilder().method(iAmNotAbstract()).toInvocation()).isAbstract()).isFalse();
-    }
-
-    @Test
-    public void should_know_method_is_declared_on_interface() throws Exception {
-        assertThat(new InvocationInfo(new InvocationBuilder().method(iAmAbstract()).toInvocation()).isDeclaredOnInterface()).isFalse();
-        assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).isDeclaredOnInterface()).isTrue();
-    }
-
-    @Test
-    public void isVoid_invocationOnVoidMethod_returnTrue(){
-        mock(IMethods.class).voidMethod();
-
-        InvocationInfo voidMethod = new InvocationInfo(getLastInvocation());
-
-        assertThat(voidMethod.isVoid()).isTrue();
-    }
-
-    @Test
-    public void isVoid_invocationOnVoidReturningMethod_returnTrue(){
-        mock(IMethods.class).voidReturningMethod();
-
-        InvocationInfo voidRetuningMethod = new InvocationInfo(getLastInvocation());
-
-        assertThat(voidRetuningMethod.isVoid()).isTrue();
-    }
-
-    @Test
-    public void isVoid_invocationNonVoidMethod_returnFalse(){
-        mock(IMethods.class).simpleMethod();
-
-        InvocationInfo stringReturningMethod = new InvocationInfo(getLastInvocation());
-
-        assertThat(stringReturningMethod.isVoid()).isFalse();
-    }
-
-    private Method iAmAbstract() throws NoSuchMethodException {
-        abstract class TheAbstract {
-            abstract void iAmAbstract();
-        }
-        return TheAbstract.class.getDeclaredMethod("iAmAbstract");
-    }
-
-    private Method iAmNotAbstract() throws NoSuchMethodException {
-        abstract class TheNotAbstract {
-            void iAmNotAbstract() {}
-        }
-        return TheNotAbstract.class.getDeclaredMethod("iAmNotAbstract");
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
deleted file mode 100644
index 5675a3c9d8..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationOnMock;
-
-public class ReturnsArgumentAtTest {
-    @Test
-    public void should_be_able_to_return_the_first_parameter() throws Throwable {
-        assertThat(new ReturnsArgumentAt(0).answer(invocationWith("A", "B"))).isEqualTo("A");
-    }
-
-    @Test
-    public void should_be_able_to_return_the_second_parameter()
-            throws Throwable {
-        assertThat(new ReturnsArgumentAt(1).answer(invocationWith("A", "B", "C"))).isEqualTo("B");
-    }
-
-    @Test
-    public void should_be_able_to_return_the_last_parameter() throws Throwable {
-        assertThat(new ReturnsArgumentAt(-1).answer(invocationWith("A"))).isEqualTo("A");
-        assertThat(new ReturnsArgumentAt(-1).answer(invocationWith("A", "B"))).isEqualTo("B");
-    }
-
-    @Test
-    public void should_be_able_to_return_the_specified_parameter() throws Throwable {
-        assertThat(new ReturnsArgumentAt(0).answer(invocationWith("A", "B", "C"))).isEqualTo("A");
-        assertThat(new ReturnsArgumentAt(1).answer(invocationWith("A", "B", "C"))).isEqualTo("B");
-        assertThat(new ReturnsArgumentAt(2).answer(invocationWith("A", "B", "C"))).isEqualTo("C");
-    }
-
-    @Test
-    public void should_identify_bad_parameter_type_for_invocation() throws Exception {
-        try {
-            new ReturnsArgumentAt(1).validateFor(new InvocationBuilder().method("varargsReturningString")
-                                                                        .argTypes(Object[].class)
-                                                                        .args(new Object(), new Object(), new Object())
-                                                                        .toInvocation());
-            Assertions.fail("should scream");
-        } catch (WrongTypeOfReturnValue ignored) { }
-        try {
-            new ReturnsArgumentAt(0).validateFor(new InvocationBuilder().method("oneArray")
-                                                                        .argTypes(boolean[].class)
-                                                                        .args(true, false, false)
-                                                                        .toInvocation());
-            Assertions.fail("should scream");
-        } catch (WrongTypeOfReturnValue ignored) { }
-        try {
-            new ReturnsArgumentAt(0).validateFor(new InvocationBuilder().method("mixedVarargsReturningString")
-                                                                        .argTypes(Object.class, String[].class)
-                                                                        .args(new Object(), new String[]{"A", "B", "C"})
-                                                                        .toInvocation());
-            Assertions.fail("should scream");
-        } catch (WrongTypeOfReturnValue ignored) { }
-    }
-
-    @Test
-    public void should_not_scream_when_mixed_vararg_parameter_is_compatible_with_invocation() throws Exception {
-        new ReturnsArgumentAt(1).validateFor(new InvocationBuilder().method("mixedVarargsReturningString")
-                                                                    .argTypes(Object.class, String[].class)
-                                                                    .args(new Object(), new String[]{"A", "B", "C"})
-                                                                    .toInvocation());
-    }
-
-        @Test
-    public void should_handle_returning_vararg_as_array() throws Throwable {
-        Invocation mixedVarargsReturningStringArray = new InvocationBuilder().method("mixedVarargsReturningStringArray")
-                                                                             .argTypes(Object.class, String[].class)
-                                                                             .args(new Object(), new String[]{"A", "B", "C"})
-                                                                             .toInvocation();
-        new ReturnsArgumentAt(1).validateFor(mixedVarargsReturningStringArray);
-        assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningStringArray)).isEqualTo(new String[]{"A", "B", "C"});
-
-        Invocation mixedVarargsReturningObjectArray = new InvocationBuilder().method("mixedVarargsReturningStringArray")
-                                                                             .argTypes(Object.class, String[].class)
-                                                                             .args(new Object(), new String[]{"A", "B", "C"})
-                                                                             .toInvocation();
-        new ReturnsArgumentAt(1).validateFor(mixedVarargsReturningObjectArray);
-        assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningObjectArray)).isEqualTo(new String[]{"A", "B", "C"});
-    }
-
-    @Test
-    public void should_raise_an_exception_if_index_is_not_in_allowed_range_at_creation_time() throws Throwable {
-        try {
-            new ReturnsArgumentAt(-30);
-            fail();
-        } catch (Exception e) {
-            assertThat(e.getMessage()).containsIgnoringCase("argument index")
-                                      .containsIgnoringCase("positive number")
-                                      .contains("1")
-                                      .containsIgnoringCase("last argument");
-        }
-    }
-
-    @Test
-    public void should_allow_possible_argument_types() throws Exception {
-        new ReturnsArgumentAt(0).validateFor(
-                new InvocationBuilder().method("intArgumentReturningInt")
-                                       .argTypes(int.class)
-                                       .arg(1000)
-                                       .toInvocation()
-        );
-        new ReturnsArgumentAt(0).validateFor(
-                new InvocationBuilder().method("toString")
-                                       .argTypes(String.class)
-                                       .arg("whatever")
-                                       .toInvocation()
-        );
-        new ReturnsArgumentAt(2).validateFor(
-                new InvocationBuilder().method("varargsObject")
-                                       .argTypes(int.class, Object[].class)
-                                       .args(1000, "Object", "Object")
-                                       .toInvocation()
-        );
-        new ReturnsArgumentAt(1).validateFor(
-                new InvocationBuilder().method("threeArgumentMethod")
-                                       .argTypes(int.class, Object.class, String.class)
-                                       .args(1000, "Object", "String")
-                                       .toInvocation()
-        );
-    }
-
-    @Test
-    public void should_fail_if_index_is_not_in_range_for_one_arg_invocation() throws Throwable {
-        try {
-            new ReturnsArgumentAt(30).validateFor(new InvocationBuilder().method("oneArg")
-                                                                         .arg("A")
-                                                                         .toInvocation());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage())
-                    .containsIgnoringCase("invalid argument index")
-                    .containsIgnoringCase("iMethods.oneArg")
-                    .containsIgnoringCase("[0] String")
-                    .containsIgnoringCase("position")
-                    .contains("30");
-        }
-    }
-
-    @Test
-    public void should_fail_if_index_is_not_in_range_for_example_with_no_arg_invocation() throws Throwable {
-        try {
-            new ReturnsArgumentAt(ReturnsArgumentAt.LAST_ARGUMENT).validateFor(
-                    new InvocationBuilder().simpleMethod().toInvocation()
-            );
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage())
-                    .containsIgnoringCase("invalid argument index")
-                    .containsIgnoringCase("iMethods.simpleMethod")
-                    .containsIgnoringCase("no arguments")
-                    .containsIgnoringCase("last parameter wanted");
-        }
-    }
-
-    @Test
-    public void should_fail_if_argument_type_of_signature_is_incompatible_with_return_type() throws Throwable {
-        try {
-            new ReturnsArgumentAt(2).validateFor(
-                    new InvocationBuilder().method("varargsReturningString")
-                                           .argTypes(Object[].class)
-                                           .args("anyString", new Object(), "anyString")
-                                           .toInvocation()
-            );
-            fail();
-        } catch (WrongTypeOfReturnValue e) {
-            assertThat(e.getMessage())
-                    .containsIgnoringCase("argument of type")
-                    .containsIgnoringCase("Object")
-                    .containsIgnoringCase("varargsReturningString")
-                    .containsIgnoringCase("should return")
-                    .containsIgnoringCase("String")
-                    .containsIgnoringCase("possible argument indexes");
-        }
-    }
-
-    @Test
-    public void shouldNotFailWhenArgumentIsGenericAndCompatibleWithReturnType() throws Exception {
-        new ReturnsArgumentAt(0 ).validateFor(
-                new InvocationBuilder().method("genericToString")
-                                       .argTypes(Object.class)
-                                       .args("anyString")
-                                       .toInvocation()
-        );
-    }
-
-
-    private static InvocationOnMock invocationWith(Object... parameters) {
-        return new InvocationBuilder().method("varargsReturningString")
-                                      .argTypes(Object[].class)
-                                      .args(new Object[] { parameters }).toInvocation(); // one vararg param (sic!)
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
deleted file mode 100644
index 5ec625946e..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static java.lang.Boolean.TRUE;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.invocation.InvocationBuilder;
-
-public class ReturnsTest {
-    @Test
-    public void should_return_value() throws Throwable {
-        assertThat(new Returns("value").answer(new InvocationBuilder().method("oneArg").arg("A").toInvocation())).isEqualTo("value");
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_when_return_Value_is_set_for_void_method() throws Throwable {
-        new Returns("one").validateFor(new InvocationBuilder().method("voidMethod").toInvocation());
-    }
-
-    @Test
-    public void should_allow_correct_type_of_return_value() throws Throwable {
-        new Returns("one").validateFor(new InvocationBuilder().simpleMethod().toInvocation());
-        new Returns(false).validateFor(new InvocationBuilder().method("booleanReturningMethod").toInvocation());
-        new Returns(TRUE).validateFor(new InvocationBuilder().method("booleanObjectReturningMethod").toInvocation());
-        new Returns(1).validateFor(new InvocationBuilder().method("integerReturningMethod").toInvocation());
-        new Returns(1L).validateFor(new InvocationBuilder().method("longReturningMethod").toInvocation());
-        new Returns(1L).validateFor(new InvocationBuilder().method("longObjectReturningMethod").toInvocation());
-        new Returns(null).validateFor(new InvocationBuilder().method("objectReturningMethodNoArgs").toInvocation());
-        new Returns(1).validateFor(new InvocationBuilder().method("objectReturningMethodNoArgs").toInvocation());
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_on_return_type_mismatch() throws Throwable {
-        new Returns("String").validateFor(new InvocationBuilder().method("booleanReturningMethod").toInvocation());
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_on_wrong_primitive() throws Throwable {
-        new Returns(1).validateFor(new InvocationBuilder().method("doubleReturningMethod").toInvocation());
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_on_null_with_primitive() throws Throwable {
-        new Returns(null).validateFor(new InvocationBuilder().method("booleanReturningMethod").toInvocation());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
deleted file mode 100644
index 6940244997..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.answers;
-
-import static junit.framework.TestCase.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
-import java.io.IOException;
-import java.nio.charset.CharacterCodingException;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.invocation.Invocation;
-
-
-public class ThrowsExceptionTest {
-    @Test
-    public void should_raise_wanted_throwable() throws Throwable {
-        try {
-            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");
-        }
-    }
-
-    @Test
-    public void should_throw_mock_exception_without_stacktrace() throws Exception {
-        try {
-            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();
-        }
-    }
-
-    @Test
-    public void should_fill_in_exception_stacktrace() throws Exception {
-        // given
-        Exception throwableToRaise = new Exception();
-        throwableToRaise.fillInStackTrace();
-        assertThat(throwableToRaise.getStackTrace()[0].getClassName()).isEqualTo(this.getClass().getName());
-        assertThat(throwableToRaise.getStackTrace()[0].getMethodName()).isEqualTo("should_fill_in_exception_stacktrace");
-        try {
-
-            // when
-            new ThrowsException(throwableToRaise).answer(createMethodInvocation());
-            Assertions.fail("should have raised wanted exception");
-        } catch (Throwable throwable) {
-            // then
-            throwable.printStackTrace();
-            assertThat(throwableToRaise.getStackTrace()[0].getClassName()).isEqualTo(ThrowsException.class.getName());
-            assertThat(throwableToRaise.getStackTrace()[0].getMethodName()).isEqualTo("answer");
-        }
-    }
-
-    @Test
-    public void should_invalidate_null_throwable() throws Throwable {
-        try {
-            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(createMethodInvocation());
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_invalid_checked_exception() throws Throwable {
-        new ThrowsException(new IOException()).validateFor(createMethodInvocation());
-    }
-
-    @Test
-    public void should_pass_RuntimeExceptions() throws Throwable {
-        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/ReturnsGenericDeepStubsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
deleted file mode 100644
index 1d5b5f4f61..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.io.Closeable;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.Callable;
-
-import org.junit.Test;
-import org.mockitousage.examples.use.Article;
-
-@SuppressWarnings("unused")
-public class ReturnsGenericDeepStubsTest {
-    interface ListOfInteger extends List<Integer> {
-    }
-
-    interface AnotherListOfInteger extends ListOfInteger {
-    }
-
-    interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {
-        Set<Number> remove(Object key); // override with fixed ParameterizedType
-
-        List<? super Number> returningWildcard();
-
-        Map<String, K> returningNonMockableNestedGeneric();
-
-        K returningK();
-
-        <O extends K> List<O> paramTypeWithTypeParams();
-
-        <S extends Appendable, T extends S> T twoTypeParams(S s);
-
-        <O extends K> O typeVarWithTypeParams();
-
-        Number returnsNormalType();
-    }
-
-    @Test
-    public void generic_deep_mock_frenzy__look_at_these_chained_calls() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        Set<? extends Map.Entry<? extends Cloneable, Set<Number>>> entries = mock.entrySet();
-        Iterator<? extends Map.Entry<? extends Cloneable, Set<Number>>> entriesIterator = mock.entrySet().iterator();
-        Map.Entry<? extends Cloneable, Set<Number>> nextEntry = mock.entrySet().iterator().next();
-
-        Cloneable cloneableKey = mock.entrySet().iterator().next().getKey();
-        Comparable<?> comparableKey = mock.entrySet().iterator().next().getKey();
-
-        Set<Number> value = mock.entrySet().iterator().next().getValue();
-        Iterator<Number> numbersIterator = mock.entrySet().iterator().next().getValue().iterator();
-        Number number = mock.entrySet().iterator().next().getValue().iterator().next();
-    }
-
-    @Test
-    public void can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_parameterizedType_that_is_referencing_a_typeVar_on_class() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        Cloneable cloneable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
-            mock.paramTypeWithTypeParams().get(0);
-        Comparable<?> comparable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
-            mock.paramTypeWithTypeParams().get(0);
-    }
-
-    @Test
-    public void can_create_mock_from_multiple_type_variable_bounds_when_method_return_type_is_referencing_a_typeVar_on_class() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        Cloneable cloneable_bound_of_typevar_K = mock.returningK();
-        Comparable<?> comparable_bound_of_typevar_K = mock.returningK();
-    }
-
-    @Test
-    public void can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_typeVar_that_is_referencing_a_typeVar_on_class() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        Cloneable cloneable_bound_of_typevar_K_referenced_by_typevar_O = (Cloneable) mock.typeVarWithTypeParams();
-        Comparable<?> comparable_bound_of_typevar_K_referenced_by_typevar_O = (Comparable<?>) mock.typeVarWithTypeParams();
-    }
-
-    @Test
-    public void can_create_mock_from_return_types_declared_with_a_bounded_wildcard() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        List<? super Integer> objects = mock.returningWildcard();
-        Number type_that_is_the_upper_bound_of_the_wildcard = (Number) mock.returningWildcard().get(45);
-        type_that_is_the_upper_bound_of_the_wildcard.floatValue();
-    }
-
-    @Test
-    public void can_still_work_with_raw_type_in_the_return_type() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        Number the_raw_type_that_should_be_returned = mock.returnsNormalType();
-        the_raw_type_that_should_be_returned.floatValue();
-    }
-
-    @Test
-    public void will_return_default_value_on_non_mockable_nested_generic() {
-        GenericsNest<?> genericsNest = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-        ListOfInteger listOfInteger = mock(ListOfInteger.class, RETURNS_DEEP_STUBS);
-        AnotherListOfInteger anotherListOfInteger = mock(AnotherListOfInteger.class, RETURNS_DEEP_STUBS);
-
-        assertThat(genericsNest.returningNonMockableNestedGeneric().keySet().iterator().next()).isNull();
-        assertThat(listOfInteger.get(25)).isEqualTo(0);
-        assertThat(anotherListOfInteger.get(25)).isEqualTo(0);
-    }
-
-    @Test(expected = ClassCastException.class)
-    public void as_expected_fail_with_a_CCE_on_call_site_when_erasure_takes_place_for_example___StringBuilder_is_subject_to_erasure() {
-        GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
-
-        // following assignment needed to create a ClassCastException on the call site (i.e. : here)
-        StringBuilder stringBuilder_assignment_that_should_throw_a_CCE =
-            mock.twoTypeParams(new StringBuilder()).append(2).append(3);
-    }
-
-    class WithGenerics<T> {
-        T execute() {
-            throw new IllegalArgumentException();
-        }
-    }
-
-    class SubClass<S> extends WithGenerics<S> {
-    }
-
-    class UserOfSubClass {
-        SubClass<String> generate() {
-            return null;
-        }
-    }
-
-    @Test
-    public void can_handle_deep_stubs_with_generics_at_end_of_deep_invocation() {
-        UserOfSubClass mock = mock(UserOfSubClass.class, RETURNS_DEEP_STUBS);
-
-        when(mock.generate().execute()).thenReturn("sub");
-
-        assertThat(mock.generate().execute()).isEqualTo("sub");
-    }
-
-    public interface TopInterface<T> {
-        T generic();
-    }
-
-    public interface MiddleInterface<T> extends TopInterface<T> {
-    }
-
-    public class OwningClassWithDeclaredUpperBounds<T extends Iterable<Article> & Callable<Article> & Closeable> {
-        public abstract class AbstractInner implements MiddleInterface<T> {
-        }
-    }
-
-    @Test
-    public void cannot_handle_deep_stubs_with_generics_declared_upper_bounds_at_end_of_deep_invocation() throws Exception {
-        OwningClassWithDeclaredUpperBounds.AbstractInner mock =
-            mock(OwningClassWithDeclaredUpperBounds.AbstractInner.class, RETURNS_DEEP_STUBS);
-
-        // It seems that while the syntax used on OwningClassWithDeclaredUpperBounds.AbstractInner
-        // appear to be legal, the javac compiler does not follow through
-        // hence we need casting, this may also explain why GenericMetadataSupport has trouble to
-        // extract matching data as well.
-
-        assertThat(mock.generic())
-            .describedAs("mock should implement first bound : 'Iterable'")
-            .isInstanceOf(Iterable.class);
-        assertThat(((Iterable<Article>) mock.generic()).iterator())
-            .describedAs("Iterable returns Iterator").isInstanceOf(Iterator.class);
-        assertThat(((Iterable<Article>) mock.generic()).iterator().next())
-            .describedAs("Cannot yet extract Type argument 'Article' so return null instead of a mock "
-                         + "of type Object (which would raise CCE on the call-site)")
-            .isNull();
-
-        assertThat(mock.generic())
-            .describedAs("mock should implement second interface bound : 'Callable'")
-            .isInstanceOf(Callable.class);
-        assertThat(((Callable<Article>) mock.generic()).call())
-            .describedAs("Cannot yet extract Type argument 'Article' so return null instead of a mock "
-                         + "of type Object (which would raise CCE on the call-site)")
-            .isNull();
-
-        assertThat(mock.generic())
-            .describedAs("mock should implement third interface bound : 'Closeable'")
-            .isInstanceOf(Closeable.class);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
deleted file mode 100644
index 1cb0ac7245..0000000000
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.stubbing.defaultanswers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Test;
-import org.mockito.exceptions.verification.SmartNullPointerException;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.invocation.InterceptedInvocation;
-import org.mockito.internal.invocation.SerializableMethod;
-import org.mockito.internal.invocation.mockref.MockStrongReference;
-import org.mockito.stubbing.Answer;
-import org.mockitoutil.TestBase;
-
-public class ReturnsSmartNullsTest extends TestBase {
-
-    @Test
-    public void should_return_the_usual_default_values_for_primitives() throws Throwable {
-        Answer<Object> answer = new ReturnsSmartNulls();
-        assertEquals(false  ,   answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
-        assertEquals((char) 0,  answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
-        assertEquals((byte) 0,  answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
-        assertEquals((short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
-        assertEquals(0,         answer.answer(invocationOf(HasPrimitiveMethods.class, "intMethod")));
-        assertEquals(0L,        answer.answer(invocationOf(HasPrimitiveMethods.class, "longMethod")));
-        assertEquals(0f,        answer.answer(invocationOf(HasPrimitiveMethods.class, "floatMethod")));
-        assertEquals(0d,        answer.answer(invocationOf(HasPrimitiveMethods.class, "doubleMethod")));
-    }
-
-    @SuppressWarnings("unused")
-    interface Foo {
-        Foo get();
-        Foo withArgs(String oneArg, String otherArg);
-    }
-
-    @Test
-    public void should_return_an_object_that_fails_on_any_method_invocation_for_non_primitives() throws Throwable {
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "get"));
-
-        try {
-            smartNull.get();
-            fail();
-        } catch (SmartNullPointerException expected) {}
-    }
-
-    @Test
-    public void should_return_an_object_that_allows_object_methods() throws Throwable {
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "get"));
-
-        assertThat(smartNull.toString())
-            .contains("SmartNull returned by")
-            .contains("foo.get()");
-    }
-
-    @Test
-    public void should_print_the_parameters_when_calling_a_method_with_args() throws Throwable {
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "withArgs", "oompa", "lumpa"));
-
-        assertThat(smartNull.toString())
-            .contains("foo.withArgs")
-            .contains("oompa")
-            .contains("lumpa");
-    }
-
-    @Test
-    public void should_print_the_parameters_on_SmartNullPointerException_message() throws Throwable {
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "withArgs", "oompa", "lumpa"));
-
-        try {
-            smartNull.get();
-            fail();
-        } catch (SmartNullPointerException e) {
-            assertThat(e)
-                .hasMessageContaining("oompa")
-                .hasMessageContaining("lumpa");
-        }
-    }
-
-    interface GenericFoo<T> {
-        T get();
-    }
-
-    interface GenericFooBar extends GenericFoo<Foo> {
-        <I> I method();
-        <I> I methodWithArgs(int firstArg, I secondArg);
-        <I> I methodWithVarArgs(int firstArg, I... secondArg);
-    }
-
-    @Test
-    public void should_return_an_object_that_has_been_defined_with_class_generic() throws Throwable {
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Foo smartNull = (Foo) answer.answer(invocationOf(GenericFooBar.class, "get"));
-
-        assertThat(smartNull.toString())
-            .contains("SmartNull returned by")
-            .contains("genericFooBar.get()");
-    }
-
-    @Test
-    public void should_return_an_object_that_has_been_defined_with_method_generic() throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        String smartNull = (String) answer.answer(invocationOf(GenericFooBar.class, "method"));
-
-        assertThat(smartNull)
-            .isNull();
-    }
-
-    private static <T> InterceptedInvocation invocationMethodWithArgs(final T obj) throws NoSuchMethodException {
-        return new InterceptedInvocation(
-            new MockStrongReference<Object>(mock(GenericFooBar.class), false),
-            new SerializableMethod(GenericFooBar.class.getMethod("methodWithArgs", int.class, Object.class)),
-            new Object[]{1, obj},
-            InterceptedInvocation.NO_OP,
-            new LocationImpl(),
-            1);
-    }
-
-    @Test
-    public void should_return_a_String_that_has_been_defined_with_method_generic_and_provided_in_argument() throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithArgs("secondArg"));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(String.class)
-            .asString()
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_empty_list_that_has_been_defined_with_method_generic_and_provided_in_argument() throws Throwable {
-
-        final List<String> list = Collections.singletonList("String");
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithArgs(list));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(List.class);
-        assertThat((List) smartNull)
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_empty_map_that_has_been_defined_with_method_generic_and_provided_in_argument() throws Throwable {
-
-        final Map<String, String> map = new HashMap<String, String>();
-        map.put("key-1", "value-1");
-        map.put("key-2", "value-2");
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithArgs(map));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(Map.class);
-        assertThat((Map) smartNull)
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_empty_set_that_has_been_defined_with_method_generic_and_provided_in_argument() throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull =
-            answer.answer(invocationMethodWithArgs(new HashSet<String>(Arrays.asList("set-1", "set-2"))));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(Set.class);
-        assertThat((Set) smartNull)
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_new_mock_that_has_been_defined_with_method_generic_and_provided_in_argument() throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-        final Foo mock = mock(Foo.class);
-
-        Object smartNull = answer.answer(invocationMethodWithArgs(mock));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isNotSameAs(mock);
-        assertThat(smartNull.toString())
-            .contains("SmartNull returned by")
-            .contains("genericFooBar.methodWithArgs(");
-    }
-
-    @Test
-    public void should_return_an_Object_that_has_been_defined_with_method_generic_and_provided_in_argument() throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithArgs(new Object() {
-        }));
-
-        assertThat(smartNull.toString())
-            .contains("SmartNull returned by")
-            .contains("genericFooBar.methodWithArgs(");
-    }
-
-    @Test
-    public void should_throw_a_error_on_invocation_of_returned_mock() throws Throwable {
-
-        final Answer<Object> answer = new ReturnsSmartNulls();
-        final Foo mock = mock(Foo.class);
-
-        final Throwable throwable = Assertions.catchThrowable(new ThrowableAssert.ThrowingCallable() {
-            @Override
-            public void call() throws Throwable {
-                ((Foo) answer.answer(invocationMethodWithArgs(mock))).get();
-            }
-        });
-
-        Assertions.assertThat(throwable)
-            .isInstanceOf(SmartNullPointerException.class)
-            .hasMessageContaining("genericFooBar.methodWithArgs(")
-            .hasMessageContaining("1")
-            .hasMessageContaining(mock.toString());
-    }
-
-    private static <T> InterceptedInvocation invocationMethodWithVarArgs(final T[] obj) throws NoSuchMethodException {
-        return new InterceptedInvocation(
-            new MockStrongReference<Object>(mock(GenericFooBar.class), false),
-            new SerializableMethod(GenericFooBar.class.getMethod("methodWithVarArgs", int.class, Object[].class)),
-            new Object[]{1, obj},
-            InterceptedInvocation.NO_OP,
-            new LocationImpl(),
-            1);
-    }
-
-    @Test
-    public void should_return_a_String_that_has_been_defined_with_method_generic_and_provided_in_var_args()
-        throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithVarArgs(new String[]{"varArg-1", "varArg-2"}));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(String.class)
-            .asString()
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_empty_list_that_has_been_defined_with_method_generic_and_provided_in_var_args()
-        throws Throwable {
-
-        final List<String> arg1 = Collections.singletonList("String");
-        final List<String> arg2 = Arrays.asList("str-1", "str-2");
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithVarArgs(new List[]{arg1, arg2}));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(List.class);
-        assertThat((List) smartNull)
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_empty_map_that_has_been_defined_with_method_generic_and_provided_in_var_args()
-        throws Throwable {
-
-        final Map<String, String> map1 = new HashMap<String, String>() {{
-            put("key-1", "value-1");
-            put("key-2", "value-2");
-        }};
-        final Map<String, String> map2 = new HashMap<String, String>() {{
-            put("key-3", "value-1");
-            put("key-4", "value-2");
-        }};
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithVarArgs(new Map[]{map1, map2}));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(Map.class);
-        assertThat((Map) smartNull)
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_empty_set_that_has_been_defined_with_method_generic_and_provided_in_var_args()
-        throws Throwable {
-
-        final HashSet<String> set1 = new HashSet<String>(Arrays.asList("set-1", "set-2"));
-        final HashSet<String> set2 = new HashSet<String>(Arrays.asList("set-1", "set-2"));
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull =
-            answer.answer(invocationMethodWithVarArgs(new HashSet[]{set1, set2}));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isInstanceOf(Set.class);
-        assertThat((Set) smartNull)
-            .isEmpty();
-    }
-
-    @Test
-    public void should_return_a_new_mock_that_has_been_defined_with_method_generic_and_provided_in_var_args()
-        throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-        final Foo mock1 = mock(Foo.class);
-        final Foo mock2 = mock(Foo.class);
-
-        Object smartNull = answer.answer(invocationMethodWithVarArgs(new Foo[]{mock1, mock2}));
-
-        assertThat(smartNull)
-            .isNotNull()
-            .isNotSameAs(mock1)
-            .isNotSameAs(mock2);
-        assertThat(smartNull.toString())
-            .contains("SmartNull returned by")
-            .contains("genericFooBar.methodWithVarArgs(");
-    }
-
-    @Test
-    public void should_return_an_Object_that_has_been_defined_with_method_generic_and_provided_in_var_args()
-        throws Throwable {
-
-        Answer<Object> answer = new ReturnsSmartNulls();
-
-        Object smartNull = answer.answer(invocationMethodWithVarArgs(new Object[]{new Object() {
-        }, new Object() {
-        }}));
-
-        assertThat(smartNull.toString())
-            .contains("SmartNull returned by")
-            .contains("genericFooBar.methodWithVarArgs(");
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/util/ChecksTest.java b/src/test/java/org/mockito/internal/util/ChecksTest.java
deleted file mode 100644
index 3245b2f0ab..0000000000
--- a/src/test/java/org/mockito/internal/util/ChecksTest.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-public class ChecksTest {
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
-    @Test
-    public void checkNotNull_not_null() throws Exception {
-        assertEquals("abc", Checks.checkNotNull("abc", "someValue"));
-    }
-
-    @Test
-    public void checkNotNull_not_null_additional_message() throws Exception {
-        assertEquals("abc", Checks.checkNotNull("abc", "someValue", "Oh no!"));
-    }
-
-    @Test
-    public void checkNotNull_null() throws Exception {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("someValue should not be null");
-        Checks.checkNotNull(null, "someValue");
-    }
-
-    @Test
-    public void checkNotNull_null_additonal_message() throws Exception {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("someValue should not be null. Oh no!");
-        Checks.checkNotNull(null, "someValue", "Oh no!");
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java b/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
deleted file mode 100644
index 0861f87863..0000000000
--- a/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.stubbing.Stubbing;
-import org.mockitousage.IMethods;
-
-@SuppressWarnings("unchecked")
-public class DefaultMockingDetailsTest {
-
-    @Mock private Foo foo;
-    @Mock private Bar bar;
-    @Mock private IMethods mock;
-    @Spy private Gork gork;
-
-    @Before public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void should_provide_original_mock() throws Exception {
-        //expect
-        assertEquals(mockingDetails(foo).getMock(), foo);
-        assertEquals(mockingDetails(null).getMock(), null);
-    }
-
-    @Test
-    public void should_know_spy(){
-        assertTrue(mockingDetails(gork).isMock());
-        assertTrue(mockingDetails(spy( new Gork())).isMock());
-        assertTrue(mockingDetails(spy(Gork.class)).isMock());
-        assertTrue(mockingDetails(mock(Gork.class, withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))).isMock());
-    }
-
-    @Test
-    public void should_know_mock(){
-        assertTrue(mockingDetails(foo).isMock());
-        assertTrue(mockingDetails(mock(Foo.class)).isMock());
-        assertFalse(mockingDetails(foo).isSpy());
-        assertFalse(mockingDetails(mock(Foo.class)).isSpy());
-    }
-
-    @Test
-    public void should_handle_non_mocks() {
-        assertFalse(mockingDetails("non mock").isSpy());
-        assertFalse(mockingDetails("non mock").isMock());
-
-        assertFalse(mockingDetails(null).isSpy());
-        assertFalse(mockingDetails(null).isMock());
-    }
-
-    @Test
-    public void should_check_that_a_spy_is_also_a_mock() throws Exception {
-        assertEquals(true, mockingDetails(gork).isMock());
-    }
-
-    @Test
-    public void provides_invocations() {
-        //when
-        mock.simpleMethod(10);
-        mock.otherMethod();
-
-        //then
-        assertEquals(0, mockingDetails(foo).getInvocations().size());
-        assertEquals("[mock.simpleMethod(10);, mock.otherMethod();]", mockingDetails(mock).getInvocations().toString());
-    }
-
-    @Test
-    public void manipulating_invocations_is_safe() {
-        mock.simpleMethod();
-
-        //when we manipulate the invocations
-        mockingDetails(mock).getInvocations().clear();
-
-        //then we didn't actually changed the invocations
-        assertEquals(1, mockingDetails(mock).getInvocations().size());
-    }
-
-    @Test
-    public void provides_mock_creation_settings() {
-        //smoke test some creation settings
-        assertEquals(Foo.class, mockingDetails(foo).getMockCreationSettings().getTypeToMock());
-        assertEquals(Bar.class, mockingDetails(bar).getMockCreationSettings().getTypeToMock());
-        assertEquals(0, mockingDetails(mock).getMockCreationSettings().getExtraInterfaces().size());
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void fails_when_getting_creation_settings_for_incorrect_input() {
-        mockingDetails(null).getMockCreationSettings();
-    }
-
-    @Test
-    public void fails_when_getting_invocations_when_null() {
-        try {
-            //when
-            mockingDetails(null).getInvocations();
-            //then
-            fail();
-        } catch (NotAMockException e) {
-            assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is null!", e.getMessage());
-        }
-    }
-
-    @Test
-    public void fails_when_getting_invocations_when_not_mock() {
-        try {
-            //when
-            mockingDetails(new Object()).getInvocations();
-            //then
-            fail();
-        } catch (NotAMockException e) {
-            assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage());
-        }
-    }
-
-    @Test
-    public void fails_when_getting_stubbings_from_non_mock() {
-        try {
-            //when
-            mockingDetails(new Object()).getStubbings();
-            //then
-            fail();
-        } catch (NotAMockException e) {
-            assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage());
-        }
-    }
-
-    @Test
-    public void mock_with_no_stubbings() {
-        assertTrue(mockingDetails(mock).getStubbings().isEmpty());
-    }
-
-    @Test
-    public void provides_stubbings_of_mock_in_declaration_order() {
-        when(mock.simpleMethod(1)).thenReturn("1");
-        when(mock.otherMethod()).thenReturn("2");
-
-        //when
-        Collection<Stubbing> stubbings = mockingDetails(mock).getStubbings();
-
-        //then
-        assertEquals(2, stubbings.size());
-        assertEquals("[mock.simpleMethod(1); stubbed with: [Returns: 1], mock.otherMethod(); stubbed with: [Returns: 2]]", stubbings.toString());
-    }
-
-    @Test
-    public void manipulating_stubbings_explicitly_is_safe() {
-        when(mock.simpleMethod(1)).thenReturn("1");
-
-        //when somebody manipulates stubbings directly
-        mockingDetails(mock).getStubbings().clear();
-
-        //then it does not affect stubbings of the mock
-        assertEquals(1, mockingDetails(mock).getStubbings().size());
-    }
-
-    @Test
-    public void prints_invocations() throws Exception {
-        //given
-        given(mock.simpleMethod("different arg")).willReturn("foo");
-        mock.simpleMethod("arg");
-
-        //when
-        String log = Mockito.mockingDetails(mock).printInvocations();
-
-        //then
-        assertThat(log).containsIgnoringCase("unused");
-        assertThat(log).containsIgnoringCase("mock.simpleMethod(\"arg\")");
-        assertThat(log).containsIgnoringCase("mock.simpleMethod(\"different arg\")");
-    }
-
-    @Test
-    public void fails_when_printin_invocations_from_non_mock() {
-        try {
-            //when
-            mockingDetails(new Object()).printInvocations();
-            //then
-            fail();
-        } catch (NotAMockException e) {
-            assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage());
-        }
-    }
-
-    public class Foo { }
-    public interface Bar { }
-    public static class Gork { }
-}
diff --git a/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java b/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
deleted file mode 100644
index 1fdc7e7103..0000000000
--- a/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static java.util.Arrays.asList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-
-@SuppressWarnings("unchecked")
-public class MockCreationValidatorTest {
-
-    MockCreationValidator validator = new MockCreationValidator();
-
-    @Test
-    public void should_not_allow_extra_interface_that_is_the_same_as_the_mocked_type() throws Exception {
-        try {
-            //when
-            validator.validateExtraInterfaces(IMethods.class, (Collection) asList(IMethods.class));
-            fail();
-        } catch (MockitoException e) {
-            //then
-            assertThat(e.getMessage()).contains("You mocked following type: IMethods");
-        }
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_not_allow_inconsistent_types() throws Exception {
-        //when
-        validator.validateMockedType(List.class, new ArrayList());
-        //then
-    }
-
-    @Test
-    public void should_allow_only_consistent_types() throws Exception {
-        //when
-        validator.validateMockedType(ArrayList.class, new ArrayList());
-        //then no exception is thrown
-    }
-
-    @Test
-    public void should_validation_be_safe_when_nulls_passed() throws Exception {
-        //when
-        validator.validateMockedType(null, new ArrayList());
-        //or
-        validator.validateMockedType(ArrayList.class, null);
-        //then no exception is thrown
-    }
-
-    @Test
-    public void should_fail_when_type_not_mockable() throws Exception {
-        try {
-            validator.validateType(long.class);
-        } catch (MockitoException ex) {
-            assertThat(ex.getMessage()).contains("primitive");
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/MockNameImplTest.java b/src/test/java/org/mockito/internal/util/MockNameImplTest.java
deleted file mode 100644
index 7217eaeda4..0000000000
--- a/src/test/java/org/mockito/internal/util/MockNameImplTest.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-public class MockNameImplTest extends TestBase {
-
-    @Test
-    public void shouldProvideTheNameForClass() throws Exception {
-        //when
-        String name = new MockNameImpl(null, SomeClass.class).toString();
-        //then
-        assertEquals("someClass", name);
-    }
-
-    @Test
-    public void shouldProvideTheNameForAnonymousClass() throws Exception {
-        //given
-        SomeInterface anonymousInstance = new SomeInterface() {};
-        //when
-        String name = new MockNameImpl(null, anonymousInstance.getClass()).toString();
-        //then
-        assertEquals("someInterface", name);
-    }
-
-    @Test
-    public void shouldProvideTheGivenName() throws Exception {
-        //when
-        String name = new MockNameImpl("The Hulk", SomeClass.class).toString();
-        //then
-        assertEquals("The Hulk", name);
-    }
-
-    private class SomeClass {}
-    private class SomeInterface {}
-}
diff --git a/src/test/java/org/mockito/internal/util/MockUtilTest.java b/src/test/java/org/mockito/internal/util/MockUtilTest.java
deleted file mode 100644
index 4eef4612ce..0000000000
--- a/src/test/java/org/mockito/internal/util/MockUtilTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.withSettings;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class MockUtilTest extends TestBase {
-
-    @Test
-    public void should_get_handler() {
-        List<?> mock = Mockito.mock(List.class);
-        assertNotNull(MockUtil.getMockHandler(mock));
-    }
-
-    @Test (expected=NotAMockException.class)
-    public void should_scream_when_not_a_mock_passed() {
-        MockUtil.getMockHandler("");
-    }
-
-    @Test (expected=MockitoException.class)
-    public void should_scream_when_null_passed() {
-        MockUtil.getMockHandler(null);
-    }
-
-    @Test
-    public void should_get_mock_settings() {
-        List<?> mock = Mockito.mock(List.class);
-        assertNotNull(MockUtil.getMockSettings(mock));
-    }
-
-    @Test
-    public void should_validate_mock() {
-        assertFalse(MockUtil.isMock("i mock a mock"));
-        assertTrue(MockUtil.isMock(Mockito.mock(List.class)));
-    }
-
-    @Test
-    public void should_validate_spy() {
-        assertFalse(MockUtil.isSpy("i mock a mock"));
-        assertFalse(MockUtil.isSpy(Mockito.mock(List.class)));
-        assertFalse(MockUtil.isSpy(null));
-
-        assertTrue(MockUtil.isSpy(Mockito.spy(new ArrayList())));
-        assertTrue(MockUtil.isSpy(Mockito.spy(ArrayList.class)));
-        assertTrue(MockUtil.isSpy(Mockito.mock(ArrayList.class, withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))));
-    }
-
-    @Test
-    public void should_redefine_MockName_if_default() {
-        List<?> mock = Mockito.mock(List.class);
-        MockUtil.maybeRedefineMockName(mock, "newName");
-
-        Assertions.assertThat(MockUtil.getMockName(mock).toString()).isEqualTo("newName");
-    }
-
-    @Test
-    public void should_not_redefine_MockName_if_default() {
-        List<?> mock = Mockito.mock(List.class, "original");
-        MockUtil.maybeRedefineMockName(mock, "newName");
-
-        Assertions.assertThat(MockUtil.getMockName(mock).toString()).isEqualTo("original");
-    }
-
-    final class FinalClass {}
-    class SomeClass {}
-    interface SomeInterface {}
-
-    @Test
-    public void should_know_if_type_is_mockable() throws Exception {
-        Assertions.assertThat(MockUtil.typeMockabilityOf(FinalClass.class).mockable())
-                .isEqualTo(Plugins.getMockMaker().isTypeMockable(FinalClass.class).mockable());
-
-        assertFalse(MockUtil.typeMockabilityOf(int.class).mockable());
-
-        assertTrue(MockUtil.typeMockabilityOf(SomeClass.class).mockable());
-        assertTrue(MockUtil.typeMockabilityOf(SomeInterface.class).mockable());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java b/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
deleted file mode 100644
index 016be1f61f..0000000000
--- a/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Date;
-
-import org.junit.Test;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class ObjectMethodsGuruTest extends TestBase {
-
-
-    private interface HasCompareToButDoesNotImplementComparable {
-        int compareTo(HasCompareToButDoesNotImplementComparable other);
-    }
-
-    private interface HasCompare extends Comparable<HasCompare> {
-        int foo(HasCompare other);
-        int compareTo(HasCompare other, String redHerring);
-        int compareTo(String redHerring);
-        int compareTo(HasCompare redHerring);
-    }
-
-    @Test
-    public void shouldKnowToStringMethod() throws Exception {
-        assertFalse(ObjectMethodsGuru.isToStringMethod(Object.class.getMethod("equals", Object.class)));
-        assertFalse(ObjectMethodsGuru.isToStringMethod(IMethods.class.getMethod("toString", String.class)));
-        assertTrue(ObjectMethodsGuru.isToStringMethod(IMethods.class.getMethod("toString")));
-    }
-
-
-    @Test
-    public void shouldKnowCompareToMethod() throws Exception {
-        assertFalse(ObjectMethodsGuru.isCompareToMethod(Date.class.getMethod("toString")));
-        assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("foo", HasCompare.class)));
-        assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("compareTo", HasCompare.class, String.class)));
-        assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("compareTo", String.class)));
-        assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompareToButDoesNotImplementComparable.class.getDeclaredMethod("compareTo", HasCompareToButDoesNotImplementComparable.class)));
-
-        assertTrue(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("compareTo", HasCompare.class)));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/PlatformTest.java b/src/test/java/org/mockito/internal/util/PlatformTest.java
deleted file mode 100644
index d41a5beac4..0000000000
--- a/src/test/java/org/mockito/internal/util/PlatformTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Test;
-
-// Possible description on a IBM J9 VM (see #801)
-//
-// java.specification.version = 1.8
-// java.vm.vendor = IBM Corporation
-// java.vm.version = 2.8
-// java.vm.name = IBM J9 VM
-// java.runtime.version = pwa6480sr1fp10-20150711_01 (SR1 FP10)
-// java.vm.info =
-//   JRE 1.8.0 Windows 7 amd64-64 Compressed References 20150630_255633 (JIT enabled, AOT enabled)
-//   J9VM - R28_jvm.28_20150630_1742_B255633
-//   JIT  - tr.r14.java_20150625_95081.01
-//   GC   - R28_jvm.28_20150630_1742_B255633_CMPRSS
-//   J9CL - 20150630_255633
-// os.name = Windows 7
-// os.version = 6.1
-public class PlatformTest {
-    // TODO use ClassLoaders
-
-    @Test
-    public void const_are_initialized_from_system_properties() {
-        System.out.println(Platform.describe());
-
-        assertThat(Platform.JVM_VERSION).isEqualTo(System.getProperty("java.runtime.version"));
-        assertThat(Platform.JVM_INFO).isEqualTo(System.getProperty("java.vm.info"));
-        assertThat(Platform.JVM_NAME).isEqualTo(System.getProperty("java.vm.name"));
-        assertThat(Platform.JVM_VENDOR).isEqualTo(System.getProperty("java.vm.vendor"));
-        assertThat(Platform.JVM_VENDOR_VERSION).isEqualTo(System.getProperty("java.vm.version"));
-    }
-
-    @Test
-    public void should_warn_for_jvm() throws Exception {
-        assertThat(Platform.warnForVM("Java HotSpot(TM) 64-Bit Server VM",
-                                      "HotSpot", "hotspot warning",
-                                      "IBM", "ibm warning"))
-                .isEqualTo("hotspot warning");
-        assertThat(Platform.warnForVM("IBM J9 VM",
-                                      "HotSpot", "hotspot warning",
-                                      "IBM", "ibm warning"))
-                .isEqualTo("ibm warning");
-        assertThat(Platform.warnForVM("whatever",
-                                      null, "should not be returned",
-                                      null, "should not be returned"))
-                .isEqualTo("");
-    }
-
-    @Test
-    public void should_parse_open_jdk_string_and_report_wether_below_or_nut_update_45() {
-        // Given
-        // Sources :
-        //  - http://www.oracle.com/technetwork/java/javase/versioning-naming-139433.html
-        //  - http://www.oracle.com/technetwork/java/javase/jdk7-naming-418744.html
-        //  - http://www.oracle.com/technetwork/java/javase/jdk8-naming-2157130.html
-        //  - http://stackoverflow.com/questions/35844985/how-do-we-get-sr-and-fp-of-ibm-jre-using-java
-        //  - http://www.ibm.com/support/knowledgecenter/SSYKE2_6.0.0/com.ibm.java.doc.user.win32.60/user/java_version_check.html
-        Map<String, Boolean> versions = new HashMap<String, Boolean>() {{
-            put("1.8.0_92-b14", false);
-            put("1.8.0-b24", true);
-            put("1.8.0_5", true);
-            put("1.8.0b5_u44", true);
-            put("1.8.0b5_u92", false);
-            put("1.7.0_4", false);
-            put("1.4.0_03-b04", false);
-            put("1.4.0_03-ea-b01", false);
-            put("pxi3270_27sr4-20160303_03 (SR4)", false);
-            put("pwi3260sr11-20120412_01 (SR11)", false);
-            put("pwa6480sr1fp10-20150711_01 (SR1 FP10)", false);
-            put("null", false);
-        }};
-
-        assertPlatformParsesCorrectlyVariousVersionScheme(versions);
-    }
-
-    @Test
-    public void should_parse_open_jdk9_string() {
-        // The tested method targets Java 8 but should be able to parse other Java version numbers including Java 9
-
-        // Given
-        // Sources :
-        //  - http://openjdk.java.net/jeps/223 (Java 9)
-        //
-        // System Property                 Existing      Proposed
-        // ------------------------------- ------------  --------
-        // Early Access
-        // java.runtime.version            1.9.0-ea-b73  9-ea+73
-        // java.vm.version                 1.9.0-ea-b73  9-ea+73
-        // java.specification.version      1.9           9
-        // java.vm.specification.version   1.9           9
-        //
-        // Major (GA)
-        // java.version                    1.9.0         9
-        // java.runtime.version            1.9.0-b100    9+100
-        // java.vm.version                 1.9.0-b100    9+100
-        // java.specification.version      1.9           9
-        // java.vm.specification.version   1.9           9
-        //
-        // Minor #1 (GA)
-        // java.version                    1.9.0_20      9.1.2
-        // java.runtime.version            1.9.0_20-b62  9.1.2+62
-        // java.vm.version                 1.9.0_20-b62  9.1.2+62
-        // java.specification.version      1.9           9
-        // java.vm.specification.version   1.9           9
-        //
-        // Security #1 (GA)
-        // java.version                    1.9.0_5       9.0.1
-        // java.runtime.version            1.9.0_5-b20   9.0.1+20
-        // java.vm.version                 1.9.0_5-b20   9.0.1+20
-        // java.specification.version      1.9           9
-        // java.vm.specification.version   1.9           9
-        //
-        Map<String, Boolean> versions = new HashMap<String, Boolean>() {{
-            put("9-ea+73", false);
-            put("9+100", false);
-            put("9.1.2+62", false);
-            put("9.0.1+20", false);
-        }};
-
-        assertPlatformParsesCorrectlyVariousVersionScheme(versions);
-    }
-
-
-    private void assertPlatformParsesCorrectlyVariousVersionScheme(Map<String, Boolean> versions) {
-        for (Map.Entry<String, Boolean> version : versions.entrySet()) {
-            assertThat(Platform.isJava8BelowUpdate45(version.getKey())).describedAs(version.getKey())
-                                                                       .isEqualTo(version.getValue());
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/StringUtilTest.java b/src/test/java/org/mockito/internal/util/StringUtilTest.java
deleted file mode 100644
index d7f1168a17..0000000000
--- a/src/test/java/org/mockito/internal/util/StringUtilTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-public class StringUtilTest  {
-
-    @Test
-    public void decamelizes_matcher() throws Exception {
-        assertEquals("<Sentence with strong language>", StringUtil.decamelizeMatcher("SentenceWithStrongLanguage"));
-        assertEquals("<W e i r d o 1>", StringUtil.decamelizeMatcher("WEIRDO1"));
-        assertEquals("<_>", StringUtil.decamelizeMatcher("_"));
-        assertEquals("<Has exactly 3 elements>", StringUtil.decamelizeMatcher("HasExactly3Elements"));
-        assertEquals("<custom argument matcher>", StringUtil.decamelizeMatcher(""));
-    }
-
-    @Test
-    public void joins_empty_list() throws Exception {
-        assertThat(StringUtil.join()).isEmpty();
-        assertThat(StringUtil.join("foo", emptyList())).isEmpty();
-    }
-
-    @Test
-    public void joins_single_line() throws Exception {
-        assertThat(StringUtil.join("line1")).hasLineCount(2);
-    }
-
-    @Test
-    public void joins_two_lines() throws Exception {
-        assertThat(StringUtil.join("line1","line2")).hasLineCount(3);
-    }
-
-    @Test
-    public void join_has_preceding_linebreak() throws Exception {
-        assertThat(StringUtil.join("line1")).isEqualTo("\nline1");
-    }
-
-    @Test
-    public void removes_first_line() throws Exception {
-        assertThat(StringUtil.removeFirstLine("line1\nline2")).isEqualTo("line2");
-    }
-
-    @Test
-    public void joins_with_line_prefix() throws Exception {
-        assertEquals("Hey!\n" +
-            " - a\n" +
-            " - b", StringUtil.join("Hey!\n", " - ", asList("a", "b")));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/TimerTest.java b/src/test/java/org/mockito/internal/util/TimerTest.java
deleted file mode 100644
index 8a4a173e02..0000000000
--- a/src/test/java/org/mockito/internal/util/TimerTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.exceptions.misusing.FriendlyReminderException;
-import org.mockitoutil.TestBase;
-
-public class TimerTest extends TestBase {
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
-    @Test
-    public void should_return_true_if_task_is_in_acceptable_time_bounds() {
-        //given
-        long duration = 10000L;
-        Timer timer = new Timer(duration);
-
-        //when
-        timer.start();
-
-        //then
-        Assertions.assertThat(timer.isCounting()).isTrue();
-    }
-
-    @Test
-    public void should_return_false_when_time_run_out() throws Exception {
-        //given
-        Timer timer = new Timer(0);
-        timer.start();
-
-        //when
-        oneMillisecondPasses();
-
-        //then
-        Assertions.assertThat(timer.isCounting()).isFalse();
-    }
-
-    @Test
-    public void should_throw_friendly_reminder_exception_when_duration_is_negative() {
-        expectedException.expect(FriendlyReminderException.class);
-        expectedException.expectMessage("Don't panic! I'm just a friendly reminder!");
-        new Timer(-1);
-    }
-
-    private void oneMillisecondPasses() throws InterruptedException {
-        Thread.sleep(1);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java b/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java
deleted file mode 100644
index ea8ad66bb9..0000000000
--- a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.collections;
-
-import static java.util.Arrays.asList;
-
-import static org.junit.Assert.assertTrue;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-import org.mockitoutil.TestBase;
-
-public class ListUtilTest extends TestBase {
-
-    @Test
-    public void shouldFilterList() throws Exception {
-        List<String> list = asList("one", "x", "two", "x", "three");
-        List<String> filtered = ListUtil.filter(list, new Filter<String>() {
-            public boolean isOut(String object) {
-                return object == "x";
-            }
-        });
-
-        Assertions.assertThat(filtered).containsSequence("one", "two", "three");
-    }
-
-    @Test
-    public void shouldReturnEmptyIfEmptyListGiven() throws Exception {
-        List<Object> list = new LinkedList<Object>();
-        List<Object> filtered = ListUtil.filter(list, null);
-        assertTrue(filtered.isEmpty());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/AccessibilityChangerTest.java b/src/test/java/org/mockito/internal/util/reflection/AccessibilityChangerTest.java
deleted file mode 100644
index b1af50258e..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/AccessibilityChangerTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.mockitoutil.VmArgAssumptions.assumeVmArgPresent;
-
-import java.lang.reflect.Field;
-import java.util.Observable;
-
-import org.junit.Test;
-
-public class AccessibilityChangerTest {
-
-    @SuppressWarnings("unused")
-    private Observable whatever;
-
-    @Test
-    public void should_enable_and_safely_disable() throws Exception {
-        AccessibilityChanger changer = new AccessibilityChanger();
-        changer.enableAccess(field("whatever"));
-        changer.safelyDisableAccess(field("whatever"));
-    }
-
-    @Test(expected = java.lang.AssertionError.class)
-    public void safelyDisableAccess_should_fail_when_enableAccess_not_called() throws Exception {
-        assumeVmArgPresent("-ea");
-        new AccessibilityChanger().safelyDisableAccess(field("whatever"));
-    }
-
-
-    private Field field(String fieldName) throws NoSuchFieldException {
-        return this.getClass().getDeclaredField(fieldName);
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java b/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
deleted file mode 100644
index 6967c02c8a..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-public class DummyParentClassForTests {
-
-    @SuppressWarnings("unused")//I know, I know. We're doing nasty reflection hacks here...
-    private String somePrivateField;
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java b/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
deleted file mode 100644
index 8fbe6ee0b2..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.junit.Assert.*;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.Test;
-import org.mockito.InjectMocks;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
-
-
-
-public class FieldInitializerTest {
-
-    private StaticClass alreadyInstantiated = new StaticClass();
-    private StaticClass noConstructor;
-    private StaticClassWithDefaultConstructor defaultConstructor;
-    private StaticClassWithPrivateDefaultConstructor privateDefaultConstructor;
-    private StaticClassWithoutDefaultConstructor noDefaultConstructor;
-    private StaticClassThrowingExceptionDefaultConstructor throwingExDefaultConstructor;
-    private AbstractStaticClass abstractType;
-    private Interface interfaceType;
-    private InnerClassType innerClassType;
-    private AbstractStaticClass instantiatedAbstractType = new ConcreteStaticClass();
-    private Interface instantiatedInterfaceType =  new ConcreteStaticClass();
-    private InnerClassType instantiatedInnerClassType = new InnerClassType();
-
-    @Test
-    public void should_keep_same_instance_if_field_initialized() throws Exception {
-        final StaticClass backupInstance = alreadyInstantiated;
-        FieldInitializer fieldInitializer = new FieldInitializer(this, field("alreadyInstantiated"));
-        FieldInitializationReport report = fieldInitializer.initialize();
-
-        assertSame(backupInstance, report.fieldInstance());
-        assertFalse(report.fieldWasInitialized());
-        assertFalse(report.fieldWasInitializedUsingContructorArgs());
-    }
-
-    @Test
-    public void should_instantiate_field_when_type_has_no_constructor() throws Exception {
-        FieldInitializer fieldInitializer = new FieldInitializer(this, field("noConstructor"));
-        FieldInitializationReport report = fieldInitializer.initialize();
-
-        assertNotNull(report.fieldInstance());
-        assertTrue(report.fieldWasInitialized());
-        assertFalse(report.fieldWasInitializedUsingContructorArgs());
-    }
-
-    @Test
-    public void should_instantiate_field_with_default_constructor() throws Exception {
-        FieldInitializer fieldInitializer = new FieldInitializer(this, field("defaultConstructor"));
-        FieldInitializationReport report = fieldInitializer.initialize();
-
-        assertNotNull(report.fieldInstance());
-        assertTrue(report.fieldWasInitialized());
-        assertFalse(report.fieldWasInitializedUsingContructorArgs());
-    }
-
-    @Test
-    public void should_instantiate_field_with_private_default_constructor() throws Exception {
-        FieldInitializer fieldInitializer = new FieldInitializer(this, field("privateDefaultConstructor"));
-        FieldInitializationReport report = fieldInitializer.initialize();
-
-        assertNotNull(report.fieldInstance());
-        assertTrue(report.fieldWasInitialized());
-        assertFalse(report.fieldWasInitializedUsingContructorArgs());
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_to_instantiate_field_if_no_default_constructor() throws Exception {
-        FieldInitializer fieldInitializer = new FieldInitializer(this, field("noDefaultConstructor"));
-        fieldInitializer.initialize();
-    }
-
-    @Test
-    public void should_fail_to_instantiate_field_if_default_constructor_throws_exception() throws Exception {
-        FieldInitializer fieldInitializer = new FieldInitializer(this, field("throwingExDefaultConstructor"));
-        try {
-            fieldInitializer.initialize();
-            fail();
-        } catch (MockitoException e) {
-            InvocationTargetException ite = (InvocationTargetException) e.getCause();
-            assertTrue(ite.getTargetException() instanceof NullPointerException);
-            assertEquals("business logic failed", ite.getTargetException().getMessage());
-        }
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_for_abstract_field() throws Exception {
-        new FieldInitializer(this, field("abstractType"));
-    }
-
-    @Test
-    public void should_not_fail_if_abstract_field_is_instantiated() throws Exception {
-        new FieldInitializer(this, field("instantiatedAbstractType"));
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_for_interface_field() throws Exception {
-        new FieldInitializer(this, field("interfaceType"));
-    }
-
-    @Test
-    public void should_not_fail_if_interface_field_is_instantiated() throws Exception {
-        new FieldInitializer(this, field("instantiatedInterfaceType"));
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_for_local_type_field() throws Exception {
-        // when
-        class LocalType { }
-
-        class TheTestWithLocalType {
-            @InjectMocks LocalType field;
-        }
-
-        TheTestWithLocalType testWithLocalType = new TheTestWithLocalType();
-
-        // when
-        new FieldInitializer(testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
-    }
-
-    @Test
-    public void should_not_fail_if_local_type_field_is_instantiated() throws Exception {
-        // when
-        class LocalType { }
-
-        class TheTestWithLocalType {
-            @InjectMocks LocalType field = new LocalType();
-        }
-
-        TheTestWithLocalType testWithLocalType = new TheTestWithLocalType();
-
-        // when
-        new FieldInitializer(testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_fail_for_inner_class_field() throws Exception {
-        new FieldInitializer(this, field("innerClassType"));
-    }
-
-    @Test
-    public void should_not_fail_if_inner_class_field_is_instantiated() throws Exception {
-        new FieldInitializer(this, field("instantiatedInnerClassType"));
-    }
-
-    @Test
-    public void can_instantiate_class_with_parameterized_constructor() throws Exception {
-        ConstructorArgumentResolver resolver = given(mock(ConstructorArgumentResolver.class).resolveTypeInstances(any(Class.class)))
-                        .willReturn(new Object[]{null}).getMock();
-
-        new FieldInitializer(this, field("noDefaultConstructor"), resolver).initialize();
-
-        assertNotNull(noDefaultConstructor);
-    }
-
-    private Field field(String fieldName) throws NoSuchFieldException {
-        return this.getClass().getDeclaredField(fieldName);
-    }
-
-    static class StaticClass {
-    }
-
-    static class StaticClassWithDefaultConstructor {
-        StaticClassWithDefaultConstructor() { }
-    }
-
-    static class StaticClassWithPrivateDefaultConstructor {
-        private StaticClassWithPrivateDefaultConstructor() { }
-    }
-
-    static class StaticClassWithoutDefaultConstructor {
-        private StaticClassWithoutDefaultConstructor(String param) { }
-    }
-
-    static class StaticClassThrowingExceptionDefaultConstructor {
-        StaticClassThrowingExceptionDefaultConstructor() throws Exception {
-            throw new NullPointerException("business logic failed");
-        }
-    }
-
-    static abstract class AbstractStaticClass {
-        public AbstractStaticClass() {}
-    }
-
-    interface Interface {
-
-    }
-
-    static class ConcreteStaticClass extends AbstractStaticClass implements Interface {
-    }
-
-    class InnerClassType {
-        InnerClassType() { }
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java b/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java
deleted file mode 100644
index 897cc2a218..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.util.reflection.Fields.syntheticField;
-
-import java.lang.reflect.Field;
-
-import org.junit.Test;
-
-public class FieldsTest {
-
-    @Test
-    public void fields_should_return_all_declared_fields_in_hierarchy() throws Exception {
-        assertThat(Fields.allDeclaredFieldsOf(new HierarchyOfClasses()).filter(syntheticField()).names())
-                .containsOnly("a", "b", "static_a", "static_b");
-    }
-
-    @Test
-    public void fields_should_return_declared_fields() throws Exception {
-        assertThat(Fields.declaredFieldsOf(new HierarchyOfClasses()).filter(syntheticField()).names())
-                .containsOnly("b", "static_b");
-    }
-
-    @Test
-    public void can_filter_not_null_fields() throws Exception {
-        assertThat(Fields.declaredFieldsOf(new NullOrNotNullFields()).notNull().filter(syntheticField()).names())
-                .containsOnly("c");
-    }
-
-    @Test
-    public void can_get_values_of_instance_fields() throws Exception {
-        assertThat(Fields.declaredFieldsOf(new ValuedFields()).filter(syntheticField()).assignedValues())
-                .containsOnly("a", "b");
-    }
-
-
-    @Test
-    public void can_get_list_of_InstanceField() throws Exception {
-        ValuedFields instance = new ValuedFields();
-
-        assertThat(Fields.declaredFieldsOf(instance).filter(syntheticField()).instanceFields())
-                .containsOnly(new InstanceField(field("a", instance), instance),
-                              new InstanceField(field("b", instance), instance)
-                );
-    }
-
-    private Field field(String name, Object instance) throws NoSuchFieldException {
-        return instance.getClass().getDeclaredField(name);
-    }
-
-
-    interface AnInterface {
-        int someStaticInInterface = 0;
-
-    }
-    public static class ParentClass implements AnInterface {
-        static int static_a;
-        int a;
-
-    }
-    public static class HierarchyOfClasses extends ParentClass {
-        static int static_b;
-        int b = 1;
-
-    }
-    public static class NullOrNotNullFields {
-        static Object static_b;
-        Object b;
-        Object c = new Object();
-    }
-
-    public static class ValuedFields {
-        String a = "a";
-        String b = "b";
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
deleted file mode 100644
index bd43a06d60..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.junit.Assert.assertEquals;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Type;
-import java.util.*;
-
-import org.junit.Test;
-
-public class GenericMasterTest {
-
-    GenericMaster m = new GenericMaster();
-
-    List<String> one;
-    Set<Integer> two;
-    Map<Double, String> map;
-    String nonGeneric;
-    List<Set<String>> nested;
-    List<Set<Collection<String>>> multiNested;
-
-    public interface ListSet extends List<Set<?>> {}
-    public interface MapNumberString extends Map<Number, String> {}
-    public class HashMapNumberString<K extends Number> extends HashMap<K, String> {}
-
-    public List<Number> numberList() { return null; }
-    public Comparable<Number> numberComparable() { return null; }
-    @SuppressWarnings("rawtypes")
-    public List rawList() { return null; }
-    public List<? extends Type> typeList() { return null; }
-
-
-
-    @Test
-    public void should_find_generic_class() throws Exception {
-        assertEquals(String.class, m.getGenericType(field("one")));
-        assertEquals(Integer.class, m.getGenericType(field("two")));
-        assertEquals(Double.class, m.getGenericType(field("map")));
-    }
-
-    @Test
-    public void should_get_object_for_non_generic() throws Exception {
-        assertEquals(Object.class, m.getGenericType(field("nonGeneric")));
-    }
-
-    @Test
-    public void should_deal_with_nested_generics() throws Exception {
-        assertEquals(Set.class, m.getGenericType(field("nested")));
-        assertEquals(Set.class, m.getGenericType(field("multiNested")));
-    }
-
-    private Field field(String fieldName) throws SecurityException, NoSuchFieldException {
-        return this.getClass().getDeclaredField(fieldName);
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
deleted file mode 100644
index c7985fd713..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
+++ /dev/null
@@ -1,333 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.internal.util.reflection.GenericMetadataSupport.inferFrom;
-
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.junit.Test;
-
-public class GenericMetadataSupportTest {
-
-    interface GenericsSelfReference<T extends GenericsSelfReference<T>> {
-        T self();
-    }
-
-    interface UpperBoundedTypeWithClass<E extends Number & Comparable<E>> {
-        E get();
-    }
-
-    interface UpperBoundedTypeWithInterfaces<E extends Comparable<E> & Cloneable> {
-        E get();
-    }
-
-    interface ListOfNumbers extends List<Number> {
-    }
-
-    interface AnotherListOfNumbers extends ListOfNumbers {
-    }
-
-    abstract class ListOfNumbersImpl implements ListOfNumbers {
-    }
-
-    abstract class AnotherListOfNumbersImpl extends ListOfNumbersImpl {
-    }
-
-    interface ListOfAnyNumbers<N extends Number & Cloneable> extends List<N> {
-    }
-
-    interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {
-        Set<Number> remove(Object key); // override with fixed ParameterizedType
-
-        List<? super Integer> returning_wildcard_with_class_lower_bound();
-
-        List<? super K> returning_wildcard_with_typeVar_lower_bound();
-
-        List<? extends K> returning_wildcard_with_typeVar_upper_bound();
-
-        K returningK();
-
-        <O extends K> List<O> paramType_with_type_params();
-
-        <S, T extends S> T two_type_params();
-
-        <O extends K> O typeVar_with_type_params();
-    }
-
-    static class StringList extends ArrayList<String> {
-    }
-
-    public interface TopInterface<T> {
-        T generic();
-    }
-
-    public interface MiddleInterface<T> extends TopInterface<T> {
-    }
-
-    public class OwningClassWithDeclaredUpperBounds<T extends List<String> & Comparable<String> & Cloneable> {
-        public abstract class AbstractInner implements MiddleInterface<T> {
-        }
-    }
-
-    public class OwningClassWithNoDeclaredUpperBounds<T> {
-        public abstract class AbstractInner implements MiddleInterface<T> {
-        }
-    }
-
-    @Test
-    public void typeVariable_of_self_type() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsSelfReference.class).resolveGenericReturnType(firstNamedMethod("self", GenericsSelfReference.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(GenericsSelfReference.class);
-    }
-
-    @Test
-    public void can_get_raw_type_from_Class() {
-        assertThat(inferFrom(ListOfAnyNumbers.class).rawType()).isEqualTo(ListOfAnyNumbers.class);
-        assertThat(inferFrom(ListOfNumbers.class).rawType()).isEqualTo(ListOfNumbers.class);
-        assertThat(inferFrom(GenericsNest.class).rawType()).isEqualTo(GenericsNest.class);
-        assertThat(inferFrom(StringList.class).rawType()).isEqualTo(StringList.class);
-    }
-
-    @Test
-    public void can_get_raw_type_from_ParameterizedType() {
-        assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).rawType()).isEqualTo(List.class);
-        assertThat(inferFrom(ListOfNumbers.class.getGenericInterfaces()[0]).rawType()).isEqualTo(List.class);
-        assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).rawType()).isEqualTo(Map.class);
-        assertThat(inferFrom(StringList.class.getGenericSuperclass()).rawType()).isEqualTo(ArrayList.class);
-    }
-
-    @Test
-    public void can_get_type_variables_from_Class() {
-        assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("K");
-        assertThat(inferFrom(ListOfNumbers.class).actualTypeArguments().keySet()).isEmpty();
-        assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("N");
-        assertThat(inferFrom(Map.class).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V");
-        assertThat(inferFrom(Serializable.class).actualTypeArguments().keySet()).isEmpty();
-        assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
-    }
-
-    @Test
-    public void can_resolve_type_variables_from_ancestors() throws Exception {
-        Method listGet = List.class.getMethod("get", int.class);
-        assertThat(inferFrom(AnotherListOfNumbers.class).resolveGenericReturnType(listGet).rawType()).isEqualTo(Number.class);
-        assertThat(inferFrom(AnotherListOfNumbersImpl.class).resolveGenericReturnType(listGet).rawType()).isEqualTo(Number.class);
-    }
-
-    @Test
-    public void can_get_type_variables_from_ParameterizedType() {
-        assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V");
-        assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("E");
-        assertThat(inferFrom(Integer.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("T");
-        assertThat(inferFrom(StringBuilder.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).isEmpty();
-        assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
-    }
-
-    @Test
-    public void typeVariable_return_type_of____iterator____resolved_to_Iterator_and_type_argument_to_String() {
-        GenericMetadataSupport genericMetadata = inferFrom(StringList.class).resolveGenericReturnType(firstNamedMethod("iterator", StringList.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(Iterator.class);
-        assertThat(genericMetadata.actualTypeArguments().values()).contains(String.class);
-    }
-
-    @Test
-    public void typeVariable_return_type_of____get____resolved_to_Set_and_type_argument_to_Number() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("get", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(Set.class);
-        assertThat(genericMetadata.actualTypeArguments().values()).contains(Number.class);
-    }
-
-    @Test
-    public void bounded_typeVariable_return_type_of____returningK____resolved_to_Comparable_and_with_BoundedType() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returningK", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(Comparable.class);
-        GenericMetadataSupport extraInterface_0 = inferFrom(genericMetadata.extraInterfaces().get(0));
-        assertThat(extraInterface_0.rawType()).isEqualTo(Cloneable.class);
-    }
-
-    @Test
-    public void fixed_ParamType_return_type_of____remove____resolved_to_Set_and_type_argument_to_Number() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("remove", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(Set.class);
-        assertThat(genericMetadata.actualTypeArguments().values()).contains(Number.class);
-    }
-
-    @Test
-    public void paramType_return_type_of____values____resolved_to_Collection_and_type_argument_to_Parameterized_Set() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("values", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(Collection.class);
-        GenericMetadataSupport fromTypeVariableE = inferFrom(typeVariableValue(genericMetadata.actualTypeArguments(), "E"));
-        assertThat(fromTypeVariableE.rawType()).isEqualTo(Set.class);
-        assertThat(fromTypeVariableE.actualTypeArguments().values()).contains(Number.class);
-    }
-
-    @Test
-    public void paramType_with_type_parameters_return_type_of____paramType_with_type_params____resolved_to_Collection_and_type_argument_to_Parameterized_Set() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("paramType_with_type_params", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
-        Type firstBoundOfE = ((GenericMetadataSupport.TypeVarBoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E")).firstBound();
-        assertThat(inferFrom(firstBoundOfE).rawType()).isEqualTo(Comparable.class);
-    }
-
-    @Test
-    public void typeVariable_with_type_parameters_return_type_of____typeVar_with_type_params____resolved_K_hence_to_Comparable_and_with_BoundedType() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("typeVar_with_type_params", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(Comparable.class);
-        GenericMetadataSupport extraInterface_0 = inferFrom(genericMetadata.extraInterfaces().get(0));
-        assertThat(extraInterface_0.rawType()).isEqualTo(Cloneable.class);
-    }
-
-    @Test
-    public void class_return_type_of____append____resolved_to_StringBuilder_and_type_arguments() {
-        GenericMetadataSupport genericMetadata = inferFrom(StringBuilder.class).resolveGenericReturnType(firstNamedMethod("append", StringBuilder.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(StringBuilder.class);
-        assertThat(genericMetadata.actualTypeArguments()).isEmpty();
-    }
-
-
-    @Test
-    public void paramType_with_wildcard_return_type_of____returning_wildcard_with_class_lower_bound____resolved_to_List_and_type_argument_to_Integer() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returning_wildcard_with_class_lower_bound", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
-        GenericMetadataSupport.BoundedType boundedType = (GenericMetadataSupport.BoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E");
-        assertThat(boundedType.firstBound()).isEqualTo(Integer.class);
-        assertThat(boundedType.interfaceBounds()).isEmpty();
-    }
-
-    @Test
-    public void paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_lower_bound____resolved_to_List_and_type_argument_to_Integer() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returning_wildcard_with_typeVar_lower_bound", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
-        GenericMetadataSupport.BoundedType boundedType = (GenericMetadataSupport.BoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E");
-
-        assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
-        assertThat(boundedType.interfaceBounds()).contains(Cloneable.class);
-    }
-
-    @Test
-    public void paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_upper_bound____resolved_to_List_and_type_argument_to_Integer() {
-        GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returning_wildcard_with_typeVar_upper_bound", GenericsNest.class));
-
-        assertThat(genericMetadata.rawType()).isEqualTo(List.class);
-        GenericMetadataSupport.BoundedType boundedType = (GenericMetadataSupport.BoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E");
-
-        assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
-        assertThat(boundedType.interfaceBounds()).contains(Cloneable.class);
-    }
-
-    @Test
-    public void can_extract_raw_type_from_bounds_on_terminal_typeVariable() {
-        assertThat(inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
-                       .resolveGenericReturnType(firstNamedMethod("generic", OwningClassWithDeclaredUpperBounds.AbstractInner.class))
-                       .rawType()
-                  ).isEqualTo(List.class);
-        assertThat(inferFrom(OwningClassWithNoDeclaredUpperBounds.AbstractInner.class)
-                       .resolveGenericReturnType(firstNamedMethod("generic", OwningClassWithNoDeclaredUpperBounds.AbstractInner.class))
-                       .rawType()
-                  ).isEqualTo(Object.class);
-    }
-
-    @Test
-    public void can_extract_interface_type_from_bounds_on_terminal_typeVariable() {
-
-        assertThat(inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
-                       .resolveGenericReturnType(firstNamedMethod("generic", OwningClassWithDeclaredUpperBounds.AbstractInner.class))
-                       .rawExtraInterfaces()
-                  ).containsExactly(Comparable.class, Cloneable.class);
-        assertThat(inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
-                       .resolveGenericReturnType(firstNamedMethod("generic", OwningClassWithDeclaredUpperBounds.AbstractInner.class))
-                       .extraInterfaces()
-                  ).containsExactly(parameterizedTypeOf(Comparable.class, null, String.class),
-                                                                                                                                                                         Cloneable.class);
-
-        assertThat(inferFrom(OwningClassWithNoDeclaredUpperBounds.AbstractInner.class)
-                       .resolveGenericReturnType(firstNamedMethod("generic", OwningClassWithNoDeclaredUpperBounds.AbstractInner.class))
-                       .extraInterfaces()
-                  ).isEmpty();
-    }
-
-    private ParameterizedType parameterizedTypeOf(final Class<?> rawType, final Class<?> ownerType, final Type... actualTypeArguments) {
-        return new ParameterizedType() {
-            @Override
-            public Type[] getActualTypeArguments() {
-                return actualTypeArguments;
-            }
-
-            @Override
-            public Type getRawType() {
-                return rawType;
-            }
-
-            @Override
-            public Type getOwnerType() {
-                return ownerType;
-            }
-
-            public boolean equals(Object other) {
-                if (other instanceof ParameterizedType) {
-                    ParameterizedType otherParamType = (ParameterizedType) other;
-                    if (this == otherParamType) {
-                        return true;
-                    } else {
-                        return equals(ownerType, otherParamType.getOwnerType())
-                               && equals(rawType, otherParamType.getRawType())
-                               && Arrays.equals(actualTypeArguments, otherParamType.getActualTypeArguments());
-                    }
-                } else {
-                    return false;
-                }
-            }
-
-            private boolean equals(Object a, Object b) {
-                return (a == b) || (a != null && a.equals(b));
-            }
-        };
-    }
-
-    private Type typeVariableValue(Map<TypeVariable<?>, Type> typeVariables, String typeVariableName) {
-        for (Map.Entry<TypeVariable<?>, Type> typeVariableTypeEntry : typeVariables.entrySet()) {
-            if (typeVariableTypeEntry.getKey().getName().equals(typeVariableName)) {
-                return typeVariableTypeEntry.getValue();
-            }
-        }
-
-        fail("'" + typeVariableName + "' was not found in " + typeVariables);
-        return null; // unreachable
-    }
-
-    private Method firstNamedMethod(String methodName, Class<?> clazz) {
-        for (Method method : clazz.getMethods()) {
-            boolean protect_against_different_jdk_ordering_avoiding_bridge_methods = !method.isBridge();
-            if (method.getName().contains(methodName) && protect_against_different_jdk_ordering_avoiding_bridge_methods) {
-                return method;
-            }
-        }
-        throw new IllegalStateException("The method : '" + methodName + "' do not exist in '" + clazz.getSimpleName() + "'");
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
deleted file mode 100644
index d5f270de19..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.util.reflection.GenericTypeExtractor.genericTypeOf;
-
-import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-public class GenericTypeExtractorTest extends TestBase {
-
-    class Base<T> {}
-    static class StaticBase<T> {}
-    interface IBase<T> {}
-    interface StaticIBase<T> {}
-
-    class IntImpl extends Base<Integer> {}
-    static class StaticIntImpl extends StaticBase<Integer> {}
-    class NestedImpl extends Base<Base<String>> {}
-    class NonGeneric extends Base {}
-
-    class IIntImpl implements IBase<Integer>{}
-    class INestedImpl implements IBase<IBase<String>>{}
-    class INonGeneric implements IBase {}
-    class Mixed extends Base<Integer> implements IBase<String> {}
-
-    class Deeper extends IntImpl implements Serializable {}
-    class EvenDeeper extends Deeper implements Cloneable {}
-    interface Iface extends IBase<Integer> {}
-    interface IDeeper extends Serializable, Iface, Cloneable {}
-
-    interface Crazy extends Serializable, IDeeper, Cloneable {}
-    class Crazier extends EvenDeeper implements Crazy {}
-    class SecondGeneric implements Serializable, IBase<Integer> {}
-
-    @Test public void finds_generic_type() {
-        assertEquals(Integer.class, genericTypeOf(IntImpl.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(StaticIntImpl.class, StaticBase.class, IBase.class));
-
-        assertEquals(Object.class, genericTypeOf(NestedImpl.class, Base.class, IBase.class));
-        assertEquals(Object.class, genericTypeOf(NonGeneric.class, Base.class, IBase.class));
-        assertEquals(Object.class, genericTypeOf(String.class, Base.class, IBase.class));
-        assertEquals(Object.class, genericTypeOf(String.class, List.class, Map.class));
-
-        assertEquals(String.class, genericTypeOf(new Base<String>() {}.getClass(), Base.class, IBase.class));
-        assertEquals(String.class, genericTypeOf(new IBase<String>() {}.getClass(), Base.class, IBase.class));
-        assertEquals(String.class, genericTypeOf(new StaticBase<String>() {}.getClass(), StaticBase.class, IBase.class));
-        assertEquals(String.class, genericTypeOf(new StaticIBase<String>() {}.getClass(), Base.class, StaticIBase.class));
-
-        assertEquals(Integer.class, genericTypeOf(Mixed.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(IIntImpl.class, Base.class, IBase.class));
-        assertEquals(Object.class, genericTypeOf(INestedImpl.class, Base.class, IBase.class));
-        assertEquals(Object.class, genericTypeOf(INonGeneric.class, IBase.class, INonGeneric.class));
-
-        assertEquals(Integer.class, genericTypeOf(Deeper.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(EvenDeeper.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(Iface.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(IDeeper.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(Crazy.class, Base.class, IBase.class));
-        assertEquals(Integer.class, genericTypeOf(Crazier.class, Base.class, IBase.class));
-
-        assertEquals(Integer.class, genericTypeOf(SecondGeneric.class, Base.class, IBase.class));
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java b/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
deleted file mode 100644
index 1ffa6cfbf3..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.util.Map;
-import java.util.Observer;
-import java.util.Set;
-
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Matchers;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
-import org.mockito.internal.util.reflection.FieldInitializer.ParameterizedConstructorInstantiator;
-import org.mockito.junit.MockitoJUnitRunner;
-
-
-@SuppressWarnings("unchecked")
-@RunWith(MockitoJUnitRunner.class)
-public class ParameterizedConstructorInstantiatorTest {
-
-    private Set<?> whateverForNow;
-    private OneConstructor withOneConstructor;
-    private MultipleConstructor withMultipleConstructor;
-    private NoArgConstructor withNoArgConstructor;
-    private ThrowingConstructor withThrowingConstructor;
-    private VarargConstructor withVarargConstructor;
-
-    @After
-    public void ensure_instances_to_create_are_null() {
-        withMultipleConstructor = null;
-        withOneConstructor = null;
-        withNoArgConstructor = null;
-        withThrowingConstructor = null;
-        withVarargConstructor = null;
-    }
-
-    @Mock private ConstructorArgumentResolver resolver;
-
-    @Test
-    public void should_be_created_with_an_argument_resolver() throws Exception {
-        new ParameterizedConstructorInstantiator(this, field("whateverForNow"), resolver);
-    }
-
-    @Test
-    public void should_fail_if_no_parameterized_constructor_found___excluding_inner_and_others_kind_of_types() throws Exception {
-        try {
-            new ParameterizedConstructorInstantiator(this, field("withNoArgConstructor"), resolver).instantiate();
-            fail();
-        } catch (MockitoException me) {
-            assertThat(me.getMessage()).contains("no parameterized constructor").contains("withNoArgConstructor").contains("NoArgConstructor");
-        }
-    }
-
-    @Test
-    public void should_instantiate_type_if_resolver_provide_matching_types() throws Exception {
-        Observer observer = mock(Observer.class);
-        Map map = mock(Map.class);
-        given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ observer, map });
-
-        new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver).instantiate();
-
-        assertNotNull(withMultipleConstructor);
-        assertNotNull(withMultipleConstructor.observer);
-        assertNotNull(withMultipleConstructor.map);
-    }
-
-    @Test
-    public void should_fail_if_an_argument_instance_type_do_not_match_wanted_type() throws Exception {
-        Observer observer = mock(Observer.class);
-        Set<?> wrongArg = mock(Set.class);
-        given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ observer, wrongArg });
-
-        try {
-            new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver).instantiate();
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage()).contains("argResolver").contains("incorrect types");
-        }
-    }
-
-    @Test
-    public void should_report_failure_if_constructor_throws_exception() throws Exception {
-        given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ null });
-
-        try {
-            new ParameterizedConstructorInstantiator(this, field("withThrowingConstructor"), resolver).instantiate();
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage()).contains("constructor").contains("raised an exception");
-        }
-    }
-
-    @Test
-    public void should_instantiate_type_with_vararg_constructor() throws Exception {
-        Observer[] vararg = new Observer[] {  };
-        given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ "", vararg});
-
-        new ParameterizedConstructorInstantiator(this, field("withVarargConstructor"), resolver).instantiate();
-
-        assertNotNull(withVarargConstructor);
-    }
-
-    private Field field(String fieldName) throws NoSuchFieldException {
-        Field field = this.getClass().getDeclaredField(fieldName);
-        field.setAccessible(true);
-        return field;
-    }
-
-    private static class NoArgConstructor {
-        NoArgConstructor() { }
-    }
-
-    private static class OneConstructor {
-        public OneConstructor(Observer observer) { }
-    }
-
-    private static class ThrowingConstructor {
-        public ThrowingConstructor(Observer observer) throws IOException { throw new IOException(); }
-    }
-
-    private static class MultipleConstructor extends OneConstructor {
-        Observer observer;
-        Map map;
-
-        public MultipleConstructor(Observer observer) { this(observer, null); }
-        public MultipleConstructor(Observer observer, Map map) {
-            super(observer);
-            this.observer = observer;
-            this.map = map;
-        }
-    }
-
-    private static class VarargConstructor {
-        VarargConstructor(String whatever, Observer... observers) { }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java b/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
deleted file mode 100644
index 3cf76c61cb..0000000000
--- a/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.util.reflection.SuperTypesLastSorter.sortSuperTypesLast;
-
-import java.lang.reflect.Field;
-import java.util.*;
-
-import org.junit.Test;
-
-@SuppressWarnings("unused")
-public class SuperTypesLastSorterTest {
-    /**
-     * A Comparator that behaves like the old one, so the existing tests
-     * continue to work.
-     */
-    private static Comparator<Field> cmp = new Comparator<Field>() {
-        public int compare(Field o1, Field o2) {
-            if (o1.equals(o2)) {
-                return 0;
-            }
-
-            List<Field> l = sortSuperTypesLast(Arrays.asList(o1, o2));
-
-            if (l.get(0) == o1) {
-                return -1;
-            } else {
-                return 1;
-            }
-        }
-    };
-
-    private Object objectA;
-    private Object objectB;
-
-    private Number numberA;
-    private Number numberB;
-
-    private Integer integerA;
-    private Integer integerB;
-
-    private Iterable<?> iterableA;
-
-    private Number xNumber;
-    private Iterable<?> yIterable;
-    private Integer zInteger;
-
-
-    @Test
-    public void when_same_type_the_order_is_based_on_field_name() throws Exception {
-        assertThat(cmp.compare(field("objectA"), field("objectB"))).isEqualTo(-1);
-        assertThat(cmp.compare(field("objectB"), field("objectA"))).isEqualTo(1);
-        assertThat(cmp.compare(field("objectB"), field("objectB"))).isEqualTo(0);
-    }
-
-    @Test
-    public void when_type_is_different_the_supertype_comes_last() throws Exception {
-        assertThat(cmp.compare(field("numberA"), field("objectB"))).isEqualTo(-1);
-        assertThat(cmp.compare(field("objectB"), field("numberA"))).isEqualTo(1);
-    }
-
-    @Test
-    public void using_Collections_dot_sort() throws Exception {
-        List<Field> unsortedFields = Arrays.asList(
-                field("objectB"),
-                field("integerB"),
-                field("numberA"),
-                field("numberB"),
-                field("objectA"),
-                field("integerA")
-        );
-
-        List<Field> sortedFields =  sortSuperTypesLast(unsortedFields);
-
-        assertThat(sortedFields).containsSequence(
-                field("integerA"),
-                field("integerB"),
-                field("numberA"),
-                field("numberB"),
-                field("objectA"),
-                field("objectB")
-        );
-    }
-
-
-    @Test
-    public void issue_352_order_was_different_between_JDK6_and_JDK7() throws Exception {
-        List<Field> unsortedFields = Arrays.asList(
-                field("objectB"),
-                field("objectA")
-        );
-
-        Collections.sort(unsortedFields, cmp);
-
-        assertThat(unsortedFields).containsSequence(
-                field("objectA"),
-                field("objectB")
-        );
-    }
-
-    @Test
-    public void fields_sort_consistently_when_interfaces_are_included() throws NoSuchFieldException {
-        assertSortConsistently(field("iterableA"), field("numberA"), field("integerA"));
-    }
-
-    @Test
-    public void fields_sort_consistently_when_names_and_type_indicate_different_order() throws NoSuchFieldException {
-        assertSortConsistently(field("xNumber"), field("yIterable"), field("zInteger"));
-    }
-
-    /**
-     * Assert that these fields sort in the same order no matter which order
-     * they start in.
-     */
-    private static void assertSortConsistently(Field a, Field b, Field c) {
-        Field[][] initialOrderings = {
-                {a, b, c},
-                {a, c, b},
-                {b, a, c},
-                {b, c, a},
-                {c, a, b},
-                {c, b, a}
-        };
-
-        Set<List<Field>> results = new HashSet<List<Field>>();
-
-        for (Field[] o : initialOrderings) {
-            results.add(sortSuperTypesLast(Arrays.asList(o)));
-        }
-
-        assertThat(results).hasSize(1);
-    }
-
-    private Field field(String field) throws NoSuchFieldException {
-        return getClass().getDeclaredField(field);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/DescriptionTest.java b/src/test/java/org/mockito/internal/verification/DescriptionTest.java
deleted file mode 100644
index ff6a2705bc..0000000000
--- a/src/test/java/org/mockito/internal/verification/DescriptionTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.verification.VerificationMode;
-
-public class DescriptionTest {
-
-    @Mock
-    private VerificationMode mockVerificationMode;
-
-    @Mock
-    private VerificationData mockVerificationData;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-    }
-
-    /**
-     * Test of verify method, of class Description. This test validates that the custom message is prepended to the
-     * error message when verification fails.
-     */
-    @Test
-    public void verification_failure_should_prepend_expected_message() {
-        String failureMessage = "message should be prepended to the original message";
-        String exceptionMessage = "original error message";
-        String expectedResult = failureMessage + "\n" + exceptionMessage;
-        MockitoAssertionError error = new MockitoAssertionError(exceptionMessage);
-        doThrow(error).when(mockVerificationMode).verify(mockVerificationData);
-
-        Description instance = new Description(mockVerificationMode, failureMessage);
-
-        try {
-            instance.verify(mockVerificationData);
-            verify(mockVerificationMode).verify(mockVerificationData);
-            fail("Should not have made it this far");
-
-        } catch (MockitoAssertionError e) {
-            assertEquals(expectedResult, e.getMessage());
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/OnlyTest.java b/src/test/java/org/mockito/internal/verification/OnlyTest.java
deleted file mode 100644
index 60b9a082cf..0000000000
--- a/src/test/java/org/mockito/internal/verification/OnlyTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification;
-
-import static org.junit.Assert.*;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MatchableInvocation;
-
-public class OnlyTest {
-
-    Only only = new Only();
-
-    public class VerificationDataStub implements VerificationData {
-        private final Invocation invocation;
-        private final InvocationMatcher wanted;
-
-        public VerificationDataStub(InvocationMatcher wanted, Invocation invocation) {
-            this.invocation = invocation;
-            this.wanted = wanted;
-        }
-
-        public List<Invocation> getAllInvocations() {
-            return Arrays.asList(invocation);
-        }
-
-        @Override
-        public MatchableInvocation getTarget() {
-            return wanted;
-        }
-
-        public InvocationMatcher getWanted() {
-            return wanted;
-        }
-    }
-
-    @Test
-    public void shouldMarkAsVerified() {
-        //given
-        Invocation invocation = new InvocationBuilder().toInvocation();
-        assertFalse(invocation.isVerified());
-
-        //when
-        only.verify(new VerificationDataStub(new InvocationMatcher(invocation), invocation));
-
-        //then
-        assertTrue(invocation.isVerified());
-    }
-
-    @Test
-    public void shouldNotMarkAsVerifiedWhenAssertionFailed() {
-        //given
-        Invocation invocation = new InvocationBuilder().toInvocation();
-        assertFalse(invocation.isVerified());
-
-        //when
-        try {
-            only.verify(new VerificationDataStub(new InvocationBuilder().toInvocationMatcher(), invocation));
-            fail();
-        } catch (MockitoAssertionError e) {}
-
-        //then
-        assertFalse(invocation.isVerified());
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java b/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
deleted file mode 100644
index 82cceeaea7..0000000000
--- a/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockito.verification.VerificationMode;
-
-public class VerificationOverTimeImplTest {
-    @Mock
-    private VerificationMode delegate;
-    private VerificationOverTimeImpl impl;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        impl = new VerificationOverTimeImpl(10, 1000, delegate, true);
-    }
-
-    @Test
-    public void should_return_on_success() {
-        impl.verify(null);
-        verify(delegate).verify(null);
-    }
-
-    @Test
-    public void should_throw_mockito_assertion_error() {
-        MockitoAssertionError toBeThrown = new MockitoAssertionError("message");
-        exception.expect(is(toBeThrown));
-
-        doThrow(toBeThrown).when(delegate).verify(null);
-        impl.verify(null);
-    }
-
-    @Test
-    public void should_deal_with_junit_assertion_error() {
-        ArgumentsAreDifferent toBeThrown = new ArgumentsAreDifferent("message", "wanted", "actual");
-        exception.expect(is(toBeThrown));
-        exception.expectMessage("message");
-
-        doThrow(toBeThrown).when(delegate).verify(null);
-        impl.verify(null);
-    }
-
-    @Test
-    public void should_not_wrap_other_exceptions() {
-        RuntimeException toBeThrown = new RuntimeException();
-        exception.expect(is(toBeThrown));
-
-        doThrow(toBeThrown).when(delegate).verify(null);
-        impl.verify(null);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java
deleted file mode 100644
index 893e3158c1..0000000000
--- a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.argumentmatching;
-
-import static java.util.Collections.singletonList;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.ContainsExtraTypeInfo;
-import org.mockito.internal.matchers.Equals;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings({ "unchecked", "serial" })
-public class ArgumentMatchingToolTest extends TestBase {
-
-    @Test
-    public void shouldNotFindAnySuspiciousMatchersWhenNumberOfArgumentsDoesntMatch() {
-        // given
-        List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(1));
-
-        // when
-        Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10, 20 });
-
-        // then
-        assertEquals(0, suspicious.length);
-    }
-
-    @Test
-    public void shouldNotFindAnySuspiciousMatchersWhenArgumentsMatch() {
-        // given
-        List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(10), new Equals(20));
-
-        // when
-        Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10, 20 });
-
-        // then
-        assertEquals(0, suspicious.length);
-    }
-
-    @Test
-    public void shouldFindSuspiciousMatchers() {
-        // given
-        Equals matcherInt20 = new Equals(20);
-        Long longPretendingAnInt = 20L;
-
-        // when
-        List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(10), matcherInt20);
-        Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10, longPretendingAnInt });
-
-        // then
-        assertEquals(1, suspicious.length);
-        assertEquals(new Integer(1), suspicious[0]);
-    }
-
-    @Test
-    public void shouldNotFindSuspiciousMatchersWhenTypesAreTheSame() {
-        // given
-        Equals matcherWithBadDescription = new Equals(20) {
-            public String toString() {
-                return "10";
-            }
-        };
-        Integer argument = 10;
-
-        // when
-        Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes((List) Arrays.asList(matcherWithBadDescription), new Object[] { argument });
-
-        // then
-        assertEquals(0, suspicious.length);
-    }
-
-    @Test
-    public void shouldWorkFineWhenGivenArgIsNull() {
-        // when
-        Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes((List) Arrays.asList(new Equals(20)), new Object[] { null });
-
-        // then
-        assertEquals(0, suspicious.length);
-    }
-
-    @Test
-    @SuppressWarnings("rawtypes")
-    public void shouldUseMatchersSafely() {
-        // This matcher is evil cause typeMatches(Object) returns true for every passed type but matches(T)
-        // method accepts only Strings. When a Integer is passed (thru the matches(Object) bridge method )  a
-        // ClassCastException will be thrown.
-        class StringMatcher implements ArgumentMatcher<String>, ContainsExtraTypeInfo {
-            @Override
-            public boolean matches(String item) {
-                return true; // in this test we never get here
-            }
-
-            @Override
-            public String toStringWithType() {
-                return "";
-            }
-
-            @Override
-            public boolean typeMatches(Object target) {
-                return true;
-            }
-        }
-
-        // given
-        List<ArgumentMatcher> matchers = (List) singletonList(new StringMatcher());
-
-        // when
-        Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10 });
-
-        // then
-        assertEquals(0, suspicious.length);
-    }
-
-}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
deleted file mode 100644
index 466b5c1a3c..0000000000
--- a/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.checkers;
-
-import static java.util.Arrays.asList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.verification.checkers.AtLeastXNumberOfInvocationsChecker.checkAtLeastNumberOfInvocations;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.exceptions.verification.TooFewActualInvocations;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.verification.InOrderContextImpl;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-
-public class AtLeastXNumberOfInvocationsCheckerTest   {
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Test
-    public void shouldMarkActualInvocationsAsVerifiedInOrder() {
-        InOrderContext context = new InOrderContextImpl();
-        //given
-        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
-        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
-
-        //when
-        checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1, context);
-
-        //then
-        assertThat(invocation.isVerified()).isTrue();
-    }
-
-    @Test
-    public void shouldReportTooFewInvocationsInOrder() {
-        InOrderContext context = new InOrderContextImpl();
-        //given
-        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
-        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("iMethods.simpleMethod()");
-        exception.expectMessage("Wanted *at least* 2 times");
-        exception.expectMessage("But was 1 time");
-
-        //when
-        checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 2, context);
-
-
-    }
-
-    @Test
-    public void shouldMarkActualInvocationsAsVerified() {
-        //given
-        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
-        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
-
-        //when
-        checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1);
-
-        //then
-        assertThat(invocation.isVerified()).isTrue();
-    }
-
-    @Test
-    public void shouldReportTooFewInvocations() {
-        //given
-        Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
-        Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
-
-        exception.expect(TooFewActualInvocations.class);
-        exception.expectMessage("iMethods.simpleMethod()");
-        exception.expectMessage("Wanted *at least* 2 times");
-        exception.expectMessage("But was 1 time");
-
-        //when
-        checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 2);
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
deleted file mode 100644
index 14d7dd9109..0000000000
--- a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.checkers;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Mock;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockito.internal.invocation.*;
-import org.mockito.internal.invocation.mockref.MockReference;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class MissingInvocationCheckerTest extends TestBase {
-
-    private InvocationMatcher wanted;
-    private List<Invocation> invocations;
-
-    @Mock
-    private IMethods mock;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Test
-    public void shouldPassBecauseActualInvocationFound() {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildSimpleMethod().toInvocation());
-
-        MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
-    }
-
-    @Test
-    public void shouldReportWantedButNotInvoked() {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildDifferentMethod().toInvocation());
-
-        exception.expect(WantedButNotInvoked.class);
-        exception.expectMessage("Wanted but not invoked:");
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("However, there was exactly 1 interaction with this mock:");
-        exception.expectMessage("mock.differentMethod();");
-
-        MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
-    }
-
-    @Test
-    public void shouldReportWantedInvocationDiffersFromActual() {
-        wanted = buildIntArgMethod(new InvocationBuilder()).arg(2222).toInvocationMatcher();
-        invocations = asList(buildIntArgMethod(new InvocationBuilder()).arg(1111).toInvocation());
-
-        exception.expect(ArgumentsAreDifferent.class);
-
-        exception.expectMessage("Argument(s) are different! Wanted:");
-        exception.expectMessage("mock.intArgumentMethod(2222);");
-        exception.expectMessage("Actual invocations have different arguments:");
-        exception.expectMessage("mock.intArgumentMethod(1111);");
-
-        MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
-    }
-
-    @Test
-    public void shouldReportUsingInvocationDescription() {
-        wanted = buildIntArgMethod(new CustomInvocationBuilder()).arg(2222).toInvocationMatcher();
-        invocations = singletonList(buildIntArgMethod(new CustomInvocationBuilder()).arg(1111).toInvocation());
-
-        exception.expect(ArgumentsAreDifferent.class);
-
-        exception.expectMessage("Argument(s) are different! Wanted:");
-        exception.expectMessage("mock.intArgumentMethod(MyCoolPrint(2222));");
-        exception.expectMessage("Actual invocations have different arguments:");
-        exception.expectMessage("mock.intArgumentMethod(MyCoolPrint(1111));");
-
-        MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
-    }
-
-    private InvocationBuilder buildIntArgMethod(InvocationBuilder invocationBuilder) {
-        return invocationBuilder.mock(mock).method("intArgumentMethod").argTypes(int.class);
-    }
-
-    private InvocationBuilder buildSimpleMethod() {
-        return new InvocationBuilder().mock(mock).simpleMethod();
-    }
-
-    private InvocationBuilder buildDifferentMethod() {
-        return new InvocationBuilder().mock(mock).differentMethod();
-    }
-
-    static class CustomInvocationBuilder extends InvocationBuilder {
-        @Override
-        protected Invocation createInvocation(MockReference<Object> mockRef, MockitoMethod mockitoMethod, final Object[] arguments,
-            RealMethod realMethod, Location location, int sequenceNumber) {
-            return new InterceptedInvocation(mockRef, mockitoMethod, arguments, realMethod, location, sequenceNumber) {
-                @Override
-                public List<ArgumentMatcher> getArgumentsAsMatchers() {
-                    List<ArgumentMatcher> matchers = new ArrayList<ArgumentMatcher>();
-                    for (final Object argument : getRawArguments()) {
-                        matchers.add(new ArgumentMatcher() {
-                            @Override
-                            public boolean matches(Object a) {
-                                return a == argument;
-                            }
-
-                            @Override
-                            public String toString() {
-                                return "MyCoolPrint(" + argument + ")";
-                            }
-                        });
-                    }
-                    return matchers;
-                }
-            };
-        }
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
deleted file mode 100644
index 87c60d3fbc..0000000000
--- a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.verification.checkers;
-
-import static java.util.Arrays.asList;
-
-import static org.mockito.internal.verification.checkers.MissingInvocationChecker.checkMissingInvocation;
-
-import java.util.List;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.Mock;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.verification.InOrderContextImpl;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockitousage.IMethods;
-
-public class MissingInvocationInOrderCheckerTest  {
-
-    private InvocationMatcher wanted;
-    private List<Invocation> invocations;
-
-    @Mock
-    private IMethods mock;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Rule
-    public MockitoRule mockitoRule = MockitoJUnit.rule();
-
-    private InOrderContext context = new InOrderContextImpl();
-
-    @Before
-    public void setup() {
-    }
-
-    @Test
-    public void shouldPassWhenMatchingInteractionFound() throws Exception {
-
-        invocations = asList(buildSimpleMethod().toInvocation());
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        checkMissingInvocation(invocations, wanted, context);
-    }
-
-    @Test
-    public void shouldReportWantedButNotInvoked() throws Exception {
-        invocations = asList(buildDifferentMethod().toInvocation());
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(WantedButNotInvoked.class);
-        exception.expectMessage("Wanted but not invoked:");
-        exception.expectMessage("mock.simpleMethod()");
-
-        checkMissingInvocation(invocations, wanted, context);
-    }
-
-    @Test
-    public void shouldReportArgumentsAreDifferent() throws Exception {
-        invocations = asList(buildIntArgMethod().arg(1111).toInvocation());
-        wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
-
-        exception.expect(ArgumentsAreDifferent.class);
-
-        exception.expectMessage("Argument(s) are different! Wanted:");
-        exception.expectMessage("mock.intArgumentMethod(2222);");
-        exception.expectMessage("Actual invocations have different arguments:");
-        exception.expectMessage("mock.intArgumentMethod(1111);");
-
-        checkMissingInvocation(invocations, wanted, context);
-
-     }
-
-    @Test
-    public void shouldReportWantedDiffersFromActual() throws Exception {
-
-        Invocation invocation1 = buildIntArgMethod().arg(1111).toInvocation();
-        Invocation invocation2 = buildIntArgMethod().arg(2222).toInvocation();
-
-        context.markVerified(invocation2);
-        invocations = asList(invocation1,invocation2);
-        wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
-
-        exception.expect(VerificationInOrderFailure.class);
-
-        exception.expectMessage("Verification in order failure");
-        exception.expectMessage("Wanted but not invoked:");
-        exception.expectMessage("mock.intArgumentMethod(2222);");
-        exception.expectMessage("Wanted anywhere AFTER following interaction:");
-        exception.expectMessage("mock.intArgumentMethod(2222);");
-
-        checkMissingInvocation(invocations, wanted, context);
-    }
-
-    private InvocationBuilder buildIntArgMethod() {
-        return new InvocationBuilder().mock(mock).method("intArgumentMethod").argTypes(int.class);
-    }
-
-    private InvocationBuilder buildSimpleMethod() {
-        return new InvocationBuilder().mock(mock).simpleMethod();
-    }
-
-    private InvocationBuilder buildDifferentMethod() {
-        return new InvocationBuilder().mock(mock).differentMethod();
-    }
-
-
-}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
deleted file mode 100644
index f6f4bb5121..0000000000
--- a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-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;
-import org.hamcrest.TypeSafeMatcher;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.rules.TestName;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.exceptions.verification.NeverWantedButInvoked;
-import org.mockito.exceptions.verification.TooFewActualInvocations;
-import org.mockito.exceptions.verification.TooManyActualInvocations;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.Invocation;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitousage.IMethods;
-
-@RunWith(MockitoJUnitRunner.class)
-public class NumberOfInvocationsCheckerTest {
-
-    private InvocationMatcher wanted;
-
-    private List<Invocation> invocations;
-
-    @Mock
-    private IMethods mock;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Rule
-    public TestName testName = new TestName();
-
-    @Test
-    public void shouldReportTooFewActual() throws Exception {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
-
-        exception.expect(TooFewActualInvocations.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 100 times");
-        exception.expectMessage("But was 2 times");
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100);
-    }
-
-    @Test
-    public void shouldReportAllInvocationsStackTrace() throws Exception {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
-
-        exception.expect(TooFewActualInvocations.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 100 times");
-        exception.expectMessage("But was 2 times");
-        exception.expectMessage(containsTimes("-> at", 3));
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100);
-    }
-
-    @Test
-    public void shouldNotReportWithLastInvocationStackTraceIfNoInvocationsFound() throws Exception {
-        invocations = emptyList();
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(TooFewActualInvocations.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 100 times");
-        exception.expectMessage("But was 0 times");
-        exception.expectMessage(containsTimes("-> at", 1));
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100);
-    }
-
-    @Test
-    public void shouldReportWithAllInvocationsStackTrace() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-        Invocation second = buildSimpleMethod().toInvocation();
-        Invocation third = buildSimpleMethod().toInvocation();
-
-        invocations = asList(first, second, third);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(TooManyActualInvocations.class);
-        exception.expectMessage("" + first.getLocation());
-        exception.expectMessage("" + second.getLocation());
-        exception.expectMessage("" + third.getLocation());
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 2);
-    }
-
-    @Test
-    public void shouldReportTooManyActual() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-        Invocation second = buildSimpleMethod().toInvocation();
-
-        invocations = asList(first, second);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expectMessage("Wanted 1 time");
-        exception.expectMessage("But was 2 times");
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1);
-    }
-
-    @Test
-    public void shouldReportNeverWantedButInvoked() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-
-        invocations = asList(first);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(NeverWantedButInvoked.class);
-        exception.expectMessage("Never wanted here");
-        exception.expectMessage("But invoked here");
-        exception.expectMessage("" + first.getLocation());
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0);
-    }
-
-    @Test
-    public void shouldMarkInvocationsAsVerified() throws Exception {
-        Invocation invocation = buildSimpleMethod().toInvocation();
-        assertThat(invocation.isVerified()).isFalse();
-
-        invocations = asList(invocation);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1);
-        assertThat(invocation.isVerified()).isTrue();
-    }
-
-    private InvocationBuilder buildSimpleMethod() {
-        return new InvocationBuilder().mock(mock).simpleMethod();
-    }
-
-    private static BaseMatcher<String> containsTimes(String value, int amount) {
-        return new StringContainsNumberMatcher(value, amount);
-    }
-
-    private static class StringContainsNumberMatcher extends TypeSafeMatcher<String> {
-
-        private final String expected;
-
-        private final int amount;
-
-        StringContainsNumberMatcher(String expected, int amount) {
-            this.expected = expected;
-            this.amount = amount;
-        }
-
-        public boolean matchesSafely(String text) {
-            int lastIndex = 0;
-            int count = 0;
-            while (lastIndex != -1) {
-                lastIndex = text.indexOf(expected, lastIndex);
-                if (lastIndex != -1) {
-                    count++;
-                    lastIndex += expected.length();
-                }
-            }
-            return count == amount;
-        }
-
-        public void describeTo(Description description) {
-            description.appendText("containing '" + expected + "' exactly " + amount + " times");
-        }
-
-    }
-}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
deleted file mode 100644
index ca318bd19e..0000000000
--- a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-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;
-import org.hamcrest.Description;
-import org.hamcrest.TypeSafeMatcher;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.verification.InOrderContextImpl;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-
-public class NumberOfInvocationsInOrderCheckerTest {
-
-    private InvocationMatcher wanted;
-    private List<Invocation> invocations;
-    private InOrderContext context;
-
-    private IMethods mock;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Before
-    public void setup() {
-        context = new InOrderContextImpl();
-        mock = mock(IMethods.class, "mock");
-
-    }
-
-    @Test
-    public void shouldPassIfWantedIsZeroAndMatchingChunkIsEmpty() {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = emptyList();
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0, context);
-    }
-
-    @Test
-    public void shouldPassIfChunkMatches() throws Exception {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildSimpleMethod().toInvocation());
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
-    }
-
-    @Test
-    public void shouldReportTooFewInvocations() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-        Invocation second = buildSimpleMethod().toInvocation();
-
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(first, second);
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 4 times");
-        exception.expectMessage("But was 2 times");
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 4, context);
-    }
-
-    @Test
-    public void shouldMarkAsVerifiedInOrder() throws Exception {
-        Invocation invocation = buildSimpleMethod().toInvocation();
-
-        invocations = asList(invocation);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        assertThat(context.isVerified(invocation)).isFalse();
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
-        assertThat(context.isVerified(invocation)).isTrue();
-    }
-
-    @Test
-    public void shouldReportTooFewActual() throws Exception {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 100 times");
-        exception.expectMessage("But was 2 times");
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100, context);
-    }
-
-    @Test
-    public void shouldReportWithAllInvocationsStackTrace() throws Exception {
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 100 times");
-        exception.expectMessage("But was 2 times");
-        exception.expectMessage(containsTimes("-> at", 3));
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100, context);
-
-    }
-
-    @Test
-    public void shouldNotReportWithLastInvocationStackTraceIfNoInvocationsFound() throws Exception {
-        invocations = emptyList();
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 100 times");
-        exception.expectMessage("But was 0 times");
-        exception.expectMessage(containsTimes("-> at", 1));
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100, context);
-    }
-
-    @Test
-    public void shouldReportWithFirstUndesiredInvocationStackTrace() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-        Invocation second = buildSimpleMethod().toInvocation();
-        Invocation third = buildSimpleMethod().toInvocation();
-
-        invocations = asList(first, second, third);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("" + third.getLocation());
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 2, context);
-    }
-
-    @Test
-    public void shouldReportTooManyActual() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-        Invocation second = buildSimpleMethod().toInvocation();
-
-        invocations = asList(first, second);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expectMessage("Wanted 1 time");
-        exception.expectMessage("But was 2 times");
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
-    }
-
-    @Test
-    public void shouldReportNeverWantedButInvoked() throws Exception {
-        Invocation first = buildSimpleMethod().toInvocation();
-
-        invocations = asList(first);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-
-        exception.expect(VerificationInOrderFailure.class);
-        exception.expectMessage("mock.simpleMethod()");
-        exception.expectMessage("Wanted 0 times");
-        exception.expectMessage("But was 1 time:");
-        exception.expectMessage("" + first.getLocation());
-
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0, context);
-    }
-
-    @Test
-    public void shouldMarkInvocationsAsVerified() throws Exception {
-        Invocation invocation = buildSimpleMethod().toInvocation();
-        assertThat(invocation.isVerified()).isFalse();
-
-        invocations = asList(invocation);
-        wanted = buildSimpleMethod().toInvocationMatcher();
-        NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1, context);
-        assertThat(invocation.isVerified()).isTrue();
-    }
-
-    private static BaseMatcher<String> containsTimes(String value, int amount) {
-        return new StringContainsNumberMatcher(value, amount);
-    }
-
-    private static class StringContainsNumberMatcher extends TypeSafeMatcher<String> {
-
-        private final String expected;
-
-        private final int amount;
-
-        StringContainsNumberMatcher(String expected, int amount) {
-            this.expected = expected;
-            this.amount = amount;
-        }
-
-        @Override
-        public boolean matchesSafely(String text) {
-            int lastIndex = 0;
-            int count = 0;
-            while (lastIndex != -1) {
-                lastIndex = text.indexOf(expected, lastIndex);
-                if (lastIndex != -1) {
-                    count++;
-                    lastIndex += expected.length();
-                }
-            }
-            return count == amount;
-        }
-
-        @Override
-        public void describeTo(Description description) {
-            description.appendText("containing '" + expected + "' exactly " + amount + " times");
-        }
-
-    }
-
-    private InvocationBuilder buildSimpleMethod() {
-        return new InvocationBuilder().mock(mock).simpleMethod();
-    }
-}
diff --git a/src/test/java/org/mockito/junit/TestableJUnitRunner.java b/src/test/java/org/mockito/junit/TestableJUnitRunner.java
deleted file mode 100644
index 0b13d9f065..0000000000
--- a/src/test/java/org/mockito/junit/TestableJUnitRunner.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.mockito.junit;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.runners.model.InitializationError;
-import org.mockito.internal.junit.MismatchReportingTestListener;
-import org.mockito.internal.junit.MockitoTestListener;
-import org.mockito.internal.runners.RunnerFactory;
-import org.mockito.internal.runners.StrictRunner;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.internal.util.Supplier;
-
-public class TestableJUnitRunner extends MockitoJUnitRunner {
-
-    private final static ThreadLocal<SimpleMockitoLogger> LOGGER = new ThreadLocal<SimpleMockitoLogger>() {
-        protected SimpleMockitoLogger initialValue() {
-            return new SimpleMockitoLogger();
-        }
-    };
-
-    public TestableJUnitRunner(Class<?> klass) throws InvocationTargetException, InitializationError {
-        super(new StrictRunner(new RunnerFactory().create(klass, new Supplier<MockitoTestListener>() {
-            public MockitoTestListener get() {
-                return new MismatchReportingTestListener(LOGGER.get());
-            }
-        }), klass));
-    }
-
-    public static SimpleMockitoLogger refreshedLogger() {
-        return LOGGER.get().clear();
-    }
-}
diff --git a/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java b/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java
deleted file mode 100644
index 5bbabb8f30..0000000000
--- a/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.runners;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.Description;
-import org.junit.runner.manipulation.Filter;
-import org.junit.runner.manipulation.NoTestsRemainException;
-import org.junit.runner.notification.RunNotifier;
-import org.junit.runners.model.InitializationError;
-import org.mockito.internal.runners.InternalRunner;
-import org.mockito.internal.util.ConsoleMockitoLogger;
-import org.mockitoutil.TestBase;
-
-public class ConsoleSpammingMockitoJUnitRunnerTest extends TestBase {
-
-    private ConsoleSpammingMockitoJUnitRunner runner;
-
-    private MockitoLoggerStub loggerStub;
-
-    private RunNotifier notifier;
-
-    @Before
-    public void setup() throws InitializationError {
-        loggerStub = new MockitoLoggerStub();
-        notifier = new RunNotifier();
-    }
-
-    //TODO add sensible tests
-
-    @Test
-    public void shouldDelegateToGetDescription() throws Exception {
-        //given
-        final Description expectedDescription = Description.createSuiteDescription(this.getClass());
-        runner = new ConsoleSpammingMockitoJUnitRunner(loggerStub, new InternalRunnerStub() {
-            public Description getDescription() {
-                return expectedDescription;
-            }
-        });
-
-        //when
-        Description description = runner.getDescription();
-
-        //then
-        assertEquals(expectedDescription, description);
-    }
-
-    public class MockitoLoggerStub extends ConsoleMockitoLogger {
-
-        StringBuilder loggedInfo = new StringBuilder();
-
-        public void log(Object what) {
-            super.log(what);
-            loggedInfo.append(what);
-        }
-
-        public String getLoggedInfo() {
-            return loggedInfo.toString();
-        }
-    }
-
-    static class InternalRunnerStub implements InternalRunner {
-
-        public Description getDescription() {
-            return null;
-        }
-
-        public void run(RunNotifier notifier) {
-        }
-
-        public void filter(Filter filter) throws NoTestsRemainException {
-        }
-
-    }
-}
diff --git a/src/test/java/org/mockito/verification/NegativeDurationTest.java b/src/test/java/org/mockito/verification/NegativeDurationTest.java
deleted file mode 100644
index ddfe31aa2e..0000000000
--- a/src/test/java/org/mockito/verification/NegativeDurationTest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.verification;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.Mockito;
-import org.mockito.exceptions.misusing.FriendlyReminderException;
-
-public class NegativeDurationTest {
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
-    @Test
-    public void should_throw_exception_when_duration_is_negative_for_timeout_method() {
-        expectedException.expect(FriendlyReminderException.class);
-        expectedException.expectMessage("Don't panic! I'm just a friendly reminder!");
-        Mockito.timeout(-1);
-    }
-
-    @Test
-    public void should_throw_exception_when_duration_is_negative_for_after_method() {
-        expectedException.expect(FriendlyReminderException.class);
-        expectedException.expectMessage("Don't panic! I'm just a friendly reminder!");
-        Mockito.after(-1);
-    }
-}
diff --git a/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java b/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java
deleted file mode 100644
index fa840602f9..0000000000
--- a/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitointegration;
-
-import static org.mockitoutil.ClassLoaders.coverageTool;
-
-import java.util.Set;
-
-import org.hamcrest.Matcher;
-import org.junit.*;
-import org.mockito.Mockito;
-import org.mockitoutil.ClassLoaders;
-
-public class NoByteCodeDependenciesTest {
-
-    private ClassLoader contextClassLoader;
-
-    @Test
-    public void pure_mockito_should_not_depend_bytecode_libraries() throws Exception {
-
-        ClassLoader classLoader_without_bytecode_libraries = ClassLoaders.excludingClassLoader()
-            .withCodeSourceUrlOf(
-                Mockito.class,
-                Matcher.class
-            )
-            .withCodeSourceUrlOf(coverageTool())
-            .without("net.bytebuddy", "org.objenesis")
-            .build();
-
-        Set<String> pureMockitoAPIClasses = ClassLoaders.in(classLoader_without_bytecode_libraries).omit(
-            "bytebuddy", "runners", "junit", "JUnit", "opentest4j").listOwnedClasses();
-        pureMockitoAPIClasses.remove("org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
-        pureMockitoAPIClasses.remove("org.mockito.internal.creation.instance.ObjenesisInstantiator");
-
-        // Remove classes that trigger plugin-loading, since bytebuddy plugins are the default.
-        pureMockitoAPIClasses.remove("org.mockito.internal.debugging.LocationImpl");
-        pureMockitoAPIClasses.remove("org.mockito.internal.exceptions.stacktrace.StackTraceFilter");
-        pureMockitoAPIClasses.remove("org.mockito.internal.util.MockUtil");
-
-        for (String pureMockitoAPIClass : pureMockitoAPIClasses) {
-            checkDependency(classLoader_without_bytecode_libraries, pureMockitoAPIClass);
-        }
-    }
-
-    private void checkDependency(ClassLoader classLoader, String pureMockitoAPIClass) throws ClassNotFoundException {
-        try {
-            Class.forName(pureMockitoAPIClass, true, classLoader);
-        } catch (Throwable e) {
-            e.printStackTrace();
-            throw new AssertionError(String.format("'%s' has some dependency to Byte Buddy or Objenesis", pureMockitoAPIClass));
-        }
-    }
-}
diff --git a/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java b/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
deleted file mode 100644
index 89336ba2a7..0000000000
--- a/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitointegration;
-
-import static org.mockitoutil.ClassLoaders.coverageTool;
-
-import java.util.Set;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.agent.ByteBuddyAgent;
-import org.hamcrest.Matcher;
-import org.junit.Assume;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockitoutil.ClassLoaders;
-import org.objenesis.Objenesis;
-
-public class NoJUnitDependenciesTest {
-
-    @Test
-    public void pure_mockito_should_not_depend_JUnit___ByteBuddy() throws Exception {
-        Assume.assumeTrue("ByteBuddyMockMaker".equals(Plugins.getMockMaker().getClass().getSimpleName()));
-
-        ClassLoader classLoader_without_JUnit = ClassLoaders.excludingClassLoader()
-                .withCodeSourceUrlOf(
-                        Mockito.class,
-                        Matcher.class,
-                        ByteBuddy.class,
-                        ByteBuddyAgent.class,
-                        Objenesis.class
-                )
-                .withCodeSourceUrlOf(coverageTool())
-                .without("junit", "org.junit", "org.opentest4j")
-                .build();
-
-        Set<String> pureMockitoAPIClasses = ClassLoaders.in(classLoader_without_JUnit).omit("runners", "junit", "JUnit", "opentest4j").listOwnedClasses();
-
-        // The later class is required to be initialized before any inline mock maker classes can be loaded.
-        checkDependency(classLoader_without_JUnit, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
-        pureMockitoAPIClasses.remove("org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
-
-        for (String pureMockitoAPIClass : pureMockitoAPIClasses) {
-            checkDependency(classLoader_without_JUnit, pureMockitoAPIClass);
-        }
-    }
-
-    private void checkDependency(ClassLoader classLoader_without_JUnit, String pureMockitoAPIClass) throws ClassNotFoundException {
-        try {
-            Class.forName(pureMockitoAPIClass, true, classLoader_without_JUnit);
-        } catch (Throwable e) {
-            e.printStackTrace();
-            throw new AssertionError(String.format("'%s' has some dependency to JUnit", pureMockitoAPIClass));
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/CompilationWarningsTest.java b/src/test/java/org/mockitousage/CompilationWarningsTest.java
deleted file mode 100644
index 0731aaff76..0000000000
--- a/src/test/java/org/mockitousage/CompilationWarningsTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-import static org.mockito.BDDMockito.*;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-
-public class CompilationWarningsTest {
-
-    @Before
-    public void pay_attention_to_compilation_warnings_and_JDK_version() {
-    }
-
-    @Test
-    public void no_warnings_for_most_common_api() throws Exception {
-        doReturn(null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doReturn("a", 12).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doReturn(1000).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doThrow(new NullPointerException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doThrow(new NullPointerException(), new IllegalArgumentException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doThrow(NullPointerException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-
-        doAnswer(ignore()).doReturn(null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doAnswer(ignore()).doReturn("a", 12).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doAnswer(ignore()).doReturn(1000).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doAnswer(ignore()).doThrow(new NullPointerException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doAnswer(ignore()).doThrow(new NullPointerException(), new IllegalArgumentException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doAnswer(ignore()).doThrow(NullPointerException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(null);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn("a", 12L);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(1000);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(new NullPointerException());
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(new NullPointerException(), new IllegalArgumentException());
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(NullPointerException.class);
-
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(null);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn("a", 12L);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(1000);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenThrow(new NullPointerException());
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenThrow(new NullPointerException(), new IllegalArgumentException());
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenThrow(NullPointerException.class);
-
-        willReturn(null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willReturn("a", 12).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willReturn(1000).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willThrow(new NullPointerException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willThrow(new NullPointerException(), new IllegalArgumentException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willThrow(NullPointerException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-
-        willAnswer(ignore()).willReturn(null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willAnswer(ignore()).willReturn("a", 12).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willAnswer(ignore()).willReturn(1000).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willAnswer(ignore()).willThrow(new NullPointerException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willAnswer(ignore()).willThrow(new NullPointerException(), new IllegalArgumentException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        willAnswer(ignore()).willThrow(NullPointerException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(null);
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn("a", 12L);
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(1000);
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(new NullPointerException());
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(new NullPointerException(), new IllegalArgumentException());
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(NullPointerException.class);
-
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(null);
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn("a", 12L);
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(1000);
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willThrow(new NullPointerException());
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willThrow(new NullPointerException(), new IllegalArgumentException());
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willThrow(NullPointerException.class);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void heap_pollution_JDK7plus_warning_avoided_BUT_now_unchecked_generic_array_creation_warnings_ON_JDK5plus_environment() throws Exception {
-        doThrow(NullPointerException.class, IllegalArgumentException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(NullPointerException.class, IllegalArgumentException.class);
-        doAnswer(ignore()).doThrow(NullPointerException.class, IllegalArgumentException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-
-        willThrow(NullPointerException.class, IllegalArgumentException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(NullPointerException.class, IllegalArgumentException.class);
-        willAnswer(ignore()).willThrow(NullPointerException.class, IllegalArgumentException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-    }
-
-    @Test
-    public void unchecked_confusing_null_argument_warnings() throws Exception {
-        doReturn(null, (Object[]) null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        doAnswer(ignore()).doReturn(null, (Object[]) null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(null, (Object[]) null);
-        when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(null, (Object[]) null);
-        willReturn(null, (Object[]) null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(null, (Object[]) null);
-        willAnswer(ignore()).willReturn(null, (Object[]) null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
-        given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(null, (Object[]) null);
-    }
-
-    private static Answer<?> ignore() {
-        return new Answer<Object>() {
-            @Override
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                return null;
-            }
-        };
-    }
-}
diff --git a/src/test/java/org/mockitousage/IMethods.java b/src/test/java/org/mockitousage/IMethods.java
deleted file mode 100644
index 69d1d039e8..0000000000
--- a/src/test/java/org/mockitousage/IMethods.java
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-import java.io.IOException;
-import java.nio.charset.CharacterCodingException;
-import java.util.*;
-
-public interface IMethods {
-
-    boolean booleanReturningMethod();
-
-    Boolean booleanObjectReturningMethod();
-
-    byte byteReturningMethod();
-
-    Byte byteObjectReturningMethod();
-
-    short shortReturningMethod();
-
-    Short shortObjectReturningMethod();
-
-    char charReturningMethod();
-
-    Character charObjectReturningMethod();
-
-    int intReturningMethod();
-
-    Integer integerReturningMethod();
-
-    long longReturningMethod();
-
-    Long longObjectReturningMethod();
-
-    float floatReturningMethod();
-
-    Float floatObjectReturningMethod();
-
-    double doubleReturningMethod();
-
-    Double doubleObjectReturningMethod();
-
-    Object objectReturningMethod(Object ... objects);
-
-    Object objectReturningMethodNoArgs();
-
-    String oneArg(boolean value);
-
-    String oneArg(Boolean value);
-
-    String forBoolean(Boolean value);
-
-    String oneArg(byte value);
-
-    String oneArg(Byte value);
-
-    String forByte(Byte value);
-
-    String oneArg(short value);
-
-    String oneArg(Short value);
-
-    String forShort(Short value);
-
-    String oneArg(char value);
-
-    String oneArg(Character value);
-
-    String forCharacter(Character value);
-
-    String oneArg(int value);
-
-    String oneArg(Integer value);
-
-    String forInteger(Integer value);
-
-    String oneArg(long value);
-
-    String oneArg(Long value);
-
-    String forLong(Long value);
-
-    String oneArg(float value);
-
-    String oneArg(Float value);
-
-    String forFloat(Float value);
-
-    String oneArg(double value);
-
-    String oneArg(Double value);
-
-    String forDouble(Double value);
-
-    String oneArg(Object value);
-
-    String oneArg(String value);
-
-    String throwsNothing(boolean value);
-
-    String throwsIOException(int count) throws IOException;
-
-    String throwsError(int count);
-
-    String simpleMethod();
-
-    String differentMethod();
-
-    String differentMethod(String argument);
-
-    String otherMethod();
-
-    String simpleMethod(String argument);
-
-    String simpleMethod(Collection<?> collection);
-
-    String simpleMethod(Object argument);
-
-    String simpleMethod(int argument);
-
-    String simpleMethod(String argOne, Integer argTwo);
-
-    String simpleMethod(String one, Integer two, Integer three, Integer four, Integer five);
-
-    String simpleMethod(String one, Integer two, Integer three, Integer four, Integer five, Integer six);
-
-    String simpleMethod(String one, String[] two);
-
-    Object threeArgumentMethod(int valueOne, Object valueTwo, String valueThree);
-
-    String threeArgumentMethodWithStrings(int valueOne, String valueTwo, String valueThree);
-
-    String fourArgumentMethod(int valueOne, String valueTwo, String valueThree, boolean[] array);
-
-    void twoArgumentMethod(int one, int two);
-
-    void arrayMethod(String[] strings);
-
-    String oneArray(boolean[] array);
-
-    String oneArray(byte[] array);
-
-    String oneArray(char[] array);
-
-    String oneArray(double[] array);
-
-    String oneArray(float[] array);
-
-    String oneArray(int[] array);
-
-    String oneArray(long[] array);
-
-    String oneArray(short[] array);
-
-    String oneArray(Object[] array);
-
-    String canThrowException() throws CharacterCodingException;
-
-    String oneArray(String[] array);
-
-    void varargsString(int i, String... string);
-
-    Object varargsObject(int i, Object... object);
-
-    void varargsbyte(byte... bytes);
-
-    int varargs(Object ... object);
-
-    String varargsReturningString(Object ... object);
-
-    int varargs(String ... string);
-
-    void mixedVarargs(Object i, String ... string);
-
-    String mixedVarargsReturningString(Object i, String ... string);
-
-    String[] mixedVarargsReturningStringArray(Object i, String ... string);
-
-    Object[] mixedVarargsReturningObjectArray(Object i, String ... string);
-
-    List<String> listReturningMethod(Object ... objects);
-
-    LinkedList<String> linkedListReturningMethod();
-
-    String toString();
-
-    String toString(String foo);
-
-    void voidMethod();
-
-    Void voidReturningMethod();
-
-    String forList(List<String> list);
-
-    String forSet(Set<String> anySet);
-
-    String forMap(Map<String, String> map);
-
-    String forCollection(Collection<String> collection);
-
-    String forIterable(Iterable<String> iterable);
-
-    Object[] arrayReturningMethod();
-
-    IMethods iMethodsReturningMethod();
-
-    String stringReturningMethod();
-
-    Object objectArgMethod(Object str);
-
-    Object listArgMethod(List<String> list);
-
-    Object collectionArgMethod(Collection<String> collection);
-
-    Object iterableArgMethod(Iterable<String> collection);
-
-    Object setArgMethod(Set<String> set);
-
-    void longArg(long longArg);
-
-    void intArgumentMethod(int i);
-
-    int intArgumentReturningInt(int i);
-
-    boolean equals(String str);
-
-    boolean equals();
-
-    int hashCode(String str);
-
-    int toIntPrimitive(Integer i);
-
-    Integer toIntWrapper(int i);
-
-    String forObject(Object object);
-
-    <T> String genericToString(T arg);
-}
diff --git a/src/test/java/org/mockitousage/PlaygroundTest.java b/src/test/java/org/mockitousage/PlaygroundTest.java
deleted file mode 100644
index b8aa49bfde..0000000000
--- a/src/test/java/org/mockitousage/PlaygroundTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitoutil.TestBase;
-
-public class PlaygroundTest extends TestBase {
-    static class Foo {
-
-        int doSomeThing() {
-            return 0;
-        }
-
-        protected String getStuff() {
-            return "foo";
-        }
-    }
-
-    class Boo {
-        final public Object withLong(long y) {
-                         return "";
-        }
-
-        public Object foo() {
-                   return "";
-        }
-    }
-
-    Foo mock;
-    @Mock IMethods mockTwo;
-
-    @Test
-    public void spyInAction() {
-
-    }
-
-    @Test
-    public void partialMockInAction() {
-//        mock = mock(Foo.class, withSettings()
-//            .defaultBehavior(CALLS_REAL_METHODS);
-
-//        mock = mock(Foo.class, withSettings()
-//            .defaultMockAnswer(CALLS_REAL_METHODS);
-
-//        mock = mock(Foo.class, withSettings()
-//            .defaultAnswer(CALLS_REAL_METHODS);
-
-//        mock = mock(Foo.class, CALLS_REAL_METHODS);
-
-//        mock = mock(Foo.class, withSettings()
-//            .defaultBehavior(CALLS_REAL_METHODS)
-//            .createUsingDefaultConstructor();
-//
-//        mock = mock(Foo.class, withSettings()
-//            .defaultBehavior(CALLS_REAL_METHODS)
-//            .createPassingArguments("some arg", 1);
-//
-//        spy = spy(Foo.class, "some arg", 1);
-//
-//            .withName("foo")
-//            .withDefaultBehavior(RETURNS_SMART_NULLS)
-//            .withInterfaces(Bar.class);
-//
-//        mock = mock(Foo.class)
-//            .name("foo")
-//            .defaultBehavior(RETURNS_SMART_NULLS)
-//            .interfaces(Bar.class);
-//
-//        mock = mock(Foo.class)
-//            .named("foo")
-//            .byDefault(RETURNS_SMART_NULLS)
-//            .alsoImplements(Bar.class, Bar2.class);
-//
-//        mock = mock(Foo.class)
-//            hasName("foo");
-
-//        when(mock.getStuff()).thenReturn("aha!");
-//        when(mock.doSomeThing()).thenCallRealMethod();
-//
-
-//        mock.doSomeThing();
-    }
-
-//    interface Colored {
-//
-//    }
-//
-//    interface Bar {
-//        <T extends Foo & Colored> T getColoredPoint();
-//    }
-//
-//    @Test
-//    public void testname() throws Exception {
-//        when(mock.get()).then(returnArgument());
-//
-//        Bar mock = mock(Bar.class);
-//        when(mock.getColoredPoint()).thenReturn(new Foo());
-//    }
-}
diff --git a/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java b/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
deleted file mode 100644
index 4dbbe88ef5..0000000000
--- a/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import org.junit.Test;
-import org.mockito.*;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class CaptorAnnotationTest extends TestBase {
-
-    @Retention(RetentionPolicy.RUNTIME)
-    public @interface NotAMock {
-    }
-
-    @Captor
-    final ArgumentCaptor<String> finalCaptor = ArgumentCaptor.forClass(String.class);
-
-    @Captor
-    ArgumentCaptor<List<List<String>>> genericsCaptor;
-
-    @SuppressWarnings("rawtypes")
-    @Captor
-    ArgumentCaptor nonGenericCaptorIsAllowed;
-
-    @Mock
-    MockInterface mockInterface;
-
-    @NotAMock
-    Set<?> notAMock;
-
-    public interface MockInterface {
-        void testMe(String simple, List<List<String>> genericList);
-    }
-
-    @Test
-    public void testNormalUsage() {
-
-        MockitoAnnotations.initMocks(this);
-
-        // check if assigned correctly
-        assertNotNull(finalCaptor);
-        assertNotNull(genericsCaptor);
-        assertNotNull(nonGenericCaptorIsAllowed);
-        assertNull(notAMock);
-
-        // use captors in the field to be sure they are cool
-        String argForFinalCaptor = "Hello";
-        ArrayList<List<String>> argForGenericsCaptor = new ArrayList<List<String>>();
-
-        mockInterface.testMe(argForFinalCaptor, argForGenericsCaptor);
-
-        Mockito.verify(mockInterface).testMe(finalCaptor.capture(), genericsCaptor.capture());
-
-        assertEquals(argForFinalCaptor, finalCaptor.getValue());
-        assertEquals(argForGenericsCaptor, genericsCaptor.getValue());
-
-    }
-
-    public static class WrongType {
-        @Captor
-        List<?> wrongType;
-    }
-
-    @Test
-    public void shouldScreamWhenWrongTypeForCaptor() {
-        try {
-            MockitoAnnotations.initMocks(new WrongType());
-            fail();
-        } catch (MockitoException e) {}
-    }
-
-    public static class ToManyAnnotations {
-        @Captor
-        @Mock
-        ArgumentCaptor<List> missingGenericsField;
-    }
-
-    @Test
-    public void shouldScreamWhenMoreThanOneMockitoAnnotation() {
-        try {
-            MockitoAnnotations.initMocks(new ToManyAnnotations());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e)
-                .hasMessageContaining("missingGenericsField")
-                .hasMessageContaining("multiple Mockito annotations");
-        }
-    }
-
-    @Test
-    public void shouldScreamWhenInitializingCaptorsForNullClass() throws Exception {
-        try {
-            MockitoAnnotations.initMocks(null);
-            fail();
-        } catch (MockitoException e) {
-        }
-    }
-
-    @Test
-    public void shouldLookForAnnotatedCaptorsInSuperClasses() throws Exception {
-        Sub sub = new Sub();
-        MockitoAnnotations.initMocks(sub);
-
-        assertNotNull(sub.getCaptor());
-        assertNotNull(sub.getBaseCaptor());
-        assertNotNull(sub.getSuperBaseCaptor());
-    }
-
-    class SuperBase {
-        @Captor
-        private ArgumentCaptor<IMethods> mock;
-
-        public ArgumentCaptor<IMethods> getSuperBaseCaptor() {
-            return mock;
-        }
-    }
-
-    class Base extends SuperBase {
-        @Captor
-        private ArgumentCaptor<IMethods> mock;
-
-        public ArgumentCaptor<IMethods> getBaseCaptor() {
-            return mock;
-        }
-    }
-
-    class Sub extends Base {
-        @Captor
-        private ArgumentCaptor<IMethods> mock;
-
-        public ArgumentCaptor<IMethods> getCaptor() {
-            return mock;
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java b/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java
deleted file mode 100644
index 11f3255fca..0000000000
--- a/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.junit.Assert.*;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.configuration.AnnotationEngine;
-import org.mockito.configuration.DefaultMockitoConfiguration;
-import org.mockito.internal.configuration.ConfigurationAccess;
-import org.mockito.internal.configuration.IndependentAnnotationEngine;
-import org.mockitoutil.TestBase;
-
-public class DeprecatedAnnotationEngineApiTest extends TestBase {
-
-    @After
-    public void goBackToDefaultConfiguration() {
-        ConfigurationAccess.getConfig().overrideAnnotationEngine(null);
-    }
-
-    class SimpleTestCase {
-        @InjectMocks Tested tested = new Tested();
-        @Mock Dependency mock;
-    }
-
-    class Tested {
-        Dependency dependency;
-        public void setDependency(Dependency dependency) {
-            this.dependency = dependency;
-        }
-    }
-
-    class Dependency {}
-
-    @Test
-    public void shouldInjectMocksIfThereIsNoUserDefinedEngine() throws Exception {
-        //given
-        AnnotationEngine defaultEngine = new DefaultMockitoConfiguration().getAnnotationEngine();
-        ConfigurationAccess.getConfig().overrideAnnotationEngine(defaultEngine);
-        SimpleTestCase test = new SimpleTestCase();
-
-        //when
-        MockitoAnnotations.initMocks(test);
-
-        //then
-        assertNotNull(test.mock);
-        assertNotNull(test.tested.dependency);
-        assertSame(test.mock, test.tested.dependency);
-    }
-
-    @Test
-    public void shouldRespectUsersEngine() throws Exception {
-        //given
-        AnnotationEngine customizedEngine = new IndependentAnnotationEngine() { /**/ };
-        ConfigurationAccess.getConfig().overrideAnnotationEngine(customizedEngine);
-        SimpleTestCase test = new SimpleTestCase();
-
-        //when
-        MockitoAnnotations.initMocks(test);
-
-        //then
-        assertNotNull(test.mock);
-        assertNull(test.tested.dependency);
-    }
-}
diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
deleted file mode 100644
index 8523ff662a..0000000000
--- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import java.util.AbstractCollection;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.internal.TextListener;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitousage.examples.use.ArticleCalculator;
-import org.mockitousage.examples.use.ArticleDatabase;
-import org.mockitousage.examples.use.ArticleManager;
-
-public class MockInjectionUsingConstructorTest {
-
-    @Mock private ArticleCalculator calculator;
-    @Mock private ArticleDatabase database;
-
-    @InjectMocks private ArticleManager articleManager;
-    @Spy @InjectMocks private ArticleManager spiedArticleManager;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Before public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void shouldNotFailWhenNotInitialized() {
-        assertNotNull(articleManager);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void innerMockShouldRaiseAnExceptionThatChangesOuterMockBehavior() {
-        when(calculator.countArticles("new")).thenThrow(new IllegalArgumentException());
-
-        articleManager.updateArticleCounters("new");
-    }
-
-    @Test
-    public void mockJustWorks() {
-        articleManager.updateArticleCounters("new");
-    }
-
-    @Test
-    public void constructor_is_called_for_each_test_in_test_class() throws Exception {
-        // given
-        junit_test_with_3_tests_methods.constructor_instantiation = 0;
-        JUnitCore jUnitCore = new JUnitCore();
-        jUnitCore.addListener(new TextListener(System.out));
-
-        // when
-        jUnitCore.run(junit_test_with_3_tests_methods.class);
-
-        // then
-        assertThat(junit_test_with_3_tests_methods.constructor_instantiation).isEqualTo(3);
-    }
-
-    @Test
-    public void objects_created_with_constructor_initialization_can_be_spied() throws Exception {
-        assertFalse(MockUtil.isMock(articleManager));
-        assertTrue(MockUtil.isMock(spiedArticleManager));
-    }
-
-    @Test
-    public void should_report_failure_only_when_object_initialization_throws_exception() throws Exception {
-
-        try {
-            MockitoAnnotations.initMocks(new ATest());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage()).contains("failingConstructor").contains("constructor").contains("threw an exception");
-            assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
-        }
-    }
-
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class junit_test_with_3_tests_methods {
-        private static int constructor_instantiation = 0;
-
-        @Mock List<?> some_collaborator;
-        @InjectMocks some_class_with_parametered_constructor should_be_initialized_3_times;
-
-        @Test public void test_1() { }
-        @Test public void test_2() { }
-        @Test public void test_3() { }
-
-        private static class some_class_with_parametered_constructor {
-            public some_class_with_parametered_constructor(List<?> collaborator) {
-                constructor_instantiation++;
-            }
-        }
-    }
-
-    private static class FailingConstructor {
-        FailingConstructor(Set<?> set) {
-            throw new IllegalStateException("always fail");
-        }
-    }
-
-    @Ignore("don't run this code in the test runner")
-    private static class ATest {
-        @Mock Set<?> set;
-        @InjectMocks FailingConstructor failingConstructor;
-    }
-
-
-    @Test
-    public void injectMocksMustFailWithInterface() throws Exception {
-        class TestCase {
-            @InjectMocks
-            IMethods f;
-        }
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'IMethods' is an interface");
-
-
-        initMocks(new TestCase());
-    }
-
-    @Test
-    public void injectMocksMustFailWithEnum() throws Exception {
-        class TestCase {
-            @InjectMocks
-            TimeUnit f;
-        }
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'TimeUnit' is an enum");
-
-        initMocks(new TestCase());
-    }
-
-    @Test
-    public void injectMocksMustFailWithAbstractClass() throws Exception {
-        class TestCase {
-            @InjectMocks
-            AbstractCollection<?> f;
-        }
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'AbstractCollection' is an abstract class");
-
-        initMocks(new TestCase());
-    }
-
-    @Test
-    public void injectMocksMustFailWithNonStaticInnerClass() throws Exception {
-        class TestCase {
-            class InnerClass {}
-            @InjectMocks
-            InnerClass f;
-        }
-
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'InnerClass' is an inner non static class");
-
-        initMocks(new TestCase());
-    }
-
-    static class  StaticInnerClass {}
-    @Test
-    public void injectMocksMustSucceedWithStaticInnerClass() throws Exception {
-        class TestCase {
-            @InjectMocks
-            StaticInnerClass f;
-        }
-
-        TestCase testClass = new TestCase();
-        initMocks(testClass);
-
-        assertThat(testClass.f).isInstanceOf(StaticInnerClass.class);
-    }
-
-    @Test
-    public void injectMocksMustSucceedWithInstance() throws Exception {
-        class TestCase {
-            @InjectMocks
-            StaticInnerClass f = new StaticInnerClass();
-        }
-
-        TestCase testClass = new TestCase();
-        StaticInnerClass original = testClass.f;
-        initMocks(testClass);
-
-        assertThat(testClass.f).isSameAs(original);
-    }
-
-
-
-
-}
diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java b/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
deleted file mode 100644
index b901ef14fe..0000000000
--- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.junit.Assert.*;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.MockUtil;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings({"unchecked", "unused"})
-public class MockInjectionUsingSetterOrPropertyTest extends TestBase {
-
-    private SuperUnderTesting superUnderTestWithoutInjection = new SuperUnderTesting();
-    @InjectMocks private SuperUnderTesting superUnderTest = new SuperUnderTesting();
-    @InjectMocks private BaseUnderTesting baseUnderTest = new BaseUnderTesting();
-    @InjectMocks private SubUnderTesting subUnderTest = new SubUnderTesting();
-    @InjectMocks private OtherBaseUnderTesting otherBaseUnderTest = new OtherBaseUnderTesting();
-    @InjectMocks private HasTwoFieldsWithSameType hasTwoFieldsWithSameType = new HasTwoFieldsWithSameType();
-
-    private BaseUnderTesting baseUnderTestingInstance = new BaseUnderTesting();
-    @InjectMocks private BaseUnderTesting initializedBase = baseUnderTestingInstance;
-    @InjectMocks private BaseUnderTesting notInitializedBase;
-
-    @Spy @InjectMocks private SuperUnderTesting initializedSpy = new SuperUnderTesting();
-    @Spy @InjectMocks private SuperUnderTesting notInitializedSpy;
-
-    @Mock private Map<?, ?> map;
-    @Mock private List<?> list;
-    @Mock private Set<?> histogram1;
-    @Mock private Set<?> histogram2;
-    @Mock private IMethods candidate2;
-
-    @Spy private TreeSet<String> searchTree = new TreeSet<String>();
-
-    @Before
-    public void enforces_new_instances() {
-        // initMocks called in TestBase Before method, so instances are not the same
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void should_keep_same_instance_if_field_initialized() {
-        assertSame(baseUnderTestingInstance, initializedBase);
-    }
-
-    @Test
-    public void should_initialize_annotated_field_if_null() {
-        assertNotNull(notInitializedBase);
-    }
-
-    @Test
-    public void should_inject_mocks_in_spy() {
-        assertNotNull(initializedSpy.getAList());
-        assertTrue(MockUtil.isMock(initializedSpy));
-    }
-
-    @Test
-    public void should_initialize_spy_if_null_and_inject_mocks() {
-        assertNotNull(notInitializedSpy);
-        assertNotNull(notInitializedSpy.getAList());
-        assertTrue(MockUtil.isMock(notInitializedSpy));
-    }
-
-    @Test
-    public void should_inject_mocks_if_annotated() {
-        MockitoAnnotations.initMocks(this);
-        assertSame(list, superUnderTest.getAList());
-    }
-
-    @Test
-    public void should_not_inject_if_not_annotated() {
-        MockitoAnnotations.initMocks(this);
-        assertNull(superUnderTestWithoutInjection.getAList());
-    }
-
-    @Test
-    public void should_inject_mocks_for_class_hierarchy_if_annotated() {
-        MockitoAnnotations.initMocks(this);
-        assertSame(list, baseUnderTest.getAList());
-        assertSame(map, baseUnderTest.getAMap());
-    }
-
-    @Test
-    public void should_inject_mocks_by_name() {
-        MockitoAnnotations.initMocks(this);
-        assertSame(histogram1, subUnderTest.getHistogram1());
-        assertSame(histogram2, subUnderTest.getHistogram2());
-    }
-
-    @Test
-    public void should_inject_spies() {
-        MockitoAnnotations.initMocks(this);
-        assertSame(searchTree, otherBaseUnderTest.getSearchTree());
-    }
-
-    @Test
-    public void should_insert_into_field_with_matching_name_when_multiple_fields_of_same_type_exists_in_injectee() {
-        MockitoAnnotations.initMocks(this);
-        assertNull("not injected, no mock named 'candidate1'", hasTwoFieldsWithSameType.candidate1);
-        assertNotNull("injected, there's a mock named 'candidate2'", hasTwoFieldsWithSameType.candidate2);
-    }
-
-    @Test
-    public void should_instantiate_inject_mock_field_if_possible() throws Exception {
-        assertNotNull(notInitializedBase);
-    }
-
-    @Test
-    public void should_keep_instance_on_inject_mock_field_if_present() throws Exception {
-        assertSame(baseUnderTestingInstance, initializedBase);
-    }
-
-    @Test
-    public void should_report_nicely() throws Exception {
-        Object failing = new Object() {
-            @InjectMocks ThrowingConstructor failingConstructor;
-        };
-        try {
-            MockitoAnnotations.initMocks(failing);
-            fail();
-        } catch (MockitoException e) {
-            Assertions.assertThat(e.getMessage()).contains("failingConstructor").contains("constructor").contains("threw an exception");
-            Assertions.assertThat(e.getCause()).isInstanceOf(RuntimeException.class);
-        }
-    }
-
-    static class ThrowingConstructor {
-        ThrowingConstructor() { throw new RuntimeException("aha"); }
-    }
-
-    static class SuperUnderTesting {
-        private List<?> aList;
-
-        public List<?> getAList() { return aList; }
-    }
-
-    static class BaseUnderTesting extends SuperUnderTesting {
-        private Map<?, ?> aMap;
-
-        public Map<?, ?> getAMap() { return aMap; }
-    }
-
-    static class OtherBaseUnderTesting extends SuperUnderTesting {
-        private TreeSet<?> searchTree;
-
-        public TreeSet<?> getSearchTree() { return searchTree; }
-    }
-
-    static class SubUnderTesting extends BaseUnderTesting {
-        private Set<?> histogram1;
-        private Set<?> histogram2;
-
-        public Set<?> getHistogram1() { return histogram1; }
-        public Set<?> getHistogram2() { return histogram2; }
-    }
-
-    static class HasTwoFieldsWithSameType {
-        private IMethods candidate1;
-        private IMethods candidate2;
-    }
-}
diff --git a/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java b/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
deleted file mode 100644
index 6a3e1a478b..0000000000
--- a/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.junit.Assert.assertTrue;
-import static org.mockito.internal.util.MockUtil.isMock;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.mockito.internal.util.MockUtil;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class SpyAnnotationInitializedInBaseClassTest extends TestBase {
-
-    class BaseClass {
-
-        @Spy
-        List list = new LinkedList();
-    }
-
-    class SubClass extends BaseClass {
-
-    }
-
-    @Test
-    public void shouldInitSpiesInBaseClass() throws Exception {
-        //given
-        SubClass subClass = new SubClass();
-        //when
-        MockitoAnnotations.initMocks(subClass);
-        //then
-        assertTrue(MockUtil.isMock(subClass.list));
-    }
-
-    @Before
-    @Override
-    public void init() {
-        //we need to get rid of parent implementation this time
-    }
-
-    @Before
-    public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Spy
-    List spyInBaseclass = new LinkedList();
-
-    public static class SubTest extends SpyAnnotationInitializedInBaseClassTest {
-
-        @Spy
-        List spyInSubclass = new LinkedList();
-
-        @Test
-        public void shouldInitSpiesInHierarchy() throws Exception {
-            assertTrue(isMock(spyInSubclass));
-            assertTrue(isMock(spyInBaseclass));
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java b/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
deleted file mode 100644
index e19b2cae39..0000000000
--- a/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.AbstractList;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unused")
-public class SpyAnnotationTest extends TestBase {
-
-    @Spy
-    final List<String> spiedList = new ArrayList<String>();
-
-    @Spy
-    InnerStaticClassWithNoArgConstructor staticTypeWithNoArgConstructor;
-
-    @Spy
-    InnerStaticClassWithoutDefinedConstructor staticTypeWithoutDefinedConstructor;
-
-    @Spy
-    MockTranslator translator;
-
-    @Rule
-    public final ExpectedException shouldThrow = ExpectedException.none();
-
-    @Test
-    public void should_init_spy_by_instance() throws Exception {
-        doReturn("foo").when(spiedList).get(10);
-        assertEquals("foo", spiedList.get(10));
-        assertTrue(spiedList.isEmpty());
-    }
-
-    @Test
-    public void should_init_spy_and_automatically_create_instance() throws Exception {
-        when(staticTypeWithNoArgConstructor.toString()).thenReturn("x");
-        when(staticTypeWithoutDefinedConstructor.toString()).thenReturn("y");
-        assertEquals("x", staticTypeWithNoArgConstructor.toString());
-        assertEquals("y", staticTypeWithoutDefinedConstructor.toString());
-    }
-
-    @Test
-    public void should_allow_spying_on_interfaces() throws Exception {
-        class WithSpy {
-            @Spy
-            List<String> list;
-        }
-
-        WithSpy withSpy = new WithSpy();
-        MockitoAnnotations.initMocks(withSpy);
-        when(withSpy.list.size()).thenReturn(3);
-        assertEquals(3, withSpy.list.size());
-    }
-
-    @Test
-    public void should_allow_spying_on_interfaces_when_instance_is_concrete() throws Exception {
-        class WithSpy {
-            @Spy
-            List<String> list = new LinkedList<String>();
-        }
-        WithSpy withSpy = new WithSpy();
-
-        //when
-        MockitoAnnotations.initMocks(withSpy);
-
-        //then
-        verify(withSpy.list, never()).clear();
-    }
-
-    @Test
-    public void should_report_when_no_arg_less_constructor() throws Exception {
-        class FailingSpy {
-            @Spy
-            NoValidConstructor noValidConstructor;
-        }
-
-        try {
-            MockitoAnnotations.initMocks(new FailingSpy());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage()).contains("Please ensure that the type")
-                    .contains(NoValidConstructor.class.getSimpleName())
-                    .contains("has a no-arg constructor");
-        }
-    }
-
-    @Test
-    public void should_report_when_constructor_is_explosive() throws Exception {
-        class FailingSpy {
-            @Spy
-            ThrowingConstructor throwingConstructor;
-        }
-
-        try {
-            MockitoAnnotations.initMocks(new FailingSpy());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e.getMessage()).contains("Unable to create mock instance");
-        }
-    }
-
-    @Test
-    public void should_spy_abstract_class() throws Exception {
-        class SpyAbstractClass {
-            @Spy
-            AbstractList<String> list;
-
-            List<String> asSingletonList(String s) {
-                when(list.size()).thenReturn(1);
-                when(list.get(0)).thenReturn(s);
-                return list;
-            }
-        }
-        SpyAbstractClass withSpy = new SpyAbstractClass();
-        MockitoAnnotations.initMocks(withSpy);
-        assertEquals(Arrays.asList("a"), withSpy.asSingletonList("a"));
-    }
-
-    @Test
-    public void should_spy_inner_class() throws Exception {
-
-        class WithMockAndSpy {
-            @Spy
-            private InnerStrength strength;
-            @Mock
-            private List<String> list;
-
-            abstract class InnerStrength {
-                private final String name;
-
-                InnerStrength() {
-                    // Make sure that @Mock fields are always injected before @Spy fields.
-                    assertNotNull(list);
-                    // Make sure constructor is indeed called.
-                    this.name = "inner";
-                }
-
-                abstract String strength();
-
-                String fullStrength() {
-                    return name + " " + strength();
-                }
-            }
-        }
-        WithMockAndSpy outer = new WithMockAndSpy();
-        MockitoAnnotations.initMocks(outer);
-        when(outer.strength.strength()).thenReturn("strength");
-        assertEquals("inner strength", outer.strength.fullStrength());
-    }
-
-    @Test(expected = IndexOutOfBoundsException.class)
-    public void should_reset_spy() throws Exception {
-        spiedList.get(10); // see shouldInitSpy
-    }
-
-    @Test
-    public void should_report_when_enclosing_instance_is_needed() throws Exception {
-        class Outer {
-            class Inner {
-            }
-        }
-        class WithSpy {
-            @Spy
-            private Outer.Inner inner;
-        }
-        try {
-            MockitoAnnotations.initMocks(new WithSpy());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasMessageContaining("@Spy annotation can only initialize inner classes");
-        }
-    }
-
-    @Test
-    public void should_report_private_inner_not_supported() throws Exception {
-        try {
-            MockitoAnnotations.initMocks(new WithInnerPrivate());
-            fail();
-        } catch (MockitoException e) {
-            // Currently fails at instantiation time, because the mock subclass don't have the
-            // 1-arg constructor expected for the outerclass.
-            // org.mockito.internal.creation.instance.ConstructorInstantiator.withParams()
-            assertThat(e).hasMessageContaining("Unable to initialize @Spy annotated field 'spy_field'")
-                    .hasMessageContaining(WithInnerPrivate.InnerPrivate.class.getSimpleName());
-        }
-    }
-
-    @Test
-    public void should_report_private_abstract_inner_not_supported() throws Exception {
-        try {
-            MockitoAnnotations.initMocks(new WithInnerPrivateAbstract());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasMessageContaining("@Spy annotation can't initialize private abstract inner classes")
-                    .hasMessageContaining(WithInnerPrivateAbstract.class.getSimpleName())
-                    .hasMessageContaining(WithInnerPrivateAbstract.InnerPrivateAbstract.class.getSimpleName())
-                    .hasMessageContaining("You should augment the visibility of this inner class");
-        }
-    }
-
-    @Test
-    public void should_report_private_static_abstract_inner_not_supported() throws Exception {
-        try {
-            MockitoAnnotations.initMocks(new WithInnerPrivateStaticAbstract());
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasMessageContaining("@Spy annotation can't initialize private abstract inner classes")
-                    .hasMessageContaining(WithInnerPrivateStaticAbstract.class.getSimpleName())
-                    .hasMessageContaining(WithInnerPrivateStaticAbstract.InnerPrivateStaticAbstract.class.getSimpleName())
-                    .hasMessageContaining("You should augment the visibility of this inner class");
-        }
-    }
-
-    @Test
-    public void should_be_able_to_stub_and_verify_via_varargs_for_list_params() throws Exception {
-      // You can stub with varargs.
-      when(translator.translate("hello", "mockito")).thenReturn(Arrays.asList("you", "too"));
-
-      // Pretend the prod code will call translate(List<String>) with these elements.
-      assertThat(translator.translate(Arrays.asList("hello", "mockito"))).containsExactly("you", "too");
-      assertThat(translator.translate(Arrays.asList("not stubbed"))).isEmpty();
-
-      // You can verify with varargs.
-      verify(translator).translate("hello", "mockito");
-    }
-
-    @Test
-    public void should_be_able_to_stub_and_verify_via_varargs_of_matchers_for_list_params() throws Exception {
-      // You can stub with varargs of matchers.
-      when(translator.translate(Mockito.anyString())).thenReturn(Arrays.asList("huh?"));
-      when(translator.translate(eq("hello"))).thenReturn(Arrays.asList("hi"));
-
-      // Pretend the prod code will call translate(List<String>) with these elements.
-      assertThat(translator.translate(Arrays.asList("hello"))).containsExactly("hi");
-      assertThat(translator.translate(Arrays.asList("not explicitly stubbed"))).containsExactly("huh?");
-
-      // You can verify with varargs of matchers.
-      verify(translator).translate(eq("hello"));
-    }
-
-    static class WithInnerPrivateStaticAbstract {
-        @Spy
-        private InnerPrivateStaticAbstract spy_field;
-
-        private static abstract class InnerPrivateStaticAbstract {
-        }
-    }
-    static class WithInnerPrivateAbstract {
-        @Spy
-        private InnerPrivateAbstract spy_field;
-
-        public void some_method() {
-            new InnerPrivateConcrete();
-        }
-
-        private abstract class InnerPrivateAbstract {
-        }
-
-        private class InnerPrivateConcrete extends InnerPrivateAbstract {
-
-        }
-    }
-
-    static class WithInnerPrivate {
-        @Spy
-        private InnerPrivate spy_field;
-
-        private class InnerPrivate {
-        }
-
-        private class InnerPrivateSub extends InnerPrivate {}
-    }
-
-    static class InnerStaticClassWithoutDefinedConstructor {
-    }
-
-    static class InnerStaticClassWithNoArgConstructor {
-        InnerStaticClassWithNoArgConstructor() {
-        }
-
-        InnerStaticClassWithNoArgConstructor(String f) {
-        }
-    }
-
-    static class NoValidConstructor {
-        NoValidConstructor(String f) {
-        }
-    }
-
-    static class ThrowingConstructor {
-        ThrowingConstructor() {
-            throw new RuntimeException("boo!");
-        }
-    }
-
-    interface Translator {
-      List<String> translate(List<String> messages);
-    }
-
-    static abstract class MockTranslator implements Translator {
-      @Override public final List<String> translate(List<String> messages) {
-        return translate(messages.toArray(new String[0]));
-      }
-
-      abstract List<String> translate(String... messages);
-    }
-}
diff --git a/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java b/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
deleted file mode 100644
index 874172c271..0000000000
--- a/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.annotation;
-
-import static org.junit.Assert.fail;
-
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.*;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitoutil.TestBase;
-
-public class WrongSetOfAnnotationsTest extends TestBase {
-
-    @Test(expected=MockitoException.class)
-    public void should_not_allow_Mock_and_Spy() throws Exception {
-        MockitoAnnotations.initMocks(new Object() {
-            @Mock @Spy List<?> mock;
-        });
-    }
-
-    @Test
-    public void should_not_allow_Spy_and_InjectMocks_on_interfaces() throws Exception {
-        try {
-            MockitoAnnotations.initMocks(new Object() { @InjectMocks @Spy List<?> mock; });
-            fail();
-        } catch (MockitoException me) {
-            Assertions.assertThat(me.getMessage()).contains("'List' is an interface");
-        }
-    }
-
-    @Test
-    public void should_allow_Spy_and_InjectMocks() throws Exception {
-        MockitoAnnotations.initMocks(new Object() {
-            @InjectMocks
-            @Spy
-            WithDependency mock;
-        });
-    }
-    static class WithDependency { List<?> list; }
-
-    @Test(expected=MockitoException.class)
-    public void should_not_allow_Mock_and_InjectMocks() throws Exception {
-        MockitoAnnotations.initMocks(new Object() {
-            @InjectMocks @Mock List<?> mock;
-        });
-    }
-
-    @Test(expected=MockitoException.class)
-    public void should_not_allow_Captor_and_Mock() throws Exception {
-        MockitoAnnotations.initMocks(new Object() {
-            @Mock @Captor ArgumentCaptor<?> captor;
-        });
-    }
-
-    @Test(expected=MockitoException.class)
-    public void should_not_allow_Captor_and_Spy() throws Exception {
-        MockitoAnnotations.initMocks(new Object() {
-            @Spy @Captor ArgumentCaptor<?> captor;
-        });
-    }
-
-    @Test(expected=MockitoException.class)
-    public void should_not_allow_Captor_and_InjectMocks() throws Exception {
-        MockitoAnnotations.initMocks(new Object() {
-            @InjectMocks @Captor ArgumentCaptor<?> captor;
-        });
-    }
-}
diff --git a/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java b/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
deleted file mode 100644
index 1be6359e95..0000000000
--- a/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.basicapi;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.withSettings;
-import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
-import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-
-// See issue 453
-public class MockingMultipleInterfacesTest {
-
-    class Foo {}
-    interface IFoo {}
-    interface IBar {}
-
-    @Test
-    public void should_allow_multiple_interfaces() {
-        //when
-        Foo mock = mock(Foo.class, withSettings().extraInterfaces(IFoo.class, IBar.class));
-
-        //then
-        assertThat(mock).isInstanceOf(IFoo.class);
-        assertThat(mock).isInstanceOf(IBar.class);
-    }
-
-    @Test
-    public void should_scream_when_null_passed_instead_of_an_interface() {
-        try {
-            //when
-            mock(Foo.class, withSettings().extraInterfaces(IFoo.class, null));
-            fail();
-        } catch (MockitoException e) {
-            //then
-            assertThat(e.getMessage()).contains("extraInterfaces() does not accept null parameters");
-        }
-    }
-
-    @Test
-    public void should_scream_when_no_args_passed() {
-        try {
-            //when
-            mock(Foo.class, withSettings().extraInterfaces());
-            fail();
-        } catch (MockitoException e) {
-            //then
-            assertThat(e.getMessage()).contains("extraInterfaces() requires at least one interface");
-        }
-    }
-
-    @Test
-    public void should_scream_when_null_passed_instead_of_an_array() {
-        try {
-            //when
-            mock(Foo.class, withSettings().extraInterfaces((Class[]) null));
-            fail();
-        } catch (MockitoException e) {
-            //then
-            assertThat(e.getMessage()).contains("extraInterfaces() requires at least one interface");
-        }
-    }
-
-    @Test
-    public void should_scream_when_non_interface_passed() {
-        try {
-            //when
-            mock(Foo.class, withSettings().extraInterfaces(Foo.class));
-            fail();
-        } catch (MockitoException e) {
-            //then
-            assertThat(e.getMessage()).contains("Foo which is not an interface");
-        }
-    }
-
-    @Test
-    public void should_scream_when_the_same_interfaces_passed() {
-        try {
-            //when
-            mock(IMethods.class, withSettings().extraInterfaces(IMethods.class));
-            fail();
-        } catch (MockitoException e) {
-            //then
-            assertThat(e.getMessage()).contains("You mocked following type: IMethods");
-        }
-    }
-
-    @Test
-    public void should_mock_class_with_interfaces_of_different_class_loader_AND_different_classpaths() throws ClassNotFoundException {
-        // Note : if classes are in the same classpath, SearchingClassLoader can find the class/classes and load them in the first matching classloader
-        Class<?> interface1 = inMemoryClassLoader()
-                .withClassDefinition("test.Interface1", makeMarkerInterface("test.Interface1"))
-                .build()
-                .loadClass("test.Interface1");
-        Class<?> interface2 = inMemoryClassLoader()
-                .withClassDefinition("test.Interface2", makeMarkerInterface("test.Interface2"))
-                .build()
-                .loadClass("test.Interface2");
-
-        Object mocked = mock(interface1, withSettings().extraInterfaces(interface2));
-        assertThat(interface2.isInstance(mocked)).describedAs("mock should be assignable from interface2 type").isTrue();
-    }
-}
diff --git a/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java b/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
deleted file mode 100644
index 171f434b18..0000000000
--- a/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.basicapi;
-
-import static org.junit.Assert.assertSame;
-import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
-
-import java.io.Serializable;
-
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("serial")
-public class ObjectsSerializationTest extends TestBase implements Serializable {
-
-    //Ok, this test has nothing to do with mocks but it shows fundamental feature of java serialization that
-    //plays important role in mocking:
-    //Serialization/deserialization actually replaces all instances of serialized object in the object graph (if there are any)
-    //thanks to that mechanizm, stubbing & verification can correctly match method invocations because
-    //one of the parts of invocation matching is checking if mock object is the same
-
-    class Bar implements Serializable {
-        Foo foo;
-    }
-
-    class Foo implements Serializable {
-        Bar bar;
-        Foo() {
-            bar = new Bar();
-            bar.foo = this;
-        }
-    }
-
-    @Test
-    public void shouldSerializationWork() throws Exception {
-        //given
-        Foo foo = new Foo();
-        //when
-        foo = serializeAndBack(foo);
-        //then
-        assertSame(foo, foo.bar.foo);
-    }
-}
diff --git a/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java b/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
deleted file mode 100644
index 3857e084b1..0000000000
--- a/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.basicapi;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockitoutil.TestBase;
-
-public class ReplacingObjectMethodsTest extends TestBase {
-
-    private interface DummyInterface {}
-    private class DummyClass {}
-
-    @Test
-    public void shouldProvideMockyImplementationOfToString() {
-        DummyClass dummyClass = Mockito.mock(DummyClass.class);
-        assertEquals("Mock for DummyClass, hashCode: " + dummyClass.hashCode(), dummyClass.toString());
-        DummyInterface dummyInterface = Mockito.mock(DummyInterface.class);
-        assertEquals("Mock for DummyInterface, hashCode: " + dummyInterface.hashCode(), dummyInterface.toString());
-    }
-
-    @Test
-    public void shouldReplaceObjectMethods() {
-        Object mock = Mockito.mock(ObjectMethodsOverridden.class);
-        Object otherMock = Mockito.mock(ObjectMethodsOverridden.class);
-
-        assertThat(mock).isEqualTo(mock);
-        assertThat(mock).isNotEqualTo(otherMock);
-        assertThat(mock.hashCode()).isNotEqualTo(otherMock.hashCode());
-
-        assertThat(mock.toString()).contains("Mock for ObjectMethodsOverridden");
-    }
-
-    @Test
-    public void shouldReplaceObjectMethodsWhenOverridden() {
-        Object mock = Mockito.mock(ObjectMethodsOverriddenSubclass.class);
-        Object otherMock = Mockito.mock(ObjectMethodsOverriddenSubclass.class);
-
-        assertThat(mock).isEqualTo(mock);
-        assertThat(mock).isNotEqualTo(otherMock);
-        assertThat(mock.hashCode()).isNotEqualTo(otherMock.hashCode());
-
-        assertThat(mock.toString()).contains("Mock for ObjectMethodsOverriddenSubclass");
-    }
-
-    public static class ObjectMethodsOverridden {
-        public boolean equals(Object o) {
-            throw new RuntimeException("Should not be called. MethodInterceptorFilter provides implementation");
-        }
-        public int hashCode() {
-            throw new RuntimeException("Should not be called. MethodInterceptorFilter provides implementation");
-        }
-        public String toString() {
-            throw new RuntimeException("Should not be called. MethodInterceptorFilter provides implementation");
-        }
-    }
-
-    public static class ObjectMethodsOverriddenSubclass extends ObjectMethodsOverridden {
-    }
-}
diff --git a/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java b/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
deleted file mode 100644
index d98995971d..0000000000
--- a/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.basicapi;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class ResetInvocationsTest extends TestBase {
-
-    @Mock
-    IMethods methods;
-
-    @Mock
-    IMethods moarMethods;
-
-    @Test
-    public void reset_invocations_should_reset_only_invocations() {
-        when(methods.simpleMethod()).thenReturn("return");
-
-        methods.simpleMethod();
-        verify(methods).simpleMethod();
-
-        clearInvocations(methods);
-
-        verifyNoMoreInteractions(methods);
-        assertEquals("return", methods.simpleMethod());
-    }
-
-    @Test
-    public void should_reset_invocations_on_multiple_mocks() {
-        methods.simpleMethod();
-        moarMethods.simpleMethod();
-
-        clearInvocations(methods, moarMethods);
-
-        verifyNoMoreInteractions(methods, moarMethods);
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void resettingNonMockIsSafe() {
-        clearInvocations("");
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void resettingNullIsSafe() {
-        clearInvocations(new Object[]{null});
-    }
-}
diff --git a/src/test/java/org/mockitousage/basicapi/ResetTest.java b/src/test/java/org/mockitousage/basicapi/ResetTest.java
deleted file mode 100644
index 9481b08475..0000000000
--- a/src/test/java/org/mockitousage/basicapi/ResetTest.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.basicapi;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.MissingMethodInvocationException;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.exceptions.misusing.UnfinishedVerificationException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class ResetTest extends TestBase {
-
-    @Mock
-    private IMethods mock;
-
-    @Mock
-    private IMethods mockTwo;
-
-    @Test
-    public void shouldResetOngoingStubbingSoThatMoreMeaningfulExceptionsAreRaised() {
-        mock.booleanReturningMethod();
-        reset(mock);
-        try {
-            when(null).thenReturn("anything");
-            fail();
-        } catch (MissingMethodInvocationException e) {
-        }
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void resettingNonMockIsSafe() {
-        reset("");
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void resettingNullIsSafe() {
-        reset(new Object[]{null});
-    }
-
-    @Test
-    public void shouldRemoveAllStubbing() throws Exception {
-        when(mock.objectReturningMethod(isA(Integer.class))).thenReturn(100);
-        when(mock.objectReturningMethod(200)).thenReturn(200);
-        reset(mock);
-        assertNull(mock.objectReturningMethod(200));
-        assertEquals("default behavior should return null", null, mock.objectReturningMethod("blah"));
-    }
-
-    @Test
-    public void shouldRemoveAllInteractions() throws Exception {
-        mock.simpleMethod(1);
-        reset(mock);
-        verifyZeroInteractions(mock);
-    }
-
-    @Test
-    public void shouldRemoveAllInteractionsVerifyNoInteractions() throws Exception {
-        mock.simpleMethod(1);
-        reset(mock);
-        verifyNoInteractions(mock);
-    }
-
-    @Test
-    public void shouldRemoveStubbingToString() throws Exception {
-        IMethods mockTwo = mock(IMethods.class);
-        when(mockTwo.toString()).thenReturn("test");
-        reset(mockTwo);
-        assertThat(mockTwo.toString()).contains("Mock for IMethods");
-    }
-
-    @Test
-    public void shouldStubbingNotBeTreatedAsInteraction() {
-        when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
-        doThrow(new RuntimeException()).when(mock).simpleMethod("two");
-        reset(mock);
-        verifyZeroInteractions(mock);
-    }
-
-    @Test
-    public void shouldStubbingNotBeTreatedAsInteractionVerifyNoInteractions() {
-        when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
-        doThrow(new RuntimeException()).when(mock).simpleMethod("two");
-        reset(mock);
-        verifyNoInteractions(mock);
-    }
-
-    @Test
-    public void shouldNotAffectMockName() {
-        IMethods mock = mock(IMethods.class, "mockie");
-        IMethods mockTwo = mock(IMethods.class);
-        reset(mock);
-        assertThat(mockTwo.toString()).contains("Mock for IMethods");
-        assertEquals("mockie", "" + mock);
-    }
-
-    @Test
-    public void shouldResetMultipleMocks() {
-        mock.simpleMethod();
-        mockTwo.simpleMethod();
-        reset(mock, mockTwo);
-        verifyNoMoreInteractions(mock, mockTwo);
-    }
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test
-    public void shouldValidateStateWhenResetting() {
-        //invalid verify:
-        verify(mock);
-
-        try {
-            reset(mockTwo);
-            fail();
-        } catch (UnfinishedVerificationException e) {
-        }
-    }
-
-    @Test
-    public void shouldMaintainPreviousDefaultAnswer() {
-        //given
-        mock = mock(IMethods.class, RETURNS_MOCKS);
-        //when
-        reset(mock);
-        //then
-        assertNotNull(mock.iMethodsReturningMethod());
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java b/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
deleted file mode 100644
index 04afc0b199..0000000000
--- a/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-// see issue 112
-public class AtLeastMarksAllInvocationsVerified extends TestBase {
-
-    public static class SomeMethods {
-        public void allowedMethod() {
-        }
-        public void disallowedMethod() {
-        }
-    }
-
-    @Test(expected = org.mockito.exceptions.verification.NoInteractionsWanted.class)
-    public void shouldFailBecauseDisallowedMethodWasCalled(){
-        SomeMethods someMethods = mock(SomeMethods.class);
-
-        someMethods.allowedMethod();
-        someMethods.disallowedMethod();
-
-        verify(someMethods, atLeast(1)).allowedMethod();
-        verifyNoMoreInteractions(someMethods);
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java b/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java
deleted file mode 100644
index 7d4ad34303..0000000000
--- a/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-import java.io.Serializable;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockitoutil.TestBase;
-
-//see issue 101
-public class BridgeMethodsHitAgainTest extends TestBase {
-
-  public interface Factory {}
-  public interface ExtendedFactory extends Factory {}
-
-  public interface SomeInterface {
-    Factory factory();
-  }
-
-  public interface SomeSubInterface extends SomeInterface {
-    ExtendedFactory factory();
-  }
-
-  public interface Base<T extends Serializable> {
-    int test(T value);
-  }
-
-  public interface Extended extends Base<String> {
-    @Override
-    int test(String value);
-  }
-
-  @Mock SomeSubInterface someSubInterface;
-  @Mock ExtendedFactory extendedFactory;
-
-  @Test
-  public void basicCheck() {
-    Mockito.when((someSubInterface).factory()).thenReturn(extendedFactory);
-    SomeInterface si = someSubInterface;
-    assertTrue(si.factory() != null);
-  }
-
-  @Test
-  public void checkWithExtraCast() {
-    Mockito.when(((SomeInterface) someSubInterface).factory()).thenReturn(extendedFactory);
-    SomeInterface si = someSubInterface;
-    assertTrue(si.factory() != null);
-  }
-
-    @Test
-    public void testBridgeInvocationIsRecordedForInterceptedMethod() {
-        Extended ext = mock(Extended.class);
-        ext.test("123");
-        verify(ext).test("123");
-        ((Base<String>) ext).test("456");
-        verify(ext).test("456");
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java b/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
deleted file mode 100644
index 851d4175f0..0000000000
--- a/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyZeroInteractions;
-
-import org.junit.Test;
-import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-public class ClassCastExOnVerifyZeroInteractionsTest {
-    public interface TestMock {
-        boolean m1();
-    }
-
-    @Test(expected = NoInteractionsWanted.class)
-    public void should_not_throw_ClassCastException_when_mock_verification_fails() {
-        TestMock test = mock(TestMock.class, new Answer<Object>() {
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                return false;
-            }
-        });
-        test.m1();
-        verifyZeroInteractions(test);
-    }
-
-    @Test(expected = WrongTypeOfReturnValue.class)
-    public void should_report_bogus_default_answer() throws Exception {
-        TestMock test = mock(TestMock.class, new Answer<Object>() {
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                return false;
-            }
-        });
-
-        test.toString();
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java b/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
deleted file mode 100644
index d23919ec43..0000000000
--- a/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.verify;
-
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-//see issue 200
-public class InheritedGenericsPolimorphicCallTest extends TestBase {
-
-    protected interface MyIterable<T> extends Iterable<T> {
-        MyIterator<T> iterator();
-    }
-
-    protected interface MyIterator<T> extends Iterator<T> {
-        // adds nothing here
-    }
-
-    MyIterator<String> myIterator = Mockito.mock(MyIterator.class);
-    MyIterable<String> iterable = Mockito.mock(MyIterable.class);
-
-    @Test
-    public void shouldStubbingWork() {
-        Mockito.when(iterable.iterator()).thenReturn(myIterator);
-        assertNotNull(((Iterable<String>) iterable).iterator());
-        assertNotNull(iterable.iterator());
-    }
-
-    @Test
-    public void shouldVerificationWorks() {
-        iterable.iterator();
-
-        verify(iterable).iterator();
-        verify((Iterable<String>) iterable).iterator();
-    }
-
-    @Test
-    public void shouldWorkExactlyAsJavaProxyWould() {
-        //given
-        final List<Method> methods = new LinkedList<Method>();
-        InvocationHandler handler = new InvocationHandler() {
-        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-            methods.add(method);
-            return null;
-        }};
-
-        iterable = (MyIterable<String>) Proxy.newProxyInstance(
-                this.getClass().getClassLoader(),
-                new Class<?>[] { MyIterable.class },
-                handler);
-
-        //when
-        iterable.iterator();
-        ((Iterable<String>) iterable).iterator();
-
-        //then
-        assertEquals(2, methods.size());
-        assertEquals(methods.get(0), methods.get(1));
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java b/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
deleted file mode 100644
index 2202a6cb4a..0000000000
--- a/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.io.OutputStream;
-import java.io.PrintStream;
-
-import org.junit.Test;
-import org.junit.internal.TextListener;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitoutil.TestBase;
-
-
-// @Ignore("for demo only. this test cannot be enabled as it fails :)")
-public class MockitoRunnerBreaksWhenNoTestMethodsTest extends TestBase {
-
-    @Test
-    public void ensure_the_test_runner_breaks() throws Exception {
-        JUnitCore runner = new JUnitCore();
-//        runner.addListener(new TextListener(System.out));
-        runner.addListener(new TextListener(DevNull.out));
-
-        Result result = runner.run(TestClassWithoutTestMethod.class);
-
-        assertEquals(1, result.getFailureCount());
-        assertTrue(result.getFailures().get(0).getException() instanceof MockitoException);
-        assertFalse(result.wasSuccessful());
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    static class TestClassWithoutTestMethod { // package visibility is important
-        public void notATestMethod() { }
-    }
-
-    public static final class DevNull {
-        public final static PrintStream out = new PrintStream(new OutputStream() {
-            public void close() {}
-            public void flush() {}
-            public void write(byte[] b) {}
-            public void write(byte[] b, int off, int len) {}
-            public void write(int b) {}
-
-        } );
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java b/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
deleted file mode 100644
index f133f4ee4f..0000000000
--- a/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.when;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockitoutil.TestBase;
-
-/**
- * @see <a href="https://github.com/mockito/mockito/issues/1279">Issue #1279</a>
- */
-public class MockitoStubbedCallInAnswerTest extends TestBase {
-
-    @Mock Foo foo;
-    @Mock Bar bar;
-
-    @Test
-    public void stubbing_the_right_mock() throws Exception {
-        //stubbing on different mock should not be altered
-        when(bar.doInt()).thenReturn(0);
-        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
-            @Override
-            public Integer answer(InvocationOnMock invocation) throws Throwable {
-                return bar.doInt();
-            }
-        });
-        assertEquals(0, foo.doInt());
-        assertEquals(0, bar.doInt());
-
-        //when we override the stubbing
-        when(foo.doInt()).thenReturn(1);
-
-        //we expect it to be reflected:
-        assertEquals(1, foo.doInt());
-
-        //but the stubbing on a different mock should not be altered:
-        assertEquals(0, bar.doInt());
-    }
-
-    @Test
-    public void return_type_validation() throws Exception {
-        when(foo.doString()).thenAnswer(new Answer<String>() {
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                //invoking a method on a different mock, with different return type
-                return String.valueOf(bar.doInt());
-            }
-        });
-        assertEquals("0", foo.doString());
-
-        //we can override stubbing without misleading return type validation errors:
-        when(foo.doString()).thenReturn("");
-        assertEquals("", foo.doString());
-    }
-
-    @Test
-    public void prevents_stack_overflow() throws Exception {
-        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
-            public Integer answer(InvocationOnMock invocation) throws Throwable {
-                return bar.doInt();
-            }
-        });
-        assertEquals(0, foo.doInt());
-
-        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
-            public Integer answer(InvocationOnMock invocation) throws Throwable {
-                return bar.doInt() + 1;
-            }
-        });
-
-        //calling below used to cause SO error
-        assertEquals(1, foo.doInt());
-    }
-
-    @Test
-    public void overriding_stubbing() throws Exception {
-        when(bar.doInt()).thenReturn(10);
-        when(foo.doInt()).thenAnswer(new Answer<Integer>() {
-            public Integer answer(InvocationOnMock invocation) throws Throwable {
-                return bar.doInt() + 1;
-            }
-        });
-
-        assertEquals(11, foo.doInt());
-
-        //when we override the stubbing with a different one
-        when(foo.doInt()).thenReturn(100);
-
-        //we expect it to be reflected:
-        assertEquals(100, foo.doInt());
-    }
-
-    interface Foo {
-        String doString();
-        int doInt();
-    }
-
-    interface Bar {
-        int doInt();
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java b/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
deleted file mode 100644
index 8864de8a22..0000000000
--- a/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs;
-
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class NPEWithCertainMatchersTest extends TestBase {
-
-    @Mock IMethods mock;
-
-    @After
-    public void clearState() {
-        this.resetState();
-    }
-
-    @Test
-    public void shouldNotThrowNPEWhenIntegerPassed() {
-        mock.intArgumentMethod(100);
-
-        verify(mock).intArgumentMethod(isA(Integer.class));
-    }
-
-    @Test
-    public void shouldNotThrowNPEWhenIntPassed() {
-        mock.intArgumentMethod(100);
-
-        verify(mock).intArgumentMethod(isA(Integer.class));
-    }
-
-    @Test
-    public void shouldNotThrowNPEWhenIntegerPassedToEq() {
-        mock.intArgumentMethod(100);
-
-        verify(mock).intArgumentMethod(eq(new Integer(100)));
-    }
-
-    @Test
-    public void shouldNotThrowNPEWhenIntegerPassedToSame() {
-        mock.intArgumentMethod(100);
-
-        verify(mock, never()).intArgumentMethod(same(new Integer(100)));
-    }
-
-    @Test(expected = AssertionError.class)
-    public void shouldNotThrowNPEWhenNullPassedToEq() {
-        mock.objectArgMethod("not null");
-
-        verify(mock).objectArgMethod(eq(null));
-    }
-
-    @Test(expected = AssertionError.class)
-    public void shouldNotThrowNPEWhenNullPassedToSame() {
-        mock.objectArgMethod("not null");
-
-        verify(mock).objectArgMethod(same(null));
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java b/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
deleted file mode 100644
index 9cf59599c0..0000000000
--- a/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs.creation;
-
-import java.util.Random;
-
-import org.junit.Test;
-import org.junit.experimental.runners.Enclosed;
-import org.junit.runner.RunWith;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-
-@RunWith(Enclosed.class)
-public class ConstructorInvokingMethodShouldNotRaiseExceptionTest {
-
-    public static class WithDumbMethod {
-        @Spy
-        HasConstructorInvokingMethod hasConstructorInvokingMethod;
-
-        @Test
-        public void should_be_able_to_create_spy() throws Exception {
-            MockitoAnnotations.initMocks(this);
-        }
-
-        private static class HasConstructorInvokingMethod {
-            public HasConstructorInvokingMethod() { someMethod(); }
-
-            void someMethod() { }
-        }
-    }
-
-    public static class UsingMethodObjectReferenceResult {
-        @Spy
-        HasConstructorInvokingMethod hasConstructorInvokingMethod;
-
-        @Test
-        public void should_be_able_to_create_spy() throws Exception {
-            MockitoAnnotations.initMocks(this);
-        }
-
-        private static class HasConstructorInvokingMethod {
-            private final boolean doesIt;
-            public HasConstructorInvokingMethod() {
-                doesIt = someMethod().contains("yup");
-            }
-
-            String someMethod() { return "tada!"; }
-        }
-    }
-
-    public static class UsingMethodPrimitiveResult {
-        @Spy
-        HasConstructorInvokingMethod hasConstructorInvokingMethod;
-
-        @Test
-        public void should_be_able_to_create_spy() throws Exception {
-            MockitoAnnotations.initMocks(this);
-        }
-
-        private static class HasConstructorInvokingMethod {
-            private final boolean doesIt;
-            public HasConstructorInvokingMethod() {
-                doesIt = someMethod();
-            }
-
-            boolean someMethod() { return new Random().nextBoolean(); }
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java b/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
deleted file mode 100644
index bd633a54f6..0000000000
--- a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs.deepstubs;
-
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-
-public class DeepStubFailingWhenGenericNestedAsRawTypeTest {
-
-  interface MyClass1<MC2 extends MyClass2> {
-    MC2 getNested();
-  }
-
-  interface MyClass2<MC3 extends MyClass3> {
-    MC3 getNested();
-  }
-
-  interface MyClass3 {
-    String returnSomething();
-  }
-
-  @Test
-  public void discoverDeepMockingOfGenerics() {
-    MyClass1 myMock1 = mock(MyClass1.class, RETURNS_DEEP_STUBS);
-    when(myMock1.getNested().getNested().returnSomething()).thenReturn("Hello World.");
-  }
-}
diff --git a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java b/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java
deleted file mode 100644
index a2dc0db17b..0000000000
--- a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.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.deepstubs;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
-
-import org.junit.Test;
-
-/**
- * In GH issue 99 : https://github.com/mockito/mockito/issues/99
- */
-public class DeepStubsWronglyReportsSerializationProblemsTest {
-
-    @Test
-    public void should_not_raise_a_mockito_exception_about_serialization_when_accessing_deep_stub() {
-        NotSerializableShouldBeMocked the_deep_stub = mock(ToBeDeepStubbed.class, RETURNS_DEEP_STUBS).getSomething();
-        assertThat(the_deep_stub).isNotNull();
-    }
-
-    public static class ToBeDeepStubbed {
-        public ToBeDeepStubbed() { }
-
-        public NotSerializableShouldBeMocked getSomething() {
-            return null;
-        }
-    }
-
-    public static class NotSerializableShouldBeMocked {
-        NotSerializableShouldBeMocked(String mandatory_param) { }
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java b/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java
deleted file mode 100644
index 387cc65989..0000000000
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs.varargs;
-
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitoutil.TestBase;
-
-public class VarargsAndAnyObjectPicksUpExtraInvocationsTest extends TestBase {
-    public interface TableBuilder {
-        void newRow(String trAttributes, String... cells);
-    }
-
-    @Mock
-    TableBuilder table;
-
-    @Test
-    public void shouldVerifyCorrectlyWithAnyVarargs() {
-        //when
-        table.newRow("qux", "foo", "bar", "baz");
-        table.newRow("abc", "def");
-
-        //then
-        verify(table, times(2)).newRow(anyString(), (String[]) anyVararg());
-    }
-
-    @Test
-    public void shouldVerifyCorrectlyNumberOfInvocationsUsingAnyVarargAndEqualArgument() {
-        //when
-        table.newRow("x", "foo", "bar", "baz");
-        table.newRow("x", "def");
-
-        //then
-        verify(table, times(2)).newRow(eq("x"), (String[]) anyVararg());
-    }
-
-    @Test
-    public void shouldVerifyCorrectlyNumberOfInvocationsWithVarargs() {
-        //when
-        table.newRow("qux", "foo", "bar", "baz");
-        table.newRow("abc", "def");
-
-        //then
-        verify(table).newRow(anyString(), eq("foo"), anyString(), anyString());
-        verify(table).newRow(anyString(), anyString());
-    }
-}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java b/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
deleted file mode 100644
index 123e2e3fa1..0000000000
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.bugs.varargs;
-
-import static org.junit.Assert.assertEquals;
-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;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitoutil.TestBase;
-
-//see issue 62
-public class VarargsNotPlayingWithAnyObjectTest extends TestBase {
-
-    interface VarargMethod {
-        Object run(String... args);
-    }
-
-    @Mock VarargMethod mock;
-
-    @Test
-    public void shouldMatchAnyVararg() {
-        mock.run("a", "b");
-
-        verify(mock).run(anyString(), anyString());
-        verify(mock).run((String) anyObject(), (String) anyObject());
-
-        verify(mock).run((String[]) anyVararg());
-
-        verify(mock, never()).run();
-        verify(mock, never()).run(anyString(), eq("f"));
-    }
-
-    @Test
-    public void shouldAllowUsingAnyObjectForVarArgs() {
-        mock.run("a", "b");
-        verify(mock).run((String[]) anyObject());
-    }
-
-    @Test
-    public void shouldStubUsingAnyVarargs() {
-        when(mock.run((String[]) anyVararg())).thenReturn("foo");
-
-        assertEquals("foo", mock.run("a", "b"));
-    }
-}
diff --git a/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java b/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
deleted file mode 100644
index 4c029f9332..0000000000
--- a/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.configuration;
-
-
-import static org.mockito.Mockito.mock;
-
-import java.util.concurrent.Callable;
-
-import org.junit.Test;
-import org.mockito.internal.configuration.ConfigurationAccess;
-import org.mockitoutil.SimplePerRealmReloadingClassLoader;
-
-public class ClassCacheVersusClassReloadingTest {
-    // TODO refactor to use ClassLoaders
-
-    private SimplePerRealmReloadingClassLoader testMethodClassLoaderRealm = new SimplePerRealmReloadingClassLoader(reloadMockito());
-
-    @Test
-    public void should_not_throw_ClassCastException_when_objenesis_cache_disabled() throws Exception {
-        prepareMockitoAndDisableObjenesisCache();
-
-        doInNewChildRealm(testMethodClassLoaderRealm, "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
-        doInNewChildRealm(testMethodClassLoaderRealm, "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
-    }
-
-    public static class DoTheMocking implements Callable<Object> {
-        public Object call() throws Exception {
-            Class<?> clazz = this.getClass().getClassLoader().loadClass("org.mockitousage.configuration.ClassToBeMocked");
-            return mock(clazz);
-        }
-    }
-
-    private static void doInNewChildRealm(ClassLoader parentRealm, String callableCalledInClassLoaderRealm) throws Exception {
-        new SimplePerRealmReloadingClassLoader(parentRealm, reloadScope()).doInRealm(callableCalledInClassLoaderRealm);
-    }
-
-    private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadScope() {
-        return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
-            public boolean acceptReloadOf(String qualifiedName) {
-                return "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking".equals(qualifiedName)
-                    || "org.mockitousage.configuration.ClassToBeMocked".equals(qualifiedName);
-            }
-        };
-    }
-
-    private void prepareMockitoAndDisableObjenesisCache() throws Exception {
-        testMethodClassLoaderRealm.doInRealm("org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$PrepareMockito");
-    }
-
-    public static class PrepareMockito implements Callable<Boolean> {
-        public Boolean call() throws Exception {
-            Class.forName("org.mockito.Mockito");
-            ConfigurationAccess.getConfig().overrideEnableClassCache(false);
-            return Boolean.TRUE;
-        }
-    }
-
-    private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadMockito() {
-        return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
-            public boolean acceptReloadOf(String qualifiedName) {
-                return (!qualifiedName.contains("net.bytebuddy") && qualifiedName.contains("org.mockito"));
-            }
-        };
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java b/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java
deleted file mode 100644
index bc161321f3..0000000000
--- a/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.configuration;
-
-import static java.lang.annotation.ElementType.FIELD;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.verify;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.Set;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.configuration.MockitoConfiguration;
-import org.mockito.internal.configuration.InjectingAnnotationEngine;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-
-/**
- * @see MockitoConfiguration#getAnnotationEngine() for the custom smartmock injection engine
- */
-public class CustomizedAnnotationForSmartMockTest extends TestBase {
-
-    @SmartMock IMethods smartMock;
-
-    @Test
-    public void shouldUseCustomAnnotation() {
-        assertEquals("SmartMock should return empty String by default", "", smartMock.simpleMethod(1));
-        verify(smartMock).simpleMethod(1);
-    }
-
-    @Target({FIELD })
-    @Retention(RetentionPolicy.RUNTIME)
-    public @interface SmartMock {}
-
-    public static class CustomInjectingAnnotationEngine extends InjectingAnnotationEngine {
-        @Override
-        protected void onInjection(Object testClassInstance, Class<?> clazz, Set<Field> mockDependentFields, Set<Object> mocks) {
-            for (Field field : clazz.getDeclaredFields()) {
-                if (field.isAnnotationPresent(SmartMock.class)) {
-                    field.setAccessible(true);
-                    try {
-                        field.set(Modifier.isStatic(field.getModifiers()) ? null : testClassInstance, Mockito.mock(field.getType(), Mockito.RETURNS_SMART_NULLS));
-                    } catch (Exception exception) {
-                        throw new AssertionError(exception.getMessage());
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java b/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
deleted file mode 100644
index 5816be1e3d..0000000000
--- a/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.constructor;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.CALLS_REAL_METHODS;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.mock.SerializableMode;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class CreatingMocksWithConstructorTest extends TestBase {
-
-    static abstract class AbstractMessage {
-        private final String message;
-        AbstractMessage() {
-            this.message = "hey!";
-        }
-        AbstractMessage(String message) {
-            this.message = message;
-        }
-        AbstractMessage(int i) {
-            this.message = String.valueOf(i);
-        }
-        String getMessage() {
-            return message;
-        }
-    }
-
-    static class Message extends AbstractMessage {}
-    class InnerClass extends AbstractMessage {}
-
-    @Test
-    public void can_create_mock_with_constructor() {
-        Message mock = mock(Message.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
-        //the message is a part of state of the mocked type that gets initialized in constructor
-        assertEquals("hey!", mock.getMessage());
-    }
-
-    @Test
-    public void can_mock_abstract_classes() {
-        AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("hey!", mock.getMessage());
-    }
-
-    @Test
-    public void can_spy_abstract_classes() {
-        AbstractMessage mock = spy(AbstractMessage.class);
-        assertEquals("hey!", mock.getMessage());
-    }
-
-    @Test
-    public void can_spy_abstract_classes_with_constructor_args() {
-        AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor("hello!").defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("hello!", mock.getMessage());
-    }
-
-    @Test
-    public void can_spy_abstract_classes_with_constructor_primitive_args() {
-        AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor(7).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("7", mock.getMessage());
-    }
-
-    @Test
-    public void can_spy_abstract_classes_with_constructor_array_of_nulls() {
-        AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor(new Object[]{null}).defaultAnswer(CALLS_REAL_METHODS));
-        assertNull(mock.getMessage());
-    }
-
-    @Test
-    public void can_spy_abstract_classes_with_casted_null() {
-        AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor((String) null).defaultAnswer(CALLS_REAL_METHODS));
-        assertNull(mock.getMessage());
-    }
-
-    @Test
-    public void can_spy_abstract_classes_with_null_varargs() {
-        try {
-            mock(AbstractMessage.class, withSettings().useConstructor(null).defaultAnswer(CALLS_REAL_METHODS));
-            fail();
-        } catch (IllegalArgumentException e) {
-            assertThat(e).hasMessageContaining("constructorArgs should not be null. " +
-                "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
-        }
-    }
-
-    @Test
-    public void can_mock_inner_classes() {
-        InnerClass mock = mock(InnerClass.class, withSettings().useConstructor().outerInstance(this).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("hey!", mock.getMessage());
-    }
-
-    public static class ThrowingConstructorClass{
-        public ThrowingConstructorClass() {
-            throw new RuntimeException();
-        }
-    }
-
-    @Test
-    public void explains_constructor_exceptions() {
-        try {
-            mock(ThrowingConstructorClass.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasRootCauseInstanceOf(RuntimeException.class);
-            assertThat(e.getCause()).hasMessageContaining("Please ensure the target class has a 0-arg constructor and executes cleanly.");
-        }
-    }
-
-    static class HasConstructor {
-        HasConstructor(String x) {}
-    }
-
-    @Test
-    public void exception_message_when_constructor_not_found() {
-        try {
-            //when
-            spy(HasConstructor.class);
-            //then
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasMessage("Unable to create mock instance of type 'HasConstructor'");
-            assertThat(e.getCause()).hasMessageContaining("Please ensure that the target class has a 0-arg constructor.");
-        }
-    }
-
-    static class Base {}
-    static class ExtendsBase extends Base {}
-    static class ExtendsExtendsBase extends ExtendsBase {}
-
-    static class UsesBase {
-        public UsesBase(Base b) {
-            constructorUsed = "Base";
-        }
-        public UsesBase(ExtendsBase b) {
-            constructorUsed = "ExtendsBase";
-        }
-
-        private String constructorUsed = null;
-        String getConstructorUsed() {
-            return constructorUsed;
-        }
-    }
-
-    @Test
-    public void can_mock_unambigous_constructor_with_inheritance_base_class_exact_match() {
-        UsesBase u = mock(UsesBase.class, withSettings().useConstructor(new Base()).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("Base", u.getConstructorUsed());
-    }
-
-    @Test
-    public void can_mock_unambigous_constructor_with_inheritance_extending_class_exact_match() {
-        UsesBase u = mock(UsesBase.class, withSettings().useConstructor(new ExtendsBase()).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("ExtendsBase", u.getConstructorUsed());
-    }
-
-    @Test
-    public void can_mock_unambigous_constructor_with_inheritance_non_exact_match() {
-        UsesBase u = mock(UsesBase.class, withSettings().useConstructor(new ExtendsExtendsBase()).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("ExtendsBase", u.getConstructorUsed());
-    }
-
-    static class UsesTwoBases {
-        public UsesTwoBases(Base b1, Base b2) {
-            constructorUsed = "Base,Base";
-        }
-        public UsesTwoBases(ExtendsBase b1, Base b2) {
-            constructorUsed = "ExtendsBase,Base";
-        }
-        public UsesTwoBases(Base b1, ExtendsBase b2) {
-            constructorUsed = "Base,ExtendsBase";
-        }
-
-        private String constructorUsed = null;
-        String getConstructorUsed() {
-            return constructorUsed;
-        }
-    }
-
-    @Test
-    public void can_mock_unambigous_constructor_with_inheritance_multiple_base_class_exact_match() {
-        UsesTwoBases u =
-            mock(UsesTwoBases.class, withSettings().useConstructor(new Base(), new Base()).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("Base,Base", u.getConstructorUsed());
-    }
-
-    @Test
-    public void can_mock_unambigous_constructor_with_inheritance_first_extending_class_exact_match() {
-        UsesTwoBases u =
-            mock(UsesTwoBases.class, withSettings().useConstructor(new ExtendsBase(), new Base()).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("ExtendsBase,Base", u.getConstructorUsed());
-    }
-
-    @Test
-    public void can_mock_unambigous_constructor_with_inheritance_second_extending_class_exact_match() {
-        UsesTwoBases u =
-            mock(UsesTwoBases.class, withSettings().useConstructor(new Base(), new ExtendsBase()).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("Base,ExtendsBase", u.getConstructorUsed());
-    }
-
-    @Test
-    public void fail_when_multiple_matching_constructors_with_inheritence() {
-        try {
-            //when
-            mock(UsesTwoBases.class, withSettings().useConstructor(new ExtendsBase(), new ExtendsBase()));
-            //then
-            fail();
-        } catch (MockitoException e) {
-            //TODO the exception message includes Mockito internals like the name of the generated class name.
-            //I suspect that we could make this exception message nicer.
-            assertThat(e).hasMessage("Unable to create mock instance of type 'UsesTwoBases'");
-            assertThat(e.getCause())
-                .hasMessageContaining("Multiple constructors could be matched to arguments of types "
-                    + "[org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase, "
-                    + "org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase]")
-                .hasMessageContaining("If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.\n" +
-                    "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.\n" +
-                    "See https://github.com/mockito/mockito/issues/685");
-        }
-    }
-
-    @Test
-    public void mocking_inner_classes_with_wrong_outer_instance() {
-        try {
-            //when
-            mock(InnerClass.class, withSettings().useConstructor().outerInstance(123).defaultAnswer(CALLS_REAL_METHODS));
-            //then
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasMessage("Unable to create mock instance of type 'InnerClass'");
-            //TODO it would be nice if all useful information was in the top level exception, instead of in the exception's cause
-            //also applies to other scenarios in this test
-            assertThat(e.getCause()).hasMessageContaining(
-                "Please ensure that the target class has a 0-arg constructor"
-                    + " and provided outer instance is correct.");
-        }
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test
-    public void mocking_interfaces_with_constructor() {
-        //at the moment this is allowed however we can be more strict if needed
-        //there is not much sense in creating a spy of an interface
-        mock(IMethods.class, withSettings().useConstructor());
-        spy(IMethods.class);
-    }
-
-    @Test
-    public void prevents_across_jvm_serialization_with_constructor() {
-        try {
-            //when
-            mock(AbstractMessage.class, withSettings().useConstructor().serializable(SerializableMode.ACROSS_CLASSLOADERS));
-            //then
-            fail();
-        } catch (MockitoException e) {
-            assertEquals("Mocks instantiated with constructor cannot be combined with " + SerializableMode.ACROSS_CLASSLOADERS + " serialization mode.", e.getMessage());
-        }
-    }
-
-    static abstract class AbstractThing {
-        abstract String name();
-        String fullName() {
-            return "abstract " + name();
-        }
-    }
-
-    @Test
-    public void abstract_method_returns_default() {
-        AbstractThing thing = spy(AbstractThing.class);
-        assertEquals("abstract null", thing.fullName());
-    }
-
-    @Test
-    public void abstract_method_stubbed() {
-        AbstractThing thing = spy(AbstractThing.class);
-        when(thing.name()).thenReturn("me");
-        assertEquals("abstract me", thing.fullName());
-    }
-
-    @Test
-    public void interface_method_stubbed() {
-        List<?> list = spy(List.class);
-        when(list.size()).thenReturn(12);
-        assertEquals(12, list.size());
-    }
-
-    @Test
-    public void calls_real_interface_method() {
-        List list = mock(List.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));
-        assertNull(list.get(1));
-    }
-
-    @Test
-    public void handles_bridge_methods_correctly() {
-        SomeConcreteClass<Integer> testBug = spy(new SomeConcreteClass<Integer>());
-        assertEquals("value", testBug.getValue(0));
-    }
-
-    public abstract class SomeAbstractClass<T> {
-
-        protected abstract String getRealValue(T value);
-
-        public String getValue(T value) {
-            return getRealValue(value);
-        }
-    }
-
-    public class SomeConcreteClass<T extends Number> extends SomeAbstractClass<T> {
-
-        @Override
-        protected String getRealValue(T value) {
-            return "value";
-        }
-    }
-
-    private static class AmbiguousWithPrimitive {
-        public AmbiguousWithPrimitive(String s, int i) {
-            data = s;
-        }
-        public AmbiguousWithPrimitive(Object o, int i) {
-            data = "just an object";
-        }
-
-        private String data;
-        public String getData() {
-            return data;
-        }
-    }
-
-    @Test
-    public void can_spy_ambiguius_constructor_with_primitive() {
-        AmbiguousWithPrimitive mock = mock(AmbiguousWithPrimitive.class, withSettings().useConstructor("String", 7).defaultAnswer(CALLS_REAL_METHODS));
-        assertEquals("String", mock.getData());
-    }
-}
diff --git a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
deleted file mode 100644
index 0154f4a898..0000000000
--- a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
+++ /dev/null
@@ -1,410 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.customization;
-
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.*;
-
-import java.util.Set;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockitousage.IMethods;
-import org.mockitousage.MethodsImpl;
-import org.mockitoutil.TestBase;
-
-public class BDDMockitoTest extends TestBase {
-
-    @Mock
-    IMethods mock;
-
-    @Test
-    public void should_stub() throws Exception {
-        given(mock.simpleMethod("foo")).willReturn("bar");
-
-        Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("bar");
-        Assertions.assertThat(mock.simpleMethod("whatever")).isEqualTo(null);
-    }
-
-    @Test
-    public void should_stub_with_throwable() throws Exception {
-        given(mock.simpleMethod("foo")).willThrow(new SomethingWasWrong());
-
-        try {
-            Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    public void should_stub_with_throwable_class() throws Exception {
-        given(mock.simpleMethod("foo")).willThrow(SomethingWasWrong.class);
-
-        try {
-            Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void should_stub_with_throwable_classes() throws Exception {
-        // unavoidable 'unchecked generic array creation' warning (from JDK7 onward)
-        given(mock.simpleMethod("foo")).willThrow(SomethingWasWrong.class, AnotherThingWasWrong.class);
-
-        try {
-            Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    public void should_stub_with_answer() throws Exception {
-        given(mock.simpleMethod(anyString())).willAnswer(new Answer<String>() {
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                return invocation.getArgument(0);
-            }
-        });
-
-        Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_stub_with_will_answer_alias() throws Exception {
-        given(mock.simpleMethod(anyString())).will(new Answer<String>() {
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                return invocation.getArgument(0);
-            }
-        });
-
-        Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_stub_consecutively() throws Exception {
-        given(mock.simpleMethod(anyString()))
-                .willReturn("foo")
-                .willReturn("bar");
-
-        Assertions.assertThat(mock.simpleMethod("whatever")).isEqualTo("foo");
-        Assertions.assertThat(mock.simpleMethod("whatever")).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_return_consecutively() throws Exception {
-        given(mock.objectReturningMethodNoArgs())
-                .willReturn("foo", "bar", 12L, new byte[0]);
-
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("foo");
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("bar");
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(12L);
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(new byte[0]);
-    }
-
-    @Test
-    public void should_stub_consecutively_with_call_real_method() throws Exception {
-        MethodsImpl mock = mock(MethodsImpl.class);
-        willReturn("foo").willCallRealMethod()
-                .given(mock).simpleMethod();
-
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("foo");
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo(null);
-    }
-
-    @Test
-    public void should_stub_void() throws Exception {
-        willThrow(new SomethingWasWrong()).given(mock).voidMethod();
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    public void should_stub_void_with_exception_class() throws Exception {
-        willThrow(SomethingWasWrong.class).given(mock).voidMethod();
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void should_stub_void_with_exception_classes() throws Exception {
-        willThrow(SomethingWasWrong.class, AnotherThingWasWrong.class).given(mock).voidMethod();
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    public void should_stub_void_consecutively() throws Exception {
-        willDoNothing()
-                .willThrow(new SomethingWasWrong())
-                .given(mock).voidMethod();
-
-        mock.voidMethod();
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    public void should_stub_void_consecutively_with_exception_class() throws Exception {
-        willDoNothing()
-                .willThrow(SomethingWasWrong.class)
-                .given(mock).voidMethod();
-
-        mock.voidMethod();
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (SomethingWasWrong expected) {
-        }
-    }
-
-    @Test
-    public void should_stub_using_do_return_style() throws Exception {
-        willReturn("foo").given(mock).simpleMethod("bar");
-
-        Assertions.assertThat(mock.simpleMethod("boooo")).isEqualTo(null);
-        Assertions.assertThat(mock.simpleMethod("bar")).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_stub_using_do_answer_style() throws Exception {
-        willAnswer(new Answer<String>() {
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                return invocation.getArgument(0);
-            }
-        })
-                .given(mock).simpleMethod(anyString());
-
-        Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_stub_by_delegating_to_real_method() throws Exception {
-        //given
-        Dog dog = mock(Dog.class);
-        //when
-        willCallRealMethod().given(dog).bark();
-        //then
-        Assertions.assertThat(dog.bark()).isEqualTo("woof");
-    }
-
-    @Test
-    public void should_stub_by_delegating_to_real_method_using_typical_stubbing_syntax() throws Exception {
-        //given
-        Dog dog = mock(Dog.class);
-        //when
-        given(dog.bark()).willCallRealMethod();
-        //then
-        Assertions.assertThat(dog.bark()).isEqualTo("woof");
-    }
-
-    @Test
-    public void should_all_stubbed_mock_reference_access() throws Exception {
-        Set<?> expectedMock = mock(Set.class);
-
-        Set<?> returnedMock = given(expectedMock.isEmpty()).willReturn(false).getMock();
-
-        Assertions.assertThat(returnedMock).isEqualTo(expectedMock);
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void should_validate_mock_when_verifying() {
-        then("notMock").should();
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void should_validate_mock_when_verifying_with_expected_number_of_invocations() {
-        then("notMock").should(times(19));
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void should_validate_mock_when_verifying_no_more_interactions() {
-        then("notMock").should();
-    }
-
-    @Test(expected = WantedButNotInvoked.class)
-    public void should_fail_for_expected_behavior_that_did_not_happen() {
-        then(mock).should().booleanObjectReturningMethod();
-    }
-
-    @Test
-    public void should_pass_for_expected_behavior_that_happened() {
-        mock.booleanObjectReturningMethod();
-
-        then(mock).should().booleanObjectReturningMethod();
-        then(mock).shouldHaveNoMoreInteractions();
-    }
-
-    @Test
-    public void should_validate_that_mock_did_not_have_any_interactions() {
-        then(mock).shouldHaveZeroInteractions();
-    }
-
-    @Test
-    public void should_validate_that_mock_had_no_interactions() {
-        then(mock).shouldHaveNoInteractions();
-    }
-
-    @Test
-    public void should_fail_when_mock_had_unwanted_interactions() {
-        mock.booleanObjectReturningMethod();
-
-        try {
-            then(mock).shouldHaveZeroInteractions();
-            fail("should have reported this interaction wasn't wanted");
-        } catch (NoInteractionsWanted expected) {
-        }
-    }
-
-    @Test
-    public void should_fail_when_mock_had_more_interactions_than_expected() {
-        mock.booleanObjectReturningMethod();
-        mock.byteObjectReturningMethod();
-
-        then(mock).should().booleanObjectReturningMethod();
-        try {
-            then(mock).shouldHaveNoMoreInteractions();
-            fail("should have reported that no more interactions were wanted");
-        } catch (NoInteractionsWanted expected) {
-        }
-    }
-
-    @Test
-    public void should_pass_for_interactions_that_happened_in_correct_order() {
-        mock.booleanObjectReturningMethod();
-        mock.arrayReturningMethod();
-
-        InOrder inOrder = inOrder(mock);
-        then(mock).should(inOrder).booleanObjectReturningMethod();
-        then(mock).should(inOrder).arrayReturningMethod();
-    }
-
-    @Test
-    public void should_fail_for_interactions_that_were_in_wrong_order() {
-        InOrder inOrder = inOrder(mock);
-
-        mock.arrayReturningMethod();
-        mock.booleanObjectReturningMethod();
-
-        then(mock).should(inOrder).booleanObjectReturningMethod();
-        try {
-            then(mock).should(inOrder).arrayReturningMethod();
-            fail("should have raise in order verification failure on second verify call");
-        } catch (VerificationInOrderFailure expected) {
-        }
-    }
-
-    @Test(expected = WantedButNotInvoked.class)
-    public void should_fail_when_checking_order_of_interactions_that_did_not_happen() {
-        then(mock).should(inOrder(mock)).booleanObjectReturningMethod();
-    }
-
-    @Test
-    public void should_pass_fluent_bdd_scenario() {
-        Bike bike = new Bike();
-        Person person = mock(Person.class);
-        Police police = mock(Police.class);
-
-        person.ride(bike);
-        person.ride(bike);
-
-        then(person).should(times(2)).ride(bike);
-        then(police).shouldHaveZeroInteractions();
-    }
-
-    @Test
-    public void should_pass_fluent_bdd_scenario_with_ordered_verification() {
-        Bike bike = new Bike();
-        Car car = new Car();
-        Person person = mock(Person.class);
-
-        person.drive(car);
-        person.ride(bike);
-        person.ride(bike);
-
-        InOrder inOrder = inOrder(person);
-        then(person).should(inOrder).drive(car);
-        then(person).should(inOrder, times(2)).ride(bike);
-    }
-
-    @Test
-    public void should_pass_fluent_bdd_scenario_with_ordered_verification_for_two_mocks() {
-        Car car = new Car();
-        Person person = mock(Person.class);
-        Police police = mock(Police.class);
-
-        person.drive(car);
-        person.drive(car);
-        police.chase(car);
-
-        InOrder inOrder = inOrder(person, police);
-        then(person).should(inOrder, times(2)).drive(car);
-        then(police).should(inOrder).chase(car);
-    }
-
-    static class Person {
-
-        void ride(Bike bike) {
-        }
-
-        void drive(Car car) {
-        }
-    }
-
-    static class Bike {
-
-    }
-
-    static class Car {
-
-    }
-
-    static class Police {
-
-        void chase(Car car) {
-        }
-    }
-
-    class Dog {
-
-        public String bark() {
-            return "woof";
-        }
-    }
-
-    private class SomethingWasWrong extends RuntimeException {
-
-    }
-
-    private class AnotherThingWasWrong extends RuntimeException {
-
-    }
-}
diff --git a/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java b/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
deleted file mode 100644
index 9b70410e33..0000000000
--- a/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.debugging;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.internal.debugging.InvocationsPrinter;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class InvocationsPrinterTest extends TestBase {
-
-    @Mock IMethods mock;
-
-    @Test public void no_invocations() {
-        assertThat(new InvocationsPrinter().printInvocations(mock)).isEqualTo("No interactions and stubbings found for mock: mock");
-    }
-
-    @Test public void prints_invocations() {
-        mock.simpleMethod(100);
-        triggerInteraction();
-
-        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
-                .isEqualTo(filterLineNo("[Mockito] Interactions of: mock\n" +
-                        " 1. mock.simpleMethod(100);\n" +
-                        "  -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations(InvocationsPrinterTest.java:0)\n" +
-                        " 2. mock.otherMethod();\n" +
-                        "  -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:0)\n"));
-    }
-
-    @Test public void prints_stubbings() {
-        triggerStubbing();
-
-        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
-                .isEqualTo(filterLineNo("[Mockito] Unused stubbings of: mock\n" +
-                        " 1. mock.simpleMethod(\"a\");\n" +
-                        "  - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:70)\n"));
-    }
-
-    @Test public void prints_invocations_and_stubbings() {
-        triggerStubbing();
-
-        mock.simpleMethod("a");
-        triggerInteraction();
-
-        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
-                .isEqualTo(filterLineNo("[Mockito] Interactions of: mock\n" +
-                        " 1. mock.simpleMethod(\"a\");\n" +
-                        "  -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_stubbings(InvocationsPrinterTest.java:49)\n" +
-                        "   - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:73)\n" +
-                        " 2. mock.otherMethod();\n" +
-                        "  -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n"));
-    }
-
-    @Test public void prints_invocations_and_unused_stubbings() {
-        triggerStubbing();
-
-        mock.simpleMethod("b");
-        triggerInteraction();
-
-        assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
-                .isEqualTo(filterLineNo("[Mockito] Interactions of: mock\n" +
-                        " 1. mock.simpleMethod(\"b\");\n" +
-                        "  -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_unused_stubbings(InvocationsPrinterTest.java:55)\n" +
-                        " 2. mock.otherMethod();\n" +
-                        "  -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n" +
-                        "[Mockito] Unused stubbings of: mock\n" +
-                        " 1. mock.simpleMethod(\"a\");\n" +
-                        "  - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:62)\n"));
-    }
-
-    private void triggerInteraction() {
-        mock.otherMethod();
-    }
-
-    private void triggerStubbing() {
-        when(mock.simpleMethod("a")).thenReturn("x");
-    }
-}
diff --git a/src/test/java/org/mockitousage/debugging/NewMockito.java b/src/test/java/org/mockitousage/debugging/NewMockito.java
deleted file mode 100644
index e8cf2729f3..0000000000
--- a/src/test/java/org/mockitousage/debugging/NewMockito.java
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.debugging;
-
-import org.mockito.Mockito;
-import org.mockito.MockitoDebugger;
-import org.mockito.internal.debugging.MockitoDebuggerImpl;
-
-//TODO get rid when debug() finally is out
-public class NewMockito extends Mockito {
-
-    public static MockitoDebugger debug() {
-        return new MockitoDebuggerImpl();
-    }
-}
diff --git a/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java b/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java
deleted file mode 100644
index d7ba7d643c..0000000000
--- a/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.debugging;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.InOrder;
-import org.mockito.listeners.StubbingLookupEvent;
-import org.mockito.listeners.StubbingLookupListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockitousage.IMethods;
-import org.mockitoutil.ConcurrentTesting;
-import org.mockitoutil.TestBase;
-
-public class StubbingLookupListenerCallbackTest extends TestBase {
-
-    StubbingLookupListener listener = mock(StubbingLookupListener.class);
-    StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
-    Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener));
-
-    @Test
-    public void should_call_listener_when_mock_return_normally_with_stubbed_answer() {
-        // given
-        doReturn("coke").when(mock).giveMeSomeString("soda");
-        doReturn("java").when(mock).giveMeSomeString("coffee");
-
-        // when
-        mock.giveMeSomeString("soda");
-
-        // then
-        verify(listener).onStubbingLookup(argThat(new ArgumentMatcher<StubbingLookupEvent>() {
-            @Override
-            public boolean matches(StubbingLookupEvent argument) {
-                assertEquals("soda", argument.getInvocation().getArgument(0));
-                assertEquals("mock", argument.getMockSettings().getMockName().toString());
-                assertEquals(2, argument.getAllStubbings().size());
-                assertNotNull(argument.getStubbingFound());
-                return true;
-            }
-        }));
-    }
-
-    @Test
-    public void should_call_listener_when_mock_return_normally_with_default_answer() {
-        // given
-        doReturn("java").when(mock).giveMeSomeString("coffee");
-
-        // when
-        mock.giveMeSomeString("soda");
-
-        // then
-        verify(listener).onStubbingLookup(argThat(new ArgumentMatcher<StubbingLookupEvent>() {
-            @Override
-            public boolean matches(StubbingLookupEvent argument) {
-                assertEquals("soda", argument.getInvocation().getArgument(0));
-                assertEquals("mock", argument.getMockSettings().getMockName().toString());
-                assertEquals(1, argument.getAllStubbings().size());
-                assertNull(argument.getStubbingFound());
-                return true;
-            }
-        }));
-    }
-
-    @Test
-    public void should_not_call_listener_when_mock_is_not_called() {
-        // when stubbing is recorded
-        doReturn("java").when(mock).giveMeSomeString("coffee");
-
-        // then
-        verifyZeroInteractions(listener);
-    }
-
-    @Test
-    public void should_allow_same_listener() {
-        // given
-        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener));
-
-        // when
-        mock.giveMeSomeString("tea");
-        mock.giveMeSomeString("coke");
-
-        // then each listener was notified 2 times (notified 4 times in total)
-        verify(listener, times(4)).onStubbingLookup(any(StubbingLookupEvent.class));
-    }
-
-    @Test
-    public void should_call_all_listeners_in_order() {
-        // given
-        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
-        doReturn("sprite").when(mock).giveMeSomeString("soda");
-
-        // when
-        mock.giveMeSomeString("soda");
-
-        // then
-        InOrder inOrder = inOrder(listener, listener2);
-        inOrder.verify(listener).onStubbingLookup(any(StubbingLookupEvent.class));
-        inOrder.verify(listener2).onStubbingLookup(any(StubbingLookupEvent.class));
-    }
-
-    @Test
-    public void should_call_all_listeners_when_mock_throws_exception() {
-        // given
-        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
-        doThrow(new NoWater()).when(mock).giveMeSomeString("tea");
-
-        // when
-        try {
-            mock.giveMeSomeString("tea");
-            fail();
-        } catch (NoWater e) {
-            // then
-            verify(listener).onStubbingLookup(any(StubbingLookupEvent.class));
-            verify(listener2).onStubbingLookup(any(StubbingLookupEvent.class));
-        }
-    }
-
-    @Test
-    public void should_delete_listener() {
-        // given
-        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
-
-        // when
-        mock.doSomething("1");
-        mockingDetails(mock).getMockCreationSettings().getStubbingLookupListeners().remove(listener2);
-        mock.doSomething("2");
-
-        // then
-        verify(listener, times(2)).onStubbingLookup(any(StubbingLookupEvent.class));
-        verify(listener2, times(1)).onStubbingLookup(any(StubbingLookupEvent.class));
-    }
-
-    @Test
-    public void should_clear_listeners() {
-        // given
-        Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
-
-        // when
-        mockingDetails(mock).getMockCreationSettings().getStubbingLookupListeners().clear();
-        mock.doSomething("foo");
-
-        // then
-        verifyZeroInteractions(listener, listener2);
-    }
-
-    @Test
-    public void add_listeners_concurrently_sanity_check() throws Exception {
-        //given
-        final IMethods mock = mock(IMethods.class);
-        final MockCreationSettings<?> settings = mockingDetails(mock).getMockCreationSettings();
-
-        List<Runnable> runnables = new LinkedList<Runnable>();
-        for (int i = 0; i < 50; i++) {
-            runnables.add(new Runnable() {
-                public void run() {
-                    StubbingLookupListener listener1 = mock(StubbingLookupListener.class);
-                    StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
-                    settings.getStubbingLookupListeners().add(listener1);
-                    settings.getStubbingLookupListeners().add(listener2);
-                    settings.getStubbingLookupListeners().remove(listener1);
-                }
-            });
-        }
-
-        //when
-        ConcurrentTesting.concurrently(runnables.toArray(new Runnable[runnables.size()]));
-
-        //then
-        //This assertion may be flaky. If it is let's fix it or remove the test. For now, I'm keeping the test.
-        assertEquals(50, settings.getStubbingLookupListeners().size());
-    }
-
-    private static class NoWater extends RuntimeException {}
-}
diff --git a/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java b/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java
deleted file mode 100644
index 48112b856f..0000000000
--- a/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.internal.debugging;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.junit.Test;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.exceptions.stacktrace.StackTraceFilter;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("serial")
-public class LocationImplTest extends TestBase {
-
-    @Test
-    public void shouldLocationNotContainGetStackTraceMethod() {
-        assertThat(new LocationImpl().toString()).contains("shouldLocationNotContainGetStackTraceMethod");
-    }
-
-    @Test
-    public void shouldBeSafeInCaseForSomeReasonFilteredStackTraceIsEmpty() {
-        //given
-        StackTraceFilter filterReturningEmptyArray = new StackTraceFilter() {
-            @Override
-            public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) {
-                return new StackTraceElement[0];
-            }
-
-            @Override
-            public StackTraceElement filterFirst(Throwable target, boolean isInline) {
-                return null;
-            }
-        };
-
-        //when
-        String loc = new LocationImpl(filterReturningEmptyArray).toString();
-
-        //then
-        assertEquals("-> at <<unknown line>>", loc);
-    }
-
-    @Test
-    public void provides_location_class() {
-        //when
-        final List<String> files = new ArrayList<String>();
-        new Runnable() { //anonymous inner class adds stress to the check
-            public void run() {
-                files.add(new LocationImpl().getSourceFile());
-            }
-        }.run();
-
-        //then
-        assertEquals("LocationImplTest.java", files.get(0));
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java b/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java
deleted file mode 100644
index 9038e75417..0000000000
--- a/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2020 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runners.model.Statement;
-import org.mockito.Mock;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-
-public class JUnitTestRuleIntegratesWithRuleChainTest {
-
-    JUnitCore runner = new JUnitCore();
-
-    @Test public void rule_can_be_changed_to_strict() {
-        //when
-        Result result = runner.run(StrictByDefault.class);
-
-        //then
-        JUnitResultAssert.assertThat(result)
-            .succeeds(1)
-            .fails(1, RuntimeException.class);
-    }
-
-    @Test public void rule_can_be_changed_to_lenient() {
-        //when
-        Result result = runner.run(LenientByDefault.class);
-
-        //then
-        JUnitResultAssert.assertThat(result)
-            .isSuccessful();
-    }
-
-    public static class LenientByDefault {
-        @Rule
-        public final RuleChain chain = RuleChain.outerRule(
-            MockitoJUnit.testRule(this)
-        ).around((base, description) -> new Statement() {
-            @Override
-            public void evaluate() throws Throwable {
-                assertThat(MockUtil.isMock(mock)).isTrue();
-                called.set(true);
-                base.evaluate();
-            }
-        });
-
-        @Mock
-        public IMethods mock;
-
-        private AtomicBoolean called = new AtomicBoolean(false);
-
-        @Test
-        public void creates_mocks_in_correct_rulechain_ordering() {
-            assertThat(MockUtil.isMock(mock)).isTrue();
-            assertThat(called.get()).isTrue();
-        }
-    }
-
-    public static class StrictByDefault {
-        @Rule
-        public final RuleChain chain = RuleChain.outerRule(
-            MockitoJUnit.testRule(this).strictness(Strictness.STRICT_STUBS)
-        ).around((base, description) -> new Statement() {
-            @Override
-            public void evaluate() throws Throwable {
-                assertThat(MockUtil.isMock(mock)).isTrue();
-                called.set(true);
-                base.evaluate();
-            }
-        });
-
-        @Mock
-        public IMethods mock;
-
-        private AtomicBoolean called = new AtomicBoolean(false);
-
-        @Test
-        public void creates_mocks_in_correct_rulechain_ordering() {
-            assertThat(MockUtil.isMock(mock)).isTrue();
-            assertThat(called.get()).isTrue();
-        }
-
-        @Test public void unused_stub() throws Throwable {
-            when(mock.simpleMethod()).thenReturn("1");
-            assertThat(called.get()).isTrue();
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
deleted file mode 100644
index 8b65a7c0f2..0000000000
--- a/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.mockito.Mockito.when;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.internal.junit.JUnitRule;
-import org.mockito.junit.MockitoRule;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-
-public class LenientJUnitRuleTest {
-
-    private MockitoLogger explosiveLogger = new MockitoLogger() {
-        public void log(Object what) {
-            throw new RuntimeException("Silent rule should not write anything to the logger");
-        }
-    };
-    @Mock private IMethods mock;
-
-    @Rule public MockitoRule mockitoRule = new JUnitRule(explosiveLogger, Strictness.LENIENT);
-
-    @Test public void no_warning_for_unused_stubbing() throws Exception {
-        when(mock.simpleMethod(1)).thenReturn("1");
-    }
-
-    @Test public void no_warning_for_stubbing_arg_mismatch() throws Exception {
-        when(mock.simpleMethod(1)).thenReturn("1");
-        mock.simpleMethod(2);
-    }
-
-    @Test(expected = IllegalStateException.class) public void no_warning_for_stubbing_arg_mismatch_on_failure() throws Exception {
-        when(mock.simpleMethod(1)).thenReturn("1");
-        mock.simpleMethod(2);
-        throw new IllegalStateException("hey!");
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
deleted file mode 100644
index 66c9197529..0000000000
--- a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.mockito.Mockito.when;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-
-public class MutableStrictJUnitRuleTest {
-
-    JUnitCore runner = new JUnitCore();
-
-    @Test public void rule_can_be_changed_to_strict() throws Throwable {
-        //when
-        Result result = runner.run(LenientByDefault.class);
-
-        //then
-        JUnitResultAssert.assertThat(result)
-                .succeeds(1)
-                .fails(1, RuntimeException.class);
-    }
-
-    @Test public void rule_can_be_changed_to_lenient() throws Throwable {
-        //when
-        Result result = runner.run(StrictByDefault.class);
-
-        //then
-        JUnitResultAssert.assertThat(result)
-                .succeeds(1)
-                .fails(1, RuntimeException.class);
-    }
-
-    public static class LenientByDefault {
-        @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.LENIENT);
-        @Mock IMethods mock;
-
-        @Test public void unused_stub() throws Throwable {
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-
-        @Test public void unused_stub_with_strictness() throws Throwable {
-            //making Mockito strict only for this test method
-            mockito.strictness(Strictness.STRICT_STUBS);
-
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-    }
-
-    public static class StrictByDefault {
-        @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
-        @Mock IMethods mock;
-
-        @Test public void unused_stub() throws Throwable {
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-
-        @Test public void unused_stub_with_lenient() throws Throwable {
-            //making Mockito lenient only for this test method
-            mockito.strictness(Strictness.LENIENT);
-
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java b/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java
deleted file mode 100644
index df8cc48237..0000000000
--- a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.mockito.Mockito.when;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoTestRule;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-
-public class MutableStrictJUnitTestRuleTest {
-
-    JUnitCore runner = new JUnitCore();
-
-    @Test public void rule_can_be_changed_to_strict() throws Throwable {
-        //when
-        Result result = runner.run(LenientByDefault.class);
-
-        //then
-        JUnitResultAssert.assertThat(result)
-                .succeeds(1)
-                .fails(1, RuntimeException.class);
-    }
-
-    @Test public void rule_can_be_changed_to_lenient() throws Throwable {
-        //when
-        Result result = runner.run(StrictByDefault.class);
-
-        //then
-        JUnitResultAssert.assertThat(result)
-                .succeeds(1)
-                .fails(1, RuntimeException.class);
-    }
-
-    public static class LenientByDefault {
-        @Rule public MockitoTestRule mockito = MockitoJUnit.testRule(this).strictness(Strictness.LENIENT);
-        @Mock IMethods mock;
-
-        @Test public void unused_stub() throws Throwable {
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-
-        @Test public void unused_stub_with_strictness() throws Throwable {
-            //making Mockito strict only for this test method
-            mockito.strictness(Strictness.STRICT_STUBS);
-
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-    }
-
-    public static class StrictByDefault {
-        @Rule public MockitoTestRule mockito = MockitoJUnit.testRule(this).strictness(Strictness.STRICT_STUBS);
-        @Mock IMethods mock;
-
-        @Test public void unused_stub() throws Throwable {
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-
-        @Test public void unused_stub_with_lenient() throws Throwable {
-            //making Mockito lenient only for this test method
-            mockito.strictness(Strictness.LENIENT);
-
-            when(mock.simpleMethod()).thenReturn("1");
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
deleted file mode 100644
index 6dbe3d83c2..0000000000
--- a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.TestBase.filterLineNo;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.PotentialStubbingProblem;
-import org.mockito.exceptions.misusing.UnfinishedVerificationException;
-import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitousage.strictness.ProductionCode;
-import org.mockitoutil.SafeJUnitRule;
-
-public class StrictJUnitRuleTest {
-
-    @Rule public SafeJUnitRule rule = new SafeJUnitRule(MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS));
-
-    @Mock IMethods mock;
-    @Mock IMethods mock2;
-
-    @Test public void ok_when_no_stubbings() throws Throwable {
-        mock.simpleMethod();
-        verify(mock).simpleMethod();
-    }
-
-    @Test public void ok_when_all_stubbings_used() throws Throwable {
-        given(mock.simpleMethod(10)).willReturn("foo");
-        mock.simpleMethod(10);
-    }
-
-    @Test public void ok_when_used_and_mismatched_argument() throws Throwable {
-        given(mock.simpleMethod(10)).willReturn("foo");
-        mock.simpleMethod(10);
-        mock.simpleMethod(15);
-    }
-
-    @Test public void fails_when_unused_stubbings() throws Throwable {
-        //expect
-        rule.expectFailure(UnnecessaryStubbingException.class);
-
-        //when
-        given(mock.simpleMethod(10)).willReturn("foo");
-        mock2.simpleMethod(10);
-    }
-
-    @Test public void test_failure_trumps_unused_stubbings() throws Throwable {
-        //expect
-        rule.expectFailure(AssertionError.class, "x");
-
-        //when
-        given(mock.simpleMethod(10)).willReturn("foo");
-        mock.otherMethod();
-
-        throw new AssertionError("x");
-    }
-
-    @Test public void why_do_return_syntax_is_useful() throws Throwable {
-        //Trade-off of Mockito strictness documented in test
-
-        //expect
-        rule.expectFailure(PotentialStubbingProblem.class);
-
-        //when
-        when(mock.simpleMethod(10)).thenReturn("10");
-        ProductionCode.simpleMethod(mock, 20);
-    }
-
-    @Test public void fails_fast_when_stubbing_invoked_with_different_argument() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                Assertions.assertThat(t).isInstanceOf(PotentialStubbingProblem.class);
-                assertEquals(filterLineNo("\n" +
-                                "Strict stubbing argument mismatch. Please check:\n" +
-                                " - this invocation of 'simpleMethod' method:\n" +
-                                "    mock.simpleMethod(15);\n" +
-                                "    -> at org.mockitousage.strictness.ProductionCode.simpleMethod(ProductionCode.java:0)\n" +
-                                " - has following stubbing(s) with different arguments:\n" +
-                                "    1. mock.simpleMethod(20);\n" +
-                                "      -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n" +
-                                "    2. mock.simpleMethod(30);\n" +
-                                "      -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n" +
-                                "Typically, stubbing argument mismatch indicates user mistake when writing tests.\n" +
-                                "Mockito fails early so that you can debug potential problem easily.\n" +
-                                "However, there are legit scenarios when this exception generates false negative signal:\n" +
-                                "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API\n" +
-                                "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.\n" +
-                                "  - stubbed method is intentionally invoked with different arguments by code under test\n" +
-                                "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).\n" +
-                                "For more information see javadoc for PotentialStubbingProblem class."),
-                        filterLineNo(t.getMessage()));
-            }
-        });
-
-        //when stubbings in the test code:
-        willReturn("10").given(mock).simpleMethod(10) ;  //used
-        willReturn("20").given(mock).simpleMethod(20) ;  //unused
-        willReturn("30").given(mock).simpleMethod(30) ;  //unused
-
-        //then
-        mock.otherMethod(); //ok, different method
-        mock.simpleMethod(10); //ok, stubbed with this argument
-
-        //invocation in the code under test uses different argument and should fail immediately
-        //this helps with debugging and is essential for Mockito strictness
-        ProductionCode.simpleMethod(mock, 15);
-    }
-
-    @Test public void verify_no_more_interactions_ignores_stubs() throws Throwable {
-        //when stubbing in test:
-        given(mock.simpleMethod(10)).willReturn("foo");
-
-        //and code under test does:
-        mock.simpleMethod(10); //implicitly verifies the stubbing
-        mock.otherMethod();
-
-        //and in test we:
-        verify(mock).otherMethod();
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test public void unused_stubs_with_multiple_mocks() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertEquals(filterLineNo("\n" +
-                        "Unnecessary stubbings detected.\n" +
-                        "Clean & maintainable test code requires zero unnecessary code.\n" +
-                        "There are 2 unnecessary stubbings (click to navigate to relevant line of code):\n" +
-                        "  1. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n" +
-                        "  2. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n" +
-                        "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."), filterLineNo(t.getMessage()));
-            }
-        });
-
-        //when test has
-        given(mock.simpleMethod(10)).willReturn("foo");
-        given(mock2.simpleMethod(20)).willReturn("foo");
-
-        given(mock.otherMethod()).willReturn("foo"); //used and should not be reported
-
-        //and code has
-        mock.otherMethod();
-        mock2.booleanObjectReturningMethod();
-    }
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test public void rule_validates_mockito_usage() throws Throwable {
-        //expect
-        rule.expectFailure(UnfinishedVerificationException.class);
-
-        //when test contains unfinished verification
-        verify(mock);
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
deleted file mode 100644
index da9f4ac44c..0000000000
--- a/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.TestBase.filterLineNo;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.internal.junit.JUnitRule;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitoutil.SafeJUnitRule;
-
-public class StubbingWarningsJUnitRuleTest {
-
-    private SimpleMockitoLogger logger = new SimpleMockitoLogger();
-    @Rule public SafeJUnitRule rule = new SafeJUnitRule(new JUnitRule(logger, Strictness.WARN));
-    @Mock IMethods mock;
-
-    @Test
-    public void no_unused_stubs_reported_on_failure() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertEquals("x", t.getMessage());
-                assertTrue(logger.getLoggedInfo().isEmpty());
-            }
-        });
-
-        //when
-        declareStubbing(mock);
-        throw new AssertionError("x");
-    }
-
-    @Test
-    public void stubbing_arg_mismatch_on_failure() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertEquals("x", t.getMessage());
-                assertEquals(
-                    "[MockitoHint] StubbingWarningsJUnitRuleTest.stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n" +
-                    "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                    "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
-                        filterLineNo(logger.getLoggedInfo()));
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a");
-        useStubbingWithArg(mock, "b");
-        throw new AssertionError("x");
-    }
-
-    @Test public void no_stubbing_arg_mismatch_when_no_mismatch_on_fail() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertEquals("x", t.getMessage());
-                assertTrue(logger.getLoggedInfo().isEmpty());
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a");
-        useStubbingWithArg(mock, "a");
-        throw new AssertionError("x");
-    }
-
-    @Test
-    public void no_stubbing_warning_on_pass() throws Throwable {
-        //expect
-        rule.expectSuccess(new Runnable() {
-            public void run() {
-                assertTrue(logger.isEmpty());
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a");
-        useStubbingWithArg(mock, "a");
-    }
-
-    @Test
-    public void multiple_stubbing_arg_mismatch_on_failure() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertEquals("x", t.getMessage());
-                assertEquals(
-                    "[MockitoHint] StubbingWarningsJUnitRuleTest.multiple_stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n" +
-                    "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                    "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                    "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                    "[MockitoHint] 2. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                    "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                    "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
-                        filterLineNo(logger.getLoggedInfo()));
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a");
-        declareStubbingWithArg(mock, "b");
-
-        useStubbingWithArg(mock, "c");
-        useStubbingWithArg(mock, "d");
-
-        throw new AssertionError("x");
-    }
-
-    @Test
-    public void reports_only_mismatching_stubs() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-            assertEquals("x", t.getMessage());
-            assertEquals(
-                "[MockitoHint] StubbingWarningsJUnitRuleTest.reports_only_mismatching_stubs (see javadoc for MockitoHint):\n" +
-                "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
-                "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
-                    filterLineNo(logger.getLoggedInfo()));
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a"); // <-- used
-        declareStubbingWithArg(mock, "b"); // <-- unused
-
-        useStubbingWithArg(mock, "a");
-        useStubbingWithArg(mock, "d"); // <-- arg mismatch
-
-        throw new AssertionError("x");
-    }
-
-    @Test
-    public void no_mismatch_when_stub_was_used() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertEquals("x", t.getMessage());
-                assertTrue(logger.getLoggedInfo().isEmpty());
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a");
-
-        useStubbingWithArg(mock, "a");
-        useStubbingWithArg(mock, "d"); // <-- arg mismatch, but the stub was already used
-
-        throw new AssertionError("x");
-    }
-
-    @Test
-    public void no_stubbing_arg_mismatch_on_pass() throws Throwable {
-        //expect
-        rule.expectSuccess(new Runnable() {
-            public void run() {
-                assertEquals(
-                    "[MockitoHint] StubbingWarningsJUnitRuleTest.no_stubbing_arg_mismatch_on_pass (see javadoc for MockitoHint):\n" +
-                    "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
-                        filterLineNo(logger.getLoggedInfo()));
-            }
-        });
-
-        //when
-        declareStubbingWithArg(mock, "a");
-        useStubbingWithArg(mock, "b");
-    }
-
-    @Test
-    public void warns_about_unused_stubs_when_passed() throws Throwable {
-        //expect
-        rule.expectSuccess(new Runnable() {
-            public void run() {
-                assertEquals(
-                    "[MockitoHint] StubbingWarningsJUnitRuleTest.warns_about_unused_stubs_when_passed (see javadoc for MockitoHint):\n" +
-                    "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbing(StubbingWarningsJUnitRuleTest.java:0)\n",
-                        filterLineNo(logger.getLoggedInfo()));
-
-            }
-        });
-
-        //when
-        declareStubbing(mock);
-    }
-
-    private static void declareStubbingWithArg(IMethods mock, String arg) {
-        when(mock.simpleMethod(arg)).thenReturn("bar");
-    }
-
-    private static void declareStubbing(IMethods mock) {
-        when(mock.simpleMethod("foo")).thenReturn("bar");
-    }
-
-    private void useStubbingWithArg(IMethods mock, String arg) {
-        mock.simpleMethod(arg);
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java b/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
deleted file mode 100644
index 5f8bdc5e02..0000000000
--- a/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrule;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.TestBase.filterLineNo;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.internal.junit.JUnitRule;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitoutil.ConcurrentTesting;
-import org.mockitoutil.SafeJUnitRule;
-
-public class StubbingWarningsMultiThreadingTest {
-
-    private SimpleMockitoLogger logger = new SimpleMockitoLogger();
-    @Rule public SafeJUnitRule rule = new SafeJUnitRule(new JUnitRule(logger, Strictness.WARN));
-    @Mock IMethods mock;
-
-    @Test public void using_stubbing_from_different_thread() throws Throwable {
-        //expect no warnings
-        rule.expectSuccess(new Runnable() {
-            public void run() {
-                assertTrue(logger.getLoggedInfo().isEmpty());
-            }
-        });
-
-        //when stubbing is declared
-        when(mock.simpleMethod()).thenReturn("1");
-        //and used from a different thread
-        ConcurrentTesting.inThread(new Runnable() {
-                    public void run() {
-                        mock.simpleMethod();
-                    }
-                });
-    }
-
-    @Test public void unused_stub_from_different_thread() throws Throwable {
-        //expect warnings
-        rule.expectSuccess(new Runnable() {
-            public void run() {
-                assertEquals(
-                    "[MockitoHint] StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread (see javadoc for MockitoHint):\n" +
-                    "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread(StubbingWarningsMultiThreadingTest.java:0)\n",
-                        filterLineNo(logger.getLoggedInfo()));
-            }
-        });
-
-        //when stubbings are declared
-        when(mock.simpleMethod(1)).thenReturn("1");
-        when(mock.simpleMethod(2)).thenReturn("2");
-
-        //and one of the stubbings is used from a different thread
-        ConcurrentTesting.inThread(new Runnable() {
-            public void run() {
-                mock.simpleMethod(1);
-            }
-        });
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
deleted file mode 100644
index 040d0d9aa1..0000000000
--- a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrunner;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.List;
-
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.UnfinishedStubbingException;
-import org.mockito.exceptions.verification.TooFewActualInvocations;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-import org.mockitoutil.TestBase;
-
-public class SilentRunnerTest extends TestBase {
-
-    JUnitCore runner = new JUnitCore();
-
-    @Test public void passing_test() {
-        //when
-        Result result = runner.run(
-                SomeFeature.class
-        );
-        //then
-        JUnitResultAssert.assertThat(result).isSuccessful();
-    }
-
-    @Test public void failing_test() {
-        //when
-        Result result = runner.run(
-                SomeFailingFeature.class
-        );
-        //then
-        JUnitResultAssert.assertThat(result).fails(1, TooFewActualInvocations.class);
-    }
-
-    @Test public void failing_test_in_constructor() {
-        //when
-        Result result = runner.run(
-                FailsInConstructor.class
-        );
-        //then
-        JUnitResultAssert.assertThat(result).fails(1, IllegalArgumentException.class);
-    }
-
-    @Test public void validates_framework_usage() {
-        //when
-        Result result = runner.run(
-                UsesFrameworkIncorrectly.class
-        );
-        //then
-        JUnitResultAssert.assertThat(result).fails(1, "unfinished_stubbing_test_method", UnfinishedStubbingException.class);
-    }
-
-    @Test
-    public void ignores_unused_stubs() {
-        JUnitCore runner = new JUnitCore();
-        //when
-        Result result = runner.run(HasUnnecessaryStubs.class);
-        //then
-        JUnitResultAssert.assertThat(result).isSuccessful();
-    }
-
-    @RunWith(MockitoJUnitRunner.Silent.class)
-    public static class SomeFeature {
-        @Mock List<String> list;
-        @Test public void some_behavior() {
-            when(list.get(0)).thenReturn("0");
-            assertEquals("0", list.get(0));
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.Silent.class)
-    public static class SomeFailingFeature {
-        @Mock List<String> list;
-        @Test public void some_failing_behavior() {
-            list.clear();
-            verify(list, times(2)).clear();
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.Silent.class)
-    public static class FailsInConstructor {
-        {
-            if (System.currentTimeMillis() > 0) {
-                throw new IllegalArgumentException("Boo!");
-            }
-        }
-        @Mock List<String> list;
-        @Test public void some_behavior() {}
-    }
-
-    @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
-        }
-    }
-
-    /**
-     * The test class itself is passing but it has some unnecessary stubs
-     */
-    @RunWith(MockitoJUnitRunner.Silent.class)
-    public static class HasUnnecessaryStubs {
-        IMethods mock1 = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
-        IMethods mock2 = when(mock(IMethods.class).simpleMethod(2)).thenReturn("2").getMock();
-        IMethods mock3 = when(mock(IMethods.class).simpleMethod(3)).thenReturn("3").getMock();
-
-        @Test
-        public void usesStub() {
-            assertEquals("1", mock1.simpleMethod(1));
-        }
-
-        @Test
-        public void usesStubWithDifferentArg() {
-            assertEquals(null, mock2.simpleMethod(200));
-            assertEquals(null, mock3.simpleMethod(300));
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
deleted file mode 100644
index 5b7591fb67..0000000000
--- a/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrunner;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.junit.MockitoRule;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-import org.mockitoutil.TestBase;
-
-
-public class StrictRunnerTest extends TestBase {
-
-    JUnitCore runner = new JUnitCore();
-
-    @Test public void succeeds_when_all_stubs_were_used() {
-        //when
-        Result result = runner.run(
-                StubbingInConstructorUsed.class,
-                StubbingInBeforeUsed.class,
-                StubbingInTestUsed.class
-        );
-        //then
-        JUnitResultAssert.assertThat(result).isSuccessful();
-    }
-
-    @Test public void fails_when_stubs_were_not_used() {
-        Class[] tests = {StubbingInConstructorUnused.class,
-                StubbingInBeforeUnused.class,
-                StubbingInTestUnused.class};
-
-        //when
-        Result result = runner.run(tests);
-
-        //then
-        JUnitResultAssert.assertThat(result).fails(3, UnnecessaryStubbingException.class);
-    }
-
-    @Test public void does_not_report_unused_stubs_when_different_failure_is_present() {
-        //when
-        Result result = runner.run(WithUnrelatedAssertionFailure.class);
-
-        //then
-        JUnitResultAssert.assertThat(result).fails(1, MyAssertionError.class);
-    }
-
-    @Test public void runner_can_coexist_with_rule() {
-        //I don't believe that this scenario is useful
-        //I only wish that Mockito does not break awkwardly when both: runner & rule is used
-
-        //when
-        Result result = runner.run(RunnerAndRule.class);
-
-        //then
-        JUnitResultAssert.assertThat(result).fails(1, UnnecessaryStubbingException.class);
-    }
-
-    @Test public void runner_in_multi_threaded_tests() {
-        //when
-        Result result = runner.run(StubUsedFromDifferentThread.class);
-
-        //then
-        JUnitResultAssert.assertThat(result).isSuccessful();
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class StubbingInConstructorUsed extends StubbingInConstructorUnused {
-        @Test public void test() {
-            assertEquals("1", mock.simpleMethod(1));
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.Strict.class) //using Strict to make sure it does the right thing
-    public static class StubbingInConstructorUnused {
-        IMethods mock = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
-        @Test public void dummy() {}
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class StubbingInBeforeUsed extends StubbingInBeforeUnused {
-        @Test public void test() {
-            assertEquals("1", mock.simpleMethod(1));
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class StubbingInBeforeUnused {
-        @Mock IMethods mock;
-        @Before public void before() {
-            when(mock.simpleMethod(1)).thenReturn("1");
-        }
-        @Test public void dummy() {}
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class StubbingInTestUsed {
-        @Test public void test() {
-            IMethods mock = mock(IMethods.class);
-            when(mock.simpleMethod(1)).thenReturn("1");
-            assertEquals("1", mock.simpleMethod(1));
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class StubbingInTestUnused {
-        @Test public void test() {
-            IMethods mock = mock(IMethods.class);
-            when(mock.simpleMethod(1)).thenReturn("1");
-            mock.simpleMethod(2); //different arg
-        }
-    }
-
-    private static class MyAssertionError extends AssertionError {}
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class WithUnrelatedAssertionFailure {
-
-        IMethods mock = mock(IMethods.class);
-        IMethods mock2 = mock(IMethods.class);
-
-        @Before public void before() {
-            when(mock2.simpleMethod("unused stubbing")).thenReturn("");
-        }
-
-        @Test public void passing_test() {
-            when(mock.simpleMethod(1)).thenReturn("1");
-            assertEquals("1", mock.simpleMethod(1));
-        }
-
-        @Test public void failing_test() {
-            throw new MyAssertionError();
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class RunnerAndRule {
-
-        public @Rule MockitoRule rule = MockitoJUnit.rule();
-        IMethods mock = mock(IMethods.class);
-
-        @Test public void passing_test() {
-            when(mock.simpleMethod(1)).thenReturn("1");
-            mock.simpleMethod(2);
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.class)
-    public static class StubUsedFromDifferentThread {
-
-        IMethods mock = mock(IMethods.class);
-
-        @Test public void passing_test() throws Exception {
-            //stubbing is done in main thread:
-            when(mock.simpleMethod(1)).thenReturn("1");
-
-            //stubbing is used in a different thread
-            //stubbing should not be reported as unused by the runner
-            Thread t = new Thread() {
-                public void run() {
-                    mock.simpleMethod(1);
-                }
-            };
-            t.start();
-            t.join();
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
deleted file mode 100644
index 7fc857de97..0000000000
--- a/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrunner;
-
-import static org.mockito.Mockito.when;
-
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.PotentialStubbingProblem;
-import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitousage.strictness.ProductionCode;
-import org.mockitoutil.JUnitResultAssert;
-import org.mockitoutil.TestBase;
-
-public class StrictStubsRunnerTest extends TestBase {
-
-    JUnitCore runner = new JUnitCore();
-
-    @Test public void detects_unnecessary_stubbings() {
-        //when
-        Result result = runner.run(UnnecessaryStubbing.class);
-        //then
-        JUnitResultAssert.assertThat(result)
-                .fails(1, UnnecessaryStubbingException.class)
-                .succeeds(2);
-    }
-
-    @Test public void fails_fast_on_argument_mismatch() {
-        //when
-        Result result = runner.run(StubbingArgMismatch.class);
-        //then
-        JUnitResultAssert.assertThat(result)
-                .succeeds(2)
-                .fails(1, PotentialStubbingProblem.class);
-    }
-
-    @RunWith(MockitoJUnitRunner.StrictStubs.class)
-    public static class UnnecessaryStubbing {
-        @Mock IMethods mock;
-        @Test public void unused_stubbing_1() {
-            when(mock.simpleMethod()).thenReturn("");
-        }
-        @Test public void unused_stubbing_2() {
-            when(mock.simpleMethod()).thenReturn("");
-        }
-        @Test public void correct_stubbing() {
-            when(mock.simpleMethod()).thenReturn("");
-            mock.simpleMethod();
-        }
-    }
-
-    @RunWith(MockitoJUnitRunner.StrictStubs.class)
-    public static class StubbingArgMismatch {
-        @Mock IMethods mock;
-        @Test public void passing1() {}
-        @Test public void passing2() {
-            when(mock.simpleMethod()).thenReturn("");
-            mock.simpleMethod();
-        }
-        @Test public void argument_mismatch() {
-            when(mock.simpleMethod(10)).thenReturn("");
-            ProductionCode.simpleMethod(mock, 20);
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
deleted file mode 100644
index e878683625..0000000000
--- a/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrunner;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.JUnitResultAssert.assertThat;
-
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.UnfinishedStubbingException;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.junit.TestableJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class StubbingWarningsJUnitRunnerTest extends TestBase {
-
-    JUnitCore runner = new JUnitCore();
-    SimpleMockitoLogger logger = TestableJUnitRunner.refreshedLogger();
-
-    @Test public void no_arg_mismatch_warnings() {
-        //when
-        runner.run(PassingArgMismatch.class, FailingWithMatchingArgs.class, MismatchButStubAlreadyUsed.class);
-
-        //then
-        assertEquals("", filterLineNo(logger.getLoggedInfo()));
-    }
-
-    @Test public void shows_arg_mismatch_warnings_when_test_fails() {
-        //when
-        runner.run(FailingWithArgMismatch.class);
-
-        //then
-        assertEquals("[MockitoHint] FailingWithArgMismatch.test (see javadoc for MockitoHint):\n" +
-                "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n" +
-                "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n", filterLineNo(logger.getLoggedInfo()));
-    }
-
-    @Test public void shows_arg_mismatch_warnings_only_for_mismatches() {
-        //when
-        runner.run(FailingWithSomeStubMismatches.class);
-
-        //then
-        assertEquals("[MockitoHint] FailingWithSomeStubMismatches.test (see javadoc for MockitoHint):\n" +
-                "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n" +
-                "[MockitoHint]  ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n", filterLineNo(logger.getLoggedInfo()));
-    }
-
-    @Test public void validates_mockito_usage() {
-        //when
-        Result result = runner.run(InvalidMockitoUsage.class);
-
-        //then
-        assertThat(result).fails(1, UnfinishedStubbingException.class);
-    }
-
-    @RunWith(TestableJUnitRunner.class)
-    public static class PassingArgMismatch {
-        IMethods mock = mock(IMethods.class);
-        @Test public void test() throws Exception {
-            when(mock.simpleMethod(1)).thenReturn("1");
-            mock.simpleMethod(2);
-        }
-    }
-
-    @RunWith(TestableJUnitRunner.class)
-    public static class FailingWithArgMismatch {
-        @Mock IMethods mock;
-        @Test public void test() throws Exception {
-            when(mock.simpleMethod(1)).thenReturn("1");
-            mock.simpleMethod(2);
-            throw new RuntimeException("x");
-        }
-    }
-
-    @RunWith(TestableJUnitRunner.class)
-    public static class FailingWithMatchingArgs {
-        @Mock IMethods mock;
-        @Test public void test() throws Exception {
-            when(mock.simpleMethod(1)).thenReturn("1");
-            mock.simpleMethod(1);
-            throw new RuntimeException("x");
-        }
-    }
-
-    @RunWith(TestableJUnitRunner.class)
-    public static class FailingWithSomeStubMismatches {
-        @Mock IMethods mock;
-        @Test public void test() throws Exception {
-            when(mock.simpleMethod(1)).thenReturn("1"); // <- used
-            when(mock.simpleMethod(2)).thenReturn("2"); // <- unused
-
-            mock.simpleMethod(1); // <- not reported
-            mock.simpleMethod(3); // <- reported
-
-            throw new RuntimeException("x");
-        }
-    }
-
-    @RunWith(TestableJUnitRunner.class)
-    public static class MismatchButStubAlreadyUsed {
-        @Mock IMethods mock;
-        @Test public void test() throws Exception {
-            when(mock.simpleMethod(1)).thenReturn("1");
-            mock.simpleMethod(1); // <-- used
-            mock.simpleMethod(2); // <-- arg mismatch, but the stub was already used
-
-            throw new RuntimeException("x");
-        }
-    }
-
-    @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/junitrunner/UnusedStubsExceptionMessageTest.java b/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
deleted file mode 100644
index 394d013a04..0000000000
--- a/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrunner;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.junit.runner.notification.Failure;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class UnusedStubsExceptionMessageTest extends TestBase {
-
-    //Moving the code around this class is tricky and may cause the test to fail
-    //We're asserting on full exception message which contains line numbers
-    //Let's leave it for now, updating the test is cheap and if it turns out hindrance we can make the assertion smarter.
-    @RunWith(MockitoJUnitRunner.class)
-    public static class HasUnnecessaryStubs {
-        IMethods mock1 = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
-        IMethods mock2 = when(mock(IMethods.class).simpleMethod(2)).thenReturn("2").getMock();
-        IMethods mock3 = when(mock(IMethods.class).simpleMethod(3)).thenReturn("3").getMock();
-
-        @Test
-        public void usesStub() {
-            assertEquals("1", mock1.simpleMethod(1));
-        }
-
-        @Test
-        public void usesStubWithDifferentArg() {
-            assertEquals(null, mock2.simpleMethod(200));
-            assertEquals(null, mock3.simpleMethod(300));
-        }
-    }
-
-    @Test
-    public void lists_all_unused_stubs_cleanly() {
-        JUnitCore runner = new JUnitCore();
-        //when
-        Result result = runner.run(HasUnnecessaryStubs.class);
-        //then
-        Failure failure = result.getFailures().get(0);
-        assertEquals("\n" +
-                        "Unnecessary stubbings detected in test class: HasUnnecessaryStubs\n" +
-                        "Clean & maintainable test code requires zero unnecessary code.\n" +
-                        "There are 2 unnecessary stubbings (click to navigate to relevant line of code):\n" +
-                        "  1. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n" +
-                        "  2. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n" +
-                        "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.",
-            filterLineNo(failure.getException().getMessage()));
-    }
-}
diff --git a/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java
deleted file mode 100644
index 44f6407aae..0000000000
--- a/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.junitrunner;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.*;
-
-import junit.framework.TestCase;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.internal.exceptions.ExceptionIncludingMockitoWarnings;
-import org.mockito.runners.VerboseMockitoJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-//@RunWith(ConsoleSpammingMockitoJUnitRunner.class)
-@RunWith(VerboseMockitoJUnitRunner.class)
-//TODO
-public class VerboseMockitoRunnerTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    public static class NoWarnings {
-
-        @Test
-        @Ignore
-        public void test() {
-            IMethods mock = mock(IMethods.class);
-            mock.simpleMethod(1);
-            mock.otherMethod();
-
-            verify(mock).simpleMethod(1);
-            throw new RuntimeException("boo");
-        }
-    }
-
-    public static class ContainsWarnings extends TestCase {
-
-        public ContainsWarnings() {
-            super("test");
-        }
-
-        public void testIgnored() {}
-
-        public void _test() {
-            IMethods mock = mock(IMethods.class);
-
-            //some stubbing
-            when(mock.simpleMethod(1)).thenReturn("foo");
-            when(mock.otherMethod()).thenReturn("foo");
-            when(mock.booleanObjectReturningMethod()).thenReturn(false);
-
-            //stub called with different args:
-            String ret = mock.simpleMethod(2);
-
-            //assertion fails due to stub called with different args
-            assertEquals("foo", ret);
-        }
-    }
-
-    public void cleanStackTraces() {
-        makeStackTracesClean();
-    }
-
-    @Test
-    @Ignore
-    public void shouldContainWarnings() throws Exception {
-        //when
-        Result result = new JUnitCore().run(new ContainsWarnings());
-        //then
-        assertEquals(1, result.getFailures().size());
-        Throwable exception = result.getFailures().get(0).getException();
-        assertTrue(exception instanceof ExceptionIncludingMockitoWarnings);
-    }
-
-    @Test
-    @Ignore
-    public void shouldNotContainWarnings() throws Exception {
-        Result result = new JUnitCore().run(NoWarnings.class);
-        assertEquals(1, result.getFailures().size());
-        assertEquals("boo", result.getFailures().get(0).getException().getMessage());
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java b/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
deleted file mode 100644
index 4701870a7d..0000000000
--- a/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.when;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class AnyXMatchersAcceptNullsTest extends TestBase {
-
-    private IMethods mock;
-
-    @Before
-    public void setUp() {
-        mock = Mockito.mock(IMethods.class);
-    }
-
-    @Test
-    public void shouldAcceptNullsInAnyMatcher() {
-        when(mock.oneArg((Object) any())).thenReturn("matched");
-
-        assertEquals(null, mock.forObject(null));
-    }
-
-    @Test
-    public void shouldAcceptNullsInAnyObjectMatcher() {
-        when(mock.oneArg((Object) anyObject())).thenReturn("matched");
-
-        assertEquals(null, mock.forObject(null));
-    }
-
-    @Test
-    public void shouldNotAcceptNullInAnyXMatchers() {
-        when(mock.oneArg(anyString())).thenReturn("0");
-        when(mock.forList(anyListOf(String.class))).thenReturn("1");
-        when(mock.forMap(anyMapOf(String.class, String.class))).thenReturn("2");
-        when(mock.forCollection(anyCollectionOf(String.class))).thenReturn("3");
-        when(mock.forSet(anySetOf(String.class))).thenReturn("4");
-
-        assertEquals(null, mock.oneArg((Object) null));
-        assertEquals(null, mock.oneArg((String) null));
-        assertEquals(null, mock.forList(null));
-        assertEquals(null, mock.forMap(null));
-        assertEquals(null, mock.forCollection(null));
-        assertEquals(null, mock.forSet(null));
-    }
-
-    @Test
-    public void shouldNotAcceptNullInAllAnyPrimitiveWrapperMatchers() {
-        when(mock.forInteger(anyInt())).thenReturn("0");
-        when(mock.forCharacter(anyChar())).thenReturn("1");
-        when(mock.forShort(anyShort())).thenReturn("2");
-        when(mock.forByte(anyByte())).thenReturn("3");
-        when(mock.forBoolean(anyBoolean())).thenReturn("4");
-        when(mock.forLong(anyLong())).thenReturn("5");
-        when(mock.forFloat(anyFloat())).thenReturn("6");
-        when(mock.forDouble(anyDouble())).thenReturn("7");
-
-        assertEquals(null, mock.forInteger(null));
-        assertEquals(null, mock.forCharacter(null));
-        assertEquals(null, mock.forShort(null));
-        assertEquals(null, mock.forByte(null));
-        assertEquals(null, mock.forBoolean(null));
-        assertEquals(null, mock.forLong(null));
-        assertEquals(null, mock.forFloat(null));
-        assertEquals(null, mock.forDouble(null));
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java b/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
deleted file mode 100644
index fc0f123c1d..0000000000
--- a/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class CapturingArgumentsTest extends TestBase {
-
-    class Person {
-
-        private final Integer age;
-
-        public Person(Integer age) {
-            this.age = age;
-        }
-
-        public int getAge() {
-            return age;
-        }
-    }
-
-    class BulkEmailService {
-
-        private EmailService service;
-
-        public BulkEmailService(EmailService service) {
-            this.service = service;
-        }
-
-        public void email(Integer ... personId) {
-            for (Integer i : personId) {
-                Person person = new Person(i);
-                service.sendEmailTo(person);
-            }
-        }
-    }
-
-    interface EmailService {
-        boolean sendEmailTo(Person person);
-    }
-
-    EmailService emailService = mock(EmailService.class);
-    BulkEmailService bulkEmailService = new BulkEmailService(emailService);
-    IMethods mock = mock(IMethods.class);
-
-    @SuppressWarnings("deprecation")
-    @Test
-    public void should_allow_assertions_on_captured_argument() {
-        //given
-        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
-
-        //when
-        bulkEmailService.email(12);
-
-        //then
-        verify(emailService).sendEmailTo(argument.capture());
-        assertEquals(12, argument.getValue().getAge());
-    }
-
-    @Test
-    public void should_allow_assertions_on_all_captured_arguments() {
-        //given
-        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
-
-        //when
-        bulkEmailService.email(11, 12);
-
-        //then
-        verify(emailService, times(2)).sendEmailTo(argument.capture());
-        assertEquals(11, argument.getAllValues().get(0).getAge());
-        assertEquals(12, argument.getAllValues().get(1).getAge());
-    }
-
-    @Test
-    public void should_allow_assertions_on_last_argument() {
-        //given
-        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
-
-        //when
-        bulkEmailService.email(11, 12, 13);
-
-        //then
-        verify(emailService, times(3)).sendEmailTo(argument.capture());
-        assertEquals(13, argument.getValue().getAge());
-    }
-
-    @Test
-    public void should_print_captor_matcher() {
-        //given
-        ArgumentCaptor<Person> person = ArgumentCaptor.forClass(Person.class);
-
-        try {
-            //when
-            verify(emailService).sendEmailTo(person.capture());
-            fail();
-        } catch(WantedButNotInvoked e) {
-            //then
-            assertThat(e).hasMessageContaining("<Capturing argument>");
-        }
-    }
-
-    @Test
-    public void should_allow_assertions_on_captured_null() {
-        //given
-        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
-
-        //when
-        emailService.sendEmailTo(null);
-
-        //then
-        verify(emailService).sendEmailTo(argument.capture());
-        assertEquals(null, argument.getValue());
-    }
-
-    @Test
-    public void should_allow_construction_of_captor_for_parameterized_type_in_a_convenient_way()  {
-        //the test passes if this expression compiles
-        @SuppressWarnings("unchecked")
-        ArgumentCaptor<List<Person>> argument = ArgumentCaptor.forClass(List.class);
-        assertNotNull(argument);
-    }
-
-    @Test
-    public void should_allow_construction_of_captor_for_a_more_specific_type()  {
-        //the test passes if this expression compiles
-        ArgumentCaptor<List<?>> argument = ArgumentCaptor.forClass(ArrayList.class);
-        assertNotNull(argument);
-    }
-
-    @Test
-    public void should_allow_capturing_for_stubbing() {
-        //given
-        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
-        when(emailService.sendEmailTo(argument.capture())).thenReturn(false);
-
-        //when
-        emailService.sendEmailTo(new Person(10));
-
-        //then
-        assertEquals(10, argument.getValue().getAge());
-    }
-
-    @Test
-    public void should_capture_when_stubbing_only_when_entire_invocation_matches() {
-        //given
-        ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
-        when(mock.simpleMethod(argument.capture(), eq(2))).thenReturn("blah");
-
-        //when
-        mock.simpleMethod("foo", 200);
-        mock.simpleMethod("bar", 2);
-
-        //then
-        Assertions.assertThat(argument.getAllValues()).containsOnly("bar");
-    }
-
-    @Test
-    public void should_say_something_smart_when_misused() {
-        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
-        try {
-            argument.getValue();
-            fail();
-        } catch (MockitoException expected) { }
-    }
-
-    @Test
-    public void should_capture_when_full_arg_list_matches() throws Exception {
-        //given
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-
-        //when
-        mock.simpleMethod("foo", 1);
-        mock.simpleMethod("bar", 2);
-
-        //then
-        verify(mock).simpleMethod(captor.capture(), eq(1));
-        assertEquals(1, captor.getAllValues().size());
-        assertEquals("foo", captor.getValue());
-    }
-
-    @Test
-    public void should_capture_int_by_creating_captor_with_primitive_wrapper() {
-        //given
-        ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(Integer.class);
-
-        //when
-        mock.intArgumentMethod(10);
-
-        //then
-        verify(mock).intArgumentMethod(argument.capture());
-        assertEquals(10, (int) argument.getValue());
-    }
-
-    @Test
-    public void should_capture_int_by_creating_captor_with_primitive() throws Exception {
-        //given
-        ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(int.class);
-
-        //when
-        mock.intArgumentMethod(10);
-
-        //then
-        verify(mock).intArgumentMethod(argument.capture());
-        assertEquals(10, (int) argument.getValue());
-    }
-
-    @Test
-    public void should_capture_byte_vararg_by_creating_captor_with_primitive() throws Exception {
-        // given
-        ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(byte.class);
-
-        // when
-        mock.varargsbyte((byte) 1, (byte) 2);
-
-        // then
-        verify(mock).varargsbyte(argumentCaptor.capture());
-        assertEquals((byte) 2, (byte) argumentCaptor.getValue());
-        Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly((byte) 1, (byte) 2);
-    }
-
-    @Test
-    public void should_capture_byte_vararg_by_creating_captor_with_primitive_wrapper() throws Exception {
-        // given
-        ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(Byte.class);
-
-        // when
-        mock.varargsbyte((byte) 1, (byte) 2);
-
-        // then
-        verify(mock).varargsbyte(argumentCaptor.capture());
-        assertEquals((byte) 2, (byte) argumentCaptor.getValue());
-        Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly((byte) 1, (byte) 2);
-    }
-
-    @Test
-    public void should_capture_vararg() throws Exception {
-        // given
-        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-
-        // when
-        mock.mixedVarargs(42, "a", "b", "c");
-
-        // then
-        verify(mock).mixedVarargs(any(), argumentCaptor.capture());
-        Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c");
-    }
-
-    @Test
-    public void should_capture_all_vararg() throws Exception {
-        // given
-        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-
-        // when
-        mock.mixedVarargs(42, "a", "b", "c");
-        mock.mixedVarargs(42, "again ?!");
-
-        // then
-        verify(mock, times(2)).mixedVarargs(any(), argumentCaptor.capture());
-
-        Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c", "again ?!");
-    }
-
-    @Test
-    public void should_capture_one_arg_even_when_using_vararg_captor_on_nonvararg_method() throws Exception {
-        // given
-        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-
-        // when
-        mock.simpleMethod("a", 2);
-
-        // then
-        verify(mock).simpleMethod(argumentCaptor.capture(), eq(2));
-        Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a");
-    }
-
-    @Test
-    public void captures_correctly_when_captor_used_multiple_times() throws Exception {
-        // given
-        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-
-        // when
-        mock.mixedVarargs(42, "a", "b", "c");
-
-        // then
-        // this is only for backwards compatibility. It does not make sense in real to do so.
-        verify(mock).mixedVarargs(any(), argumentCaptor.capture(), argumentCaptor.capture(), argumentCaptor.capture());
-        Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c");
-    }
-
-    @Test
-    public void captures_correctly_when_captor_used_on_pure_vararg_method() throws Exception {
-        // given
-        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-
-        // when
-        mock.varargs(42, "capturedValue");
-
-        // then
-        verify(mock).varargs(eq(42), argumentCaptor.capture());
-        Assertions.assertThat(argumentCaptor.getValue()).contains("capturedValue");
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java b/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
deleted file mode 100644
index 0545e2f877..0000000000
--- a/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.hamcrest.MockitoHamcrest.*;
-
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class HamcrestMatchersTest extends TestBase {
-
-    private final class ContainsX extends BaseMatcher<String> {
-        public boolean matches(Object o) {
-            return ((String) o).contains("X");
-        }
-
-        public void describeTo(Description d) {
-            d.appendText("contains 'X'");
-        }
-    }
-
-    @Mock
-    private IMethods mock;
-
-    @Test
-    public void stubs_with_hamcrest_matcher() {
-        when(mock.simpleMethod(argThat(new ContainsX()))).thenReturn("X");
-        assertNull(mock.simpleMethod("blah"));
-        assertEquals("X", mock.simpleMethod("blah X blah"));
-    }
-
-    @Test
-    public void verifies_with_hamcrest_matcher() {
-        mock.simpleMethod("blah");
-
-        try {
-            verify(mock).simpleMethod(argThat(new ContainsX()));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e).hasMessageContaining("contains 'X'");
-        }
-    }
-
-    private class IntMatcher extends BaseMatcher<Integer> {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeTo(Description description) {}
-    }
-
-    @Test
-    public void supports_primitive_matchers() {
-        when(mock.intArgumentReturningInt(argThat(new IntMatcher()))).thenReturn(5);
-        assertEquals(5, mock.intArgumentReturningInt(10));
-    }
-
-    @Test
-    public void supports_primitive_matchers_from_core_library() {
-        mock.oneArg(true);
-        mock.oneArg((byte) 1);
-        mock.oneArg(2);
-        mock.oneArg(3L);
-        mock.oneArg('4');
-        mock.oneArg(5.0D);
-        mock.oneArg(6.0F);
-
-        verify(mock).oneArg(booleanThat(is(true)));
-        verify(mock).oneArg(byteThat(is((byte) 1)));
-        verify(mock).oneArg(intThat(is(2)));
-        verify(mock).oneArg(longThat(is(3L)));
-        verify(mock).oneArg(charThat(is('4')));
-        verify(mock).oneArg(doubleThat(is(5.0D)));
-        verify(mock).oneArg(floatThat(is(6.0F)));
-    }
-
-    @SuppressWarnings("rawtypes")
-    private class NonGenericMatcher extends BaseMatcher {
-        public boolean matches(Object o) {
-            return true;
-        }
-        public void describeTo(Description description) {}
-    }
-
-    @Test
-    public void supports_non_generic_matchers() {
-        when(mock.intArgumentReturningInt(nonGenericMatcher())).thenReturn(5);
-        assertEquals(5, mock.intArgumentReturningInt(10));
-    }
-
-    @SuppressWarnings("unchecked")
-    private int nonGenericMatcher() {
-        argThat(new NonGenericMatcher());
-        return 0;
-    }
-
-    @Test
-    public void coexists_with_mockito_matcher() {
-        when(mock.simpleMethod(Mockito.argThat(new ArgumentMatcher<String>() {
-            public boolean matches(String argument) {
-                return true;
-            }
-        }))).thenReturn("x");
-
-        assertEquals("x", mock.simpleMethod("x"));
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java b/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
deleted file mode 100644
index fdaa80db3f..0000000000
--- a/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class MatchersMixedWithRawArgumentsTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    //description of an idea:
-    //types of arguments and descriptor value that identifies matcher:
-    //Object: objenesis instance to check for identity
-    //boolean: false
-    //byte: max-1
-    //short: max-1
-    //int: max-1
-    //long: max-1
-    //char: 'x'
-    //double: max-1
-    //float: max-1
-
-    //1. how objenesis deal with primitive arrays (like byte[])?
-    //2. Analisys of all matchers used by R2 project finished before anyObject() and so far proves it's a good idea.
-
-    @Ignore("prototyping new feature that allows to avoid eq() matchers when raw args passed")
-    @Test
-    public void shouldAllowMixingRawArgumentsWithMatchers() {
-        mock.varargs("1", "2", "3");
-        verify(mock).varargs("1", anyString(), "3");
-
-        verify(mock).varargs(anyBoolean(), false);
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
deleted file mode 100644
index 09ff888049..0000000000
--- a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.*;
-
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class MoreMatchersTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    @Test
-    public void should_help_out_with_unnecessary_casting() {
-        when(mock.objectArgMethod(any(String.class))).thenReturn("string");
-
-        assertEquals("string", mock.objectArgMethod("foo"));
-    }
-
-    @Test
-    public void any_should_be_actual_alias_to_anyObject() {
-        mock.simpleMethod((Object) null);
-
-        verify(mock).simpleMethod(Mockito.<Object>any());
-        verify(mock).simpleMethod(Mockito.<Object>anyObject());
-    }
-
-    @Test
-    public void any_class_should_be_actual_alias_to_isA() {
-        mock.simpleMethod(new ArrayList());
-
-        verify(mock).simpleMethod(isA(List.class));
-        verify(mock).simpleMethod(any(List.class));
-
-        mock.simpleMethod((String) null);
-
-        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
-    public void should_help_out_with_unnecessary_casting_of_lists() {
-        //Below yields compiler warning:
-        //when(mock.listArgMethod(anyList())).thenReturn("list");
-        when(mock.listArgMethod(anyListOf(String.class))).thenReturn("list");
-
-        assertEquals("list", mock.listArgMethod(new LinkedList<String>()));
-        assertEquals("list", mock.listArgMethod(Collections.<String>emptyList()));
-    }
-
-    @Test
-    public void should_help_out_with_unnecessary_casting_of_sets() {
-        //Below yields compiler warning:
-        //when(mock.setArgMethod(anySet())).thenReturn("set");
-        when(mock.setArgMethod(anySetOf(String.class))).thenReturn("set");
-
-        assertEquals("set", mock.setArgMethod(new HashSet<String>()));
-        assertEquals("set", mock.setArgMethod(Collections.<String>emptySet()));
-    }
-
-    @Test
-    public void should_help_out_with_unnecessary_casting_of_maps() {
-        //Below yields compiler warning:
-        //when(mock.setArgMethod(anySet())).thenReturn("set");
-        when(mock.forMap(anyMapOf(String.class, String.class))).thenReturn("map");
-
-        assertEquals("map", mock.forMap(new HashMap<String, String>()));
-        assertEquals("map", mock.forMap(Collections.<String, String>emptyMap()));
-    }
-
-    @Test
-    public void should_help_out_with_unnecessary_casting_of_collections() {
-        //Below yields compiler warning:
-        //when(mock.setArgMethod(anySet())).thenReturn("set");
-        when(mock.collectionArgMethod(anyCollectionOf(String.class))).thenReturn("collection");
-
-        assertEquals("collection", mock.collectionArgMethod(new ArrayList<String>()));
-        assertEquals("collection", mock.collectionArgMethod(Collections.<String>emptyList()));
-    }
-
-    @Test
-    public void should_help_out_with_unnecessary_casting_of_iterables() {
-        //Below yields compiler warning:
-        //when(mock.setArgMethod(anySet())).thenReturn("set");
-        when(mock.iterableArgMethod(anyIterableOf(String.class))).thenReturn("iterable");
-
-        assertEquals("iterable", mock.iterableArgMethod(new ArrayList<String>()));
-        assertEquals("iterable", mock.iterableArgMethod(Collections.<String>emptyList()));
-    }
-
-    @Test
-    public void should_help_out_with_unnecessary_casting_of_nullity_checks() {
-        when(mock.objectArgMethod(isNull(LinkedList.class))).thenReturn("string");
-        when(mock.objectArgMethod(notNull(LinkedList.class))).thenReturn("string");
-        when(mock.objectArgMethod(isNotNull(LinkedList.class))).thenReturn("string");
-
-        assertEquals("string", mock.objectArgMethod(null));
-        assertEquals("string", mock.objectArgMethod("foo"));
-        assertEquals("string", mock.objectArgMethod("foo"));
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/matchers/NewMatchersTest.java b/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
deleted file mode 100644
index 6b26311ecb..0000000000
--- a/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class NewMatchersTest extends TestBase {
-
-    private IMethods mock;
-
-    @Before
-    public void setUp() {
-        mock = Mockito.mock(IMethods.class);
-    }
-
-    @Test
-    public void shouldAllowAnyList() {
-        when(mock.forList(anyListOf(String.class))).thenReturn("matched");
-
-        assertEquals("matched", mock.forList(Arrays.asList("x", "y")));
-        assertEquals(null, mock.forList(null));
-
-        verify(mock, times(1)).forList(anyListOf(String.class));
-    }
-
-    @Test
-    public void shouldAllowAnyCollection() {
-        when(mock.forCollection(anyCollectionOf(String.class))).thenReturn("matched");
-
-        assertEquals("matched", mock.forCollection(Arrays.asList("x", "y")));
-        assertEquals(null, mock.forCollection(null));
-
-        verify(mock, times(1)).forCollection(anyCollectionOf(String.class));
-    }
-
-    @Test
-    public void shouldAllowAnyMap() {
-        when(mock.forMap(anyMapOf(String.class, String.class))).thenReturn("matched");
-
-        assertEquals("matched", mock.forMap(new HashMap<String, String>()));
-        assertEquals(null, mock.forMap(null));
-
-        verify(mock, times(1)).forMap(anyMapOf(String.class, String.class));
-    }
-
-    @Test
-    public void shouldAllowAnySet() {
-        when(mock.forSet(anySetOf(String.class))).thenReturn("matched");
-
-        assertEquals("matched", mock.forSet(new HashSet<String>()));
-        assertEquals(null, mock.forSet(null));
-
-        verify(mock, times(1)).forSet(anySetOf(String.class));
-    }
-
-    @Test
-    public void shouldAllowAnyIterable() {
-        when(mock.forIterable(anyIterableOf(String.class))).thenReturn("matched");
-
-        assertEquals("matched", mock.forIterable(new HashSet<String>()));
-        assertEquals(null, mock.forIterable(null));
-
-        verify(mock, times(1)).forIterable(anyIterableOf(String.class));
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java b/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
deleted file mode 100644
index 14e4c6a093..0000000000
--- a/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.mockito.Matchers.refEq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("all")
-public class ReflectionMatchersTest extends TestBase {
-
-    class Parent {
-        private int parentField;
-        protected String protectedParentField;
-        public Parent(int parentField, String protectedParentField) {
-            this.parentField = parentField;
-            this.protectedParentField = protectedParentField;
-        }
-    }
-
-    class Child extends Parent {
-        private int childFieldOne;
-        private Object childFieldTwo;
-        public Child(int parentField, String protectedParentField, int childFieldOne, Object childFieldTwo) {
-            super(parentField, protectedParentField);
-            this.childFieldOne = childFieldOne;
-            this.childFieldTwo = childFieldTwo;
-        }
-    }
-
-    interface MockMe {
-        void run(Child child);
-    }
-
-    MockMe mock;
-
-    @Before
-    public void setup() {
-        mock = mock(MockMe.class);
-
-        Child actual = new Child(1, "foo", 2, "bar");
-        mock.run(actual);
-    }
-
-    @Test
-    public void shouldMatchWhenFieldValuesEqual() throws Exception {
-        Child wanted = new Child(1, "foo", 2, "bar");
-        verify(mock).run(refEq(wanted));
-    }
-
-    @Test(expected=ArgumentsAreDifferent.class)
-    public void shouldNotMatchWhenFieldValuesDiffer() throws Exception {
-        Child wanted = new Child(1, "foo", 2, "bar XXX");
-        verify(mock).run(refEq(wanted));
-    }
-
-    @Test(expected=ArgumentsAreDifferent.class)
-    public void shouldNotMatchAgain() throws Exception {
-        Child wanted = new Child(1, "foo", 999, "bar");
-        verify(mock).run(refEq(wanted));
-    }
-
-    @Test(expected=ArgumentsAreDifferent.class)
-    public void shouldNotMatchYetAgain() throws Exception {
-        Child wanted = new Child(1, "XXXXX", 2, "bar");
-        verify(mock).run(refEq(wanted));
-    }
-
-    @Test(expected=ArgumentsAreDifferent.class)
-    public void shouldNotMatch() throws Exception {
-        Child wanted = new Child(234234, "foo", 2, "bar");
-        verify(mock).run(refEq(wanted));
-    }
-
-    @Test
-    public void shouldMatchWhenFieldValuesEqualWithOneFieldExcluded() throws Exception {
-        Child wanted = new Child(1, "foo", 2, "excluded");
-        verify(mock).run(refEq(wanted, "childFieldTwo"));
-    }
-
-    @Test
-    public void shouldMatchWhenFieldValuesEqualWithTwoFieldsExcluded() throws Exception {
-        Child wanted = new Child(234234, "foo", 2, "excluded");
-        verify(mock).run(refEq(wanted, "childFieldTwo", "parentField"));
-        verify(mock).run(refEq(wanted, "parentField", "childFieldTwo"));
-    }
-
-    @Test(expected=ArgumentsAreDifferent.class)
-    public void shouldNotMatchWithFieldsExclusion() throws Exception {
-        Child wanted = new Child(234234, "foo", 2, "excluded");
-        verify(mock).run(refEq(wanted, "childFieldTwo"));
-    }
-}
diff --git a/src/test/java/org/mockitousage/matchers/VarargsTest.java b/src/test/java/org/mockitousage/matchers/VarargsTest.java
deleted file mode 100644
index 0562d7aed3..0000000000
--- a/src/test/java/org/mockitousage/matchers/VarargsTest.java
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.matchers;
-
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNotNull;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import org.assertj.core.api.AbstractListAssert;
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.Condition;
-import org.assertj.core.api.ObjectAssert;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.ArgumentCaptor;
-import org.mockito.ArgumentMatchers;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockitousage.IMethods;
-
-public class VarargsTest {
-
-    @Rule
-    public MockitoRule mockitoRule = MockitoJUnit.rule();
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-    @Captor
-    private ArgumentCaptor<String> captor;
-    @Mock
-    private IMethods mock;
-
-    private static final Condition<Object> NULL = new Condition<Object>() {
-
-        @Override
-        public boolean matches(Object value) {
-            return value == null;
-        }
-    };
-
-    @Test
-    public void shouldMatchVarArgs_noArgs() {
-        mock.varargs();
-
-        verify(mock).varargs();
-    }
-
-    @Test
-    @Ignore("This test must succeed but is fails currently, see github issue #616")
-    public void shouldMatchEmptyVarArgs_noArgsIsNotNull() {
-        mock.varargs();
-
-        verify(mock).varargs(isNotNull());
-    }
-
-    @Test
-    @Ignore("This test must succeed but is fails currently, see github issue #616")
-    public void shouldMatchEmptyVarArgs_noArgsIsNull() {
-        mock.varargs();
-
-        verify(mock).varargs(isNull());
-    }
-
-    @Test
-    @Ignore("This test must succeed but is fails currently, see github issue #616")
-    public void shouldMatchEmptyVarArgs_noArgsIsNotNullArray() {
-        mock.varargs();
-
-        verify(mock).varargs((String[]) isNotNull());
-    }
-
-    @Test
-    public void shouldMatchVarArgs_oneNullArg_eqNull() {
-        Object arg = null;
-        mock.varargs(arg);
-
-        verify(mock).varargs(ArgumentMatchers.<Object[]>eq(null));
-    }
-
-    @Test
-    public void shouldMatchVarArgs_oneNullArg_isNull() {
-        Object arg = null;
-        mock.varargs(arg);
-
-        verify(mock).varargs(ArgumentMatchers.<Object[]>isNull());
-    }
-
-    @Test
-    public void shouldMatchVarArgs_nullArrayArg() {
-        Object[] argArray = null;
-        mock.varargs(argArray);
-
-        verify(mock).varargs(ArgumentMatchers.<Object[]>isNull());
-    }
-
-    @Test
-    public void shouldnotMatchVarArgs_twoArgsOneMatcher() {
-        mock.varargs("1", "1");
-
-        exception.expectMessage("Argument(s) are different");
-
-        verify(mock).varargs(eq("1"));
-    }
-
-    @Test
-    public void shouldMatchVarArgs_emptyVarArgsOneAnyMatcher() {
-        mock.varargs();
-
-        verify(mock).varargs((String[])any()); // any() -> VarargMatcher
-    }
-
-    @Test
-    public void shouldMatchVarArgs_oneArgsOneAnyMatcher() {
-        mock.varargs(1);
-
-        verify(mock).varargs(ArgumentMatchers.<Object[]>any()); // any() -> VarargMatcher
-    }
-
-    @Test
-    public void shouldMatchVarArgs_twoArgsOneAnyMatcher() {
-        mock.varargs(1, 2);
-
-        verify(mock).varargs(ArgumentMatchers.<Object[]>any()); // any() -> VarargMatcher
-    }
-
-    @Test
-    public void shouldMatchVarArgs_twoArgsTwoAnyMatcher() {
-        mock.varargs(1, 2);
-
-        verify(mock).varargs(any(), ArgumentMatchers.<Object>any()); // any() -> VarargMatcher
-    }
-
-    @Test
-    public void shouldMatchVarArgs_twoArgsThreeAnyMatcher() {
-        mock.varargs(1, 2);
-
-        exception.expectMessage("Argument(s) are different");
-
-        verify(mock).varargs(any(), any(), any()); //any() -> VarargMatcher
-    }
-
-    @Test
-    public void shouldMatchVarArgs_oneNullArgument() {
-        mock.varargs("1", null);
-
-        verify(mock).varargs(eq("1"), (String) isNull());
-    }
-
-    @Test
-    public void shouldMatchVarArgs_onebyte() {
-        mock.varargsbyte((byte) 1);
-
-        verify(mock).varargsbyte(eq((byte) 1));
-    }
-
-    @Test
-    public void shouldMatchVarArgs_nullByteArray() {
-        mock.varargsbyte(null);
-
-        verify(mock).varargsbyte((byte[]) isNull());
-    }
-
-    @Test
-    public void shouldMatchVarArgs_emptyByteArray() {
-        mock.varargsbyte();
-
-        verify(mock).varargsbyte();
-    }
-
-    @Test
-    @Ignore
-    public void shouldMatchEmptyVarArgs_emptyArrayIsNotNull() {
-        mock.varargsbyte();
-
-        verify(mock).varargsbyte((byte[]) isNotNull());
-    }
-
-    @Test
-    public void shouldMatchVarArgs_oneArgIsNotNull() {
-        mock.varargsbyte((byte) 1);
-
-        verify(mock).varargsbyte((byte[]) isNotNull());
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_noArgs() {
-        mock.varargs();
-
-        verify(mock).varargs(captor.capture());
-
-        assertThat(captor).isEmpty();
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_oneNullArg_eqNull() {
-        String arg = null;
-        mock.varargs(arg);
-
-        verify(mock).varargs(captor.capture());
-
-        assertThat(captor).areExactly(1, NULL);
-    }
-
-    /**
-     * Relates to Github issue #583 "ArgumentCaptor: NPE when an null array is
-     * passed to a varargs method"
-     */
-    @Test
-    public void shouldCaptureVarArgs_nullArrayArg() {
-        String[] argArray = null;
-        mock.varargs(argArray);
-
-        verify(mock).varargs(captor.capture());
-        assertThat(captor).areExactly(1, NULL);
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_twoArgsOneCapture() {
-        mock.varargs("1", "2");
-
-        verify(mock).varargs(captor.capture());
-
-        assertThat(captor).contains("1", "2");
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_twoArgsTwoCaptures() {
-        mock.varargs("1", "2");
-
-        verify(mock).varargs(captor.capture(), captor.capture());
-
-        assertThat(captor).contains("1", "2");
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_oneNullArgument() {
-        mock.varargs("1", null);
-
-        verify(mock).varargs(captor.capture());
-
-        assertThat(captor).contains("1", (String) null);
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_oneNullArgument2() {
-        mock.varargs("1", null);
-
-        verify(mock).varargs(captor.capture(), captor.capture());
-
-        assertThat(captor).contains("1", (String) null);
-    }
-
-    @Test
-    public void shouldNotCaptureVarArgs_3args2captures() {
-        mock.varargs("1", "2", "3");
-
-        exception.expect(ArgumentsAreDifferent.class);
-
-        verify(mock).varargs(captor.capture(), captor.capture());
-
-    }
-
-    @Test
-    public void shouldCaptureVarArgs_3argsCaptorMatcherMix() {
-        mock.varargs("1", "2", "3");
-
-        verify(mock).varargs(captor.capture(), eq("2"), captor.capture());
-
-        assertThat(captor).containsExactly("1", "3");
-
-    }
-
-    @Test
-    public void shouldNotCaptureVarArgs_3argsCaptorMatcherMix() {
-        mock.varargs("1", "2", "3");
-
-        try {
-            verify(mock).varargs(captor.capture(), eq("X"), captor.capture());
-            fail("The verification must fail, cause the second arg was not 'X' as expected!");
-        } catch (ArgumentsAreDifferent expected) {
-        }
-
-        assertThat(captor).isEmpty();
-
-    }
-
-    @Test
-    public void shouldNotCaptureVarArgs_1args2captures() {
-        mock.varargs("1");
-
-        exception.expect(ArgumentsAreDifferent.class);
-
-        verify(mock).varargs(captor.capture(), captor.capture());
-
-    }
-
-    /**
-     * As of v2.0.0-beta.118 this test fails. Once the github issues:
-     * <ul>
-     * <li>'#584 ArgumentCaptor can't capture varargs-arrays
-     * <li>#565 ArgumentCaptor should be type aware' are fixed this test must
-     * succeed
-     * </ul>
-     */
-    @Test
-    @Ignore("Blocked by github issue: #584 & #565")
-    public void shouldCaptureVarArgsAsArray() {
-        mock.varargs("1", "2");
-
-        ArgumentCaptor<String[]> varargCaptor = ArgumentCaptor.forClass(String[].class);
-
-        verify(mock).varargs(varargCaptor.capture());
-
-        assertThat(varargCaptor).containsExactly(new String[] { "1", "2" });
-    }
-
-    @Test
-    public void shouldNotMatchRegualrAndVaraArgs()   {
-        mock.varargsString(1, "a","b");
-
-        exception.expect(ArgumentsAreDifferent.class);
-
-        verify(mock).varargsString(1);
-    }
-    @Test
-    public void shouldNotMatchVaraArgs()   {
-        when(mock.varargsObject(1, "a","b")).thenReturn("OK");
-
-        Assertions.assertThat(mock.varargsObject(1)).isNull();
-    }
-
-    private static <T> AbstractListAssert<?, ?, T, ObjectAssert<T>> assertThat(ArgumentCaptor<T> captor) {
-        return Assertions.assertThat(captor.getAllValues());
-    }
-}
diff --git a/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java b/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
deleted file mode 100644
index 92dfc0057e..0000000000
--- a/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.misuse;
-
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.exceptions.misusing.NullInsteadOfMockException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class DescriptiveMessagesOnMisuseTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    class Foo {
-        public final String finalMethod() {
-            return null;
-        }
-    }
-
-    @SuppressWarnings("all")
-    @Test
-    public void tryDescriptiveMessagesOnMisuse() {
-        Foo foo = mock(Foo.class);
-
-//        when(foo.finalMethod()).thenReturn("foo");
-//        doReturn("foo").when(foo).finalMethod();
-//        verify(foo).finalMethod();
-
-//        doReturn("foo");
-//        doReturn("bar");
-
-//        verifyNoMoreInteractions();
-//        verifyNoMoreInteractions(null);
-//        verifyNoMoreInteractions("");
-//        verifyZeroInteractions();
-//        verifyZeroInteractions(null);
-//        verifyZeroInteractions("");
-//
-//        inOrder();
-//        inOrder(null);
-//        inOrder("test");
-//        InOrder inOrder = inOrder(mock(List.class));
-//        inOrder.verify(mock).simpleMethod();
-
-//        verify(null);
-//        verify(mock.booleanReturningMethod());
-
-//        verify(mock).varargs("test", anyString());
-
-//        when("x").thenReturn("x");
-
-//        when(mock.simpleMethod());
-//        when(mock.differentMethod()).thenReturn("");
-    }
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test(expected=NotAMockException.class)
-    public void shouldScreamWhenWholeMethodPassedToVerify() {
-        verify(mock.booleanReturningMethod());
-    }
-
-    @Test(expected=NotAMockException.class)
-    public void shouldScreamWhenWholeMethodPassedToVerifyNoMoreInteractions() {
-        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);
-    }
-
-    @Test(expected=NullInsteadOfMockException.class)
-    public void shouldScreamWhenNotMockPassedToVerifyNoMoreInteractions() {
-        verifyNoMoreInteractions(null, "blah");
-    }
-
-    @SuppressWarnings("all")
-    @Test(expected=MockitoException.class)
-    public void shouldScreamWhenNullPassedToVerifyNoMoreInteractions() {
-        verifyNoMoreInteractions((Object[])null);
-    }
-}
diff --git a/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java b/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
deleted file mode 100644
index 5e06bacccc..0000000000
--- a/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.misuse;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.anyBoolean;
-import static org.mockito.Mockito.anyInt;
-import static org.mockito.Mockito.anyObject;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.validateMockitoUsage;
-import static org.mockito.Mockito.verify;
-
-import java.util.Observer;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
-import org.mockito.exceptions.misusing.UnfinishedVerificationException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class DetectingMisusedMatchersTest extends TestBase {
-
-    class WithFinal {
-        final Object finalMethod(Object object) {
-            return null;
-        }
-    }
-
-    @Mock private WithFinal withFinal;
-
-    @After
-    public void resetState() {
-        super.resetState();
-    }
-
-    private void misplaced_anyObject_argument_matcher() {
-        anyObject();
-    }
-
-    private void misplaced_anyInt_argument_matcher() {
-        anyInt();
-    }
-
-    private void misplaced_anyBoolean_argument_matcher() {
-        anyBoolean();
-    }
-
-    @Test
-    public void should_fail_fast_when_argument_matchers_are_abused() {
-        misplaced_anyObject_argument_matcher();
-        try {
-            mock(IMethods.class);
-            fail();
-        } catch (InvalidUseOfMatchersException e) {
-            assertThat(e).hasMessageContaining("Misplaced or misused argument matcher");
-        }
-    }
-
-    @Test
-    public void should_report_argument_locations_when_argument_matchers_misused() {
-        try {
-            Observer observer = mock(Observer.class);
-
-            misplaced_anyInt_argument_matcher();
-            misplaced_anyObject_argument_matcher();
-            misplaced_anyBoolean_argument_matcher();
-
-            observer.update(null, null);
-
-            validateMockitoUsage();
-            fail();
-        } catch (InvalidUseOfMatchersException e) {
-            assertThat(e)
-                .hasMessageContaining("DetectingMisusedMatchersTest.misplaced_anyInt_argument_matcher")
-                .hasMessageContaining("DetectingMisusedMatchersTest.misplaced_anyObject_argument_matcher")
-                .hasMessageContaining("DetectingMisusedMatchersTest.misplaced_anyBoolean_argument_matcher");
-        }
-    }
-
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test
-    public void shouldSayUnfinishedVerificationButNotInvalidUseOfMatchers() {
-        assumeTrue("Does not apply for inline mocks", withFinal.getClass() != WithFinal.class);
-        verify(withFinal).finalMethod(anyObject());
-        try {
-            verify(withFinal);
-            fail();
-        } catch (UnfinishedVerificationException e) {}
-    }
-}
diff --git a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
deleted file mode 100644
index d14d928f9b..0000000000
--- a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.misuse;
-
-import static org.junit.Assume.assumeFalse;
-import static org.mockito.Mockito.*;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.misusing.MissingMethodInvocationException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class InvalidUsageTest extends TestBase {
-
-    @Mock private IMethods mock;
-    @Mock private IMethods mockTwo;
-
-    @After
-    public void resetState() {
-        super.resetState();
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldRequireArgumentsWhenVerifyingNoMoreInteractions() {
-        verifyNoMoreInteractions();
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldRequireArgumentsWhenVerifyingZeroInteractions() {
-        verifyZeroInteractions();
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldRequireArgumentsWhenVerifyingNoInteractions() {
-        verifyNoInteractions();
-    }
-
-    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
-    @Test(expected=MockitoException.class)
-    public void shouldNotCreateInOrderObjectWithoutMocks() {
-        inOrder();
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldNotAllowVerifyingInOrderUnfamilarMocks() {
-        InOrder inOrder = inOrder(mock);
-        inOrder.verify(mockTwo).simpleMethod();
-    }
-
-    @Test(expected=MissingMethodInvocationException.class)
-    public void shouldReportMissingMethodInvocationWhenStubbing() {
-        when(mock.simpleMethod()).thenReturn("this stubbing is required to make sure Stubbable is pulled");
-        when("".toString()).thenReturn("x");
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldNotAllowSettingInvalidCheckedException() throws Exception {
-        when(mock.simpleMethod()).thenThrow(new Exception());
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldNotAllowSettingNullThrowable() throws Exception {
-        when(mock.simpleMethod()).thenThrow(new Throwable[] {null});
-    }
-
-    @SuppressWarnings("all")
-    @Test(expected=MockitoException.class)
-    public void shouldNotAllowSettingNullThrowableVararg() throws Exception {
-        when(mock.simpleMethod()).thenThrow((Throwable) null);
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldNotAllowSettingNullConsecutiveThrowable() throws Exception {
-        when(mock.simpleMethod()).thenThrow(new RuntimeException(), null);
-    }
-
-    final class FinalClass {}
-
-    @Test(expected=MockitoException.class)
-    public void shouldNotAllowMockingFinalClassesIfDisabled() throws Exception {
-        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);
-    }
-
-    interface ObjectLikeInterface {
-        boolean equals(Object o);
-        String toString();
-        int hashCode();
-    }
-
-    @Test
-    public void shouldNotMockObjectMethodsOnInterface() throws Exception {
-        ObjectLikeInterface inter = mock(ObjectLikeInterface.class);
-
-        inter.equals(null);
-        inter.toString();
-        inter.hashCode();
-
-        verifyZeroInteractions(inter);
-    }
-
-    @Test
-    public void shouldNotMockObjectMethodsOnInterfaceVerifyNoInteractions() throws Exception {
-        ObjectLikeInterface inter = mock(ObjectLikeInterface.class);
-
-        inter.equals(null);
-        inter.toString();
-        inter.hashCode();
-
-        verifyNoInteractions(inter);
-    }
-
-    @Test
-    public void shouldNotMockObjectMethodsOnClass() throws Exception {
-        Object clazz = mock(ObjectLikeInterface.class);
-
-        clazz.equals(null);
-        clazz.toString();
-        clazz.hashCode();
-
-        verifyZeroInteractions(clazz);
-    }
-
-    @Test
-    public void shouldNotMockObjectMethodsOnClassVerifyNoInteractions() throws Exception {
-        Object clazz = mock(ObjectLikeInterface.class);
-
-        clazz.equals(null);
-        clazz.toString();
-        clazz.hashCode();
-
-        verifyNoInteractions(clazz);
-    }
-}
diff --git a/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java b/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java
deleted file mode 100644
index 361b9c0c8c..0000000000
--- a/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.misuse;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
-
-public class SpyStubbingMisuseTest {
-
-    @Test
-    public void nestedWhenTest() {
-        Strategy mfoo = mock(Strategy.class);
-        Sampler mpoo = mock(Sampler.class);
-        Producer out = spy(new Producer(mfoo));
-
-        try {
-            when(out.produce()).thenReturn(mpoo);
-            fail();
-        } catch (WrongTypeOfReturnValue e) {
-            assertThat(e.getMessage()).contains("spy").contains("syntax").contains("doReturn|Throw");
-        }
-    }
-
-    public class Sample { }
-
-    public class Strategy {
-        Sample getSample() {
-            return new Sample();
-        }
-    }
-
-    public class Sampler {
-        Sample sample;
-        Sampler(Strategy f) {
-            sample = f.getSample();
-        }
-    }
-
-    public class Producer {
-        Strategy strategy;
-        Producer(Strategy f) {
-            strategy = f;
-        }
-        Sampler produce() {
-            return new Sampler(strategy);
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java b/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
deleted file mode 100644
index 7f2bf5048e..0000000000
--- a/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.plugins;
-
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.withSettings;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.internal.creation.instance.Instantiator;
-import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.InstantiatorProvider;
-import org.mockito.plugins.InstantiatorProvider2;
-import org.mockito.plugins.MockMaker;
-import org.mockito.plugins.MockitoLogger;
-import org.mockito.plugins.MockitoPlugins;
-import org.mockito.plugins.PluginSwitch;
-import org.mockito.plugins.StackTraceCleanerProvider;
-import org.mockitoutil.TestBase;
-
-public class MockitoPluginsTest extends TestBase {
-
-    private final MockitoPlugins plugins = Mockito.framework().getPlugins();
-
-    @Test
-    public void provides_built_in_plugins() {
-        assertNotNull(plugins.getInlineMockMaker());
-        assertNotNull(plugins.getDefaultPlugin(MockMaker.class));
-        assertNotNull(plugins.getDefaultPlugin(StackTraceCleanerProvider.class));
-        assertNotNull(plugins.getDefaultPlugin(PluginSwitch.class));
-        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider.class));
-        assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
-        assertNotNull(plugins.getDefaultPlugin(AnnotationEngine.class));
-        assertNotNull(plugins.getDefaultPlugin(MockitoLogger.class));
-    }
-
-    @SuppressWarnings("deprecation")
-    @Test
-    public void instantiator_provider_backwards_compatibility() {
-        InstantiatorProvider provider = plugins.getDefaultPlugin(InstantiatorProvider.class);
-        Instantiator instantiator = provider.getInstantiator(withSettings().build(MockitoPluginsTest.class));
-
-        assertNotNull(instantiator.newInstance(MockitoPluginsTest.class));
-    }
-}
diff --git a/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java b/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
deleted file mode 100644
index 101598c787..0000000000
--- a/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.serialization;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.io.ByteArrayInputStream;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Callable;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.mock.SerializableMode;
-import org.mockitousage.IMethods;
-import org.mockitoutil.SimplePerRealmReloadingClassLoader;
-import org.mockitoutil.SimpleSerializationUtil;
-
-public class AcrossClassLoaderSerializationTest {
-
-    public IMethods mock;
-
-    @Before
-    public void reproduce_CCE_by_creating_a_mock_with_IMethods_before() throws Exception {
-        mock = Mockito.mock(IMethods.class);
-    }
-
-    @Test
-    public void check_that_mock_can_be_serialized_in_a_classloader_and_deserialized_in_another() throws Exception {
-        byte[] bytes = create_mock_and_serialize_it_in_class_loader_A();
-
-        Object the_deserialized_mock = read_stream_and_deserialize_it_in_class_loader_B(bytes);
-        assertThat(the_deserialized_mock.getClass().getName()).startsWith("org.mockito.codegen.AClassToBeMockedInThisTestOnlyAndInCallablesOnly");
-    }
-
-    private Object read_stream_and_deserialize_it_in_class_loader_B(byte[] bytes) throws Exception {
-        return new SimplePerRealmReloadingClassLoader(this.getClass().getClassLoader(), isolating_test_classes())
-                .doInRealm(
-                        "org.mockitousage.serialization.AcrossClassLoaderSerializationTest$ReadStreamAndDeserializeIt",
-                        new Class<?>[]{ byte[].class },
-                        new Object[]{ bytes }
-                );
-    }
-
-    private byte[] create_mock_and_serialize_it_in_class_loader_A() throws Exception {
-        return (byte[]) new SimplePerRealmReloadingClassLoader(this.getClass().getClassLoader(), isolating_test_classes())
-                .doInRealm("org.mockitousage.serialization.AcrossClassLoaderSerializationTest$CreateMockAndSerializeIt");
-    }
-
-
-    private SimplePerRealmReloadingClassLoader.ReloadClassPredicate isolating_test_classes() {
-        return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
-            public boolean acceptReloadOf(String qualifiedName) {
-                return qualifiedName.contains("org.mockitousage")
-                        || qualifiedName.contains("org.mockitoutil")
-                        ;
-            }
-        };
-    }
-
-
-    // see create_mock_and_serialize_it_in_class_loader_A
-    public static class CreateMockAndSerializeIt implements Callable<byte[]> {
-        public byte[] call() throws Exception {
-            AClassToBeMockedInThisTestOnlyAndInCallablesOnly mock = Mockito.mock(
-                    AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class,
-                    Mockito.withSettings().serializable(SerializableMode.ACROSS_CLASSLOADERS)
-            );
-            // use MethodProxy before
-            mock.returningSomething();
-
-            return SimpleSerializationUtil.serializeMock(mock).toByteArray();
-        }
-    }
-
-    // see read_stream_and_deserialize_it_in_class_loader_B
-    public static class ReadStreamAndDeserializeIt implements Callable<Object> {
-        private byte[] bytes;
-
-        public ReadStreamAndDeserializeIt(byte[] bytes) {
-            this.bytes = bytes;
-        }
-
-        public Object call() throws Exception {
-            ByteArrayInputStream to_unserialize = new ByteArrayInputStream(bytes);
-            return SimpleSerializationUtil.deserializeMock(
-                    to_unserialize,
-                    AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class
-            );
-        }
-    }
-
-
-    public static class AClassToBeMockedInThisTestOnlyAndInCallablesOnly {
-        List returningSomething() { return Collections.emptyList(); }
-    }
-}
diff --git a/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java b/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
deleted file mode 100644
index b75847db33..0000000000
--- a/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.serialization;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
-
-import java.io.Serializable;
-import java.util.Iterator;
-import java.util.List;
-
-import org.junit.Test;
-
-public class DeepStubsSerializableTest {
-
-    @Test
-    public void should_serialize_and_deserialize_mock_created_with_deep_stubs() throws Exception {
-        // given
-        SampleClass sampleClass = mock(SampleClass.class, withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
-        when(sampleClass.getSample().isFalse()).thenReturn(true);
-        when(sampleClass.getSample().number()).thenReturn(999);
-
-        // when
-        SampleClass deserializedSample = serializeAndBack(sampleClass);
-
-        // then
-        assertThat(deserializedSample.getSample().isFalse()).isEqualTo(true);
-        assertThat(deserializedSample.getSample().number()).isEqualTo(999);
-    }
-
-    @Test
-    public void should_serialize_and_deserialize_parameterized_class_mocked_with_deep_stubs() throws Exception {
-        // given
-        ListContainer deep_stubbed = mock(ListContainer.class, withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
-        when(deep_stubbed.iterator().next().add("yes")).thenReturn(true);
-
-        // when
-        ListContainer deserialized_deep_stub = serializeAndBack(deep_stubbed);
-
-        // then
-        assertThat(deserialized_deep_stub.iterator().next().add("not stubbed but mock already previously resolved")).isEqualTo(false);
-        assertThat(deserialized_deep_stub.iterator().next().add("yes")).isEqualTo(true);
-    }
-
-    @Test
-    public void should_discard_generics_metadata_when_serialized_then_disabling_deep_stubs_with_generics() throws Exception {
-        // given
-        ListContainer deep_stubbed = mock(ListContainer.class, withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
-        when(deep_stubbed.iterator().hasNext()).thenReturn(true);
-
-        ListContainer deserialized_deep_stub = serializeAndBack(deep_stubbed);
-
-        try {
-            // when stubbing on a deserialized mock
-            // then revert to the default RETURNS_DEEP_STUBS and the code will raise a ClassCastException
-            when(deserialized_deep_stub.iterator().next().get(42)).thenReturn("no");
-            fail("Expected an exception to be thrown as deep stubs and serialization does not play well together");
-        } catch (NullPointerException e) {
-            assertThat(e).hasMessage(null);
-        }
-    }
-
-    static class SampleClass implements Serializable {
-
-        SampleClass2 getSample() {
-            return new SampleClass2();
-        }
-    }
-
-    static class SampleClass2 implements Serializable {
-
-        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 Iterator<E> iterator() {
-            return new Iterator<E>() {
-                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);
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java b/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
deleted file mode 100644
index d448ecd7b6..0000000000
--- a/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.serialization;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.withSettings;
-
-import java.nio.charset.CharacterCodingException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.*;
-
-import org.junit.Test;
-import org.mockitousage.IMethods;
-import org.mockitoutil.SimpleSerializationUtil;
-
-public class ParallelSerializationTest {
-
-    @Test
-    public void single_mock_being_serialized_in_different_classloaders_by_multiple_threads() throws ExecutionException, InterruptedException {
-        // given
-        int iterations = 2;
-        int threadingFactor = 200;
-        final ExecutorService executorService = Executors.newFixedThreadPool(threadingFactor);
-        final IMethods iMethods_that_store_invocations = mock(IMethods.class, withSettings().serializable());
-
-        // when
-        for (int i = 0; i <= iterations; i++) {
-            List<Future<?>> futures = new ArrayList<Future<?>>(threadingFactor);
-            final CyclicBarrier barrier_that_will_wait_until_threads_are_ready = new CyclicBarrier(threadingFactor);
-
-            // prepare all threads by submitting a callable
-            //  - that will serialize the mock a 'threadingFactor' times
-            //  - that will use the mock a 'threadingFactor' times
-            for (int j = 0; j < threadingFactor; j++) {
-                // submit a callable that will serialize the mock 'iMethods'
-                futures.add(executorService.submit(new Callable<Object>() {
-                    public Object call() throws Exception {
-                        barrier_that_will_wait_until_threads_are_ready.await();
-
-                        randomCallOn(iMethods_that_store_invocations);
-
-                        return SimpleSerializationUtil.serializeMock(iMethods_that_store_invocations).toByteArray();
-                    }
-                }));
-
-                // submit a callable that will only use the mock 'iMethods'
-                executorService.submit(new Callable<Object>() {
-                    public Object call() throws Exception {
-                        barrier_that_will_wait_until_threads_are_ready.await();
-                        return iMethods_that_store_invocations.longObjectReturningMethod();
-                    }
-                });
-            }
-
-            // ensure we are getting the futures
-            for (Future<?> future : futures) {
-                future.get();
-            }
-        }
-    }
-
-    private void randomCallOn(IMethods iMethods) throws CharacterCodingException {
-        int random = new Random().nextInt(10);
-        switch (random) {
-            case 0 : iMethods.arrayReturningMethod(); break;
-            case 1 : iMethods.longObjectReturningMethod(); break;
-            case 2 : iMethods.linkedListReturningMethod(); break;
-            case 3 : iMethods.iMethodsReturningMethod(); break;
-            case 4 : iMethods.canThrowException(); break;
-            case 5 : iMethods.differentMethod(); break;
-            case 6 : iMethods.voidMethod(); break;
-            case 7 : iMethods.varargsString(1, ""); break;
-            case 8 : iMethods.forMap(null); break;
-            case 9 : iMethods.throwsNothing(false); break;
-            default:
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/session/MockitoSessionTest.java b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
deleted file mode 100644
index 8edf96ebde..0000000000
--- a/src/test/java/org/mockitousage/session/MockitoSessionTest.java
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.session;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoSession;
-import org.mockito.exceptions.misusing.InjectMocksException;
-import org.mockito.exceptions.misusing.UnfinishedStubbingException;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-import org.mockitoutil.TestBase;
-
-public class MockitoSessionTest extends TestBase {
-
-    private JUnitCore junit = new JUnitCore();
-
-    @Test public void session_without_any_configuration() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithoutAnyConfiguration.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).succeeds(1);
-    }
-
-    @Test public void session_without_init_mocks_configured() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithoutInitMocksConfigured.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).succeeds(1);
-    }
-
-    @Test public void session_without_strictness_configured() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithoutStrictnessConfigured.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).succeeds(1);
-    }
-
-    @Test public void session_with_incorrect_mockito_usage() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithIncorrectMockitoUsage.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).fails(1, UnfinishedStubbingException.class);
-    }
-
-    @Test public void reports_other_failure_and_incorrect_mockito_usage() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithTestFailureAndIncorrectMockitoUsage.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result)
-                .failsExactly(AssertionError.class, UnfinishedStubbingException.class);
-    }
-
-    @Test public void allows_initializing_mocks_manually() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithManuallyInitializedMock.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).succeeds(1);
-    }
-
-    @Test public void allows_updating_strictness() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithUpdatedStrictness.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).succeeds(1);
-    }
-
-    @Test public void allows_overriding_failure() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithOverriddenFailure.class);
-
-        //expect
-        JUnitResultAssert.assertThat(result).isSuccessful();
-
-        //in order to demonstrate feature, we intentionally misuse Mockito and need to clean up state
-        resetState();
-    }
-
-    @Test public void cleans_up_state_when_init_fails() {
-        //when
-        Result result = junit.run(MockitoSessionTest.SessionWithInitMocksFailure.class);
-
-        //expect that both failures are the same, indicating correct listener cleanup
-        //incorrect cleanup causes 1 failure to be InjectMocksException
-        //  but the next test method would have failed with unuseful error that session was not cleaned up
-        JUnitResultAssert.assertThat(result)
-            .fails(2, InjectMocksException.class);
-    }
-
-    public static class SessionWithoutAnyConfiguration {
-
-        @Mock IMethods mock;
-
-        //session without initMocks is not currently supported
-        MockitoSession mockito = Mockito.mockitoSession().startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void some_test() {
-            assertNull(mock); //initMocks() was not used when configuring session
-        }
-    }
-
-    public static class SessionWithoutInitMocksConfigured {
-
-        @Mock IMethods mock;
-
-        MockitoSession mockito = Mockito.mockitoSession().strictness(Strictness.LENIENT).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void some_test() {
-            assertNull(mock); //initMocks() was not used when configuring session
-        }
-    }
-
-    public static class SessionWithoutStrictnessConfigured {
-        @Mock IMethods mock;
-
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void some_test() {
-            assertNotNull(mock);
-        }
-    }
-
-    public static class SessionWithIncorrectMockitoUsage {
-        @Mock IMethods mock;
-
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-        @Test public void unfinished_stubbing() {
-            when(mock.simpleMethod());
-        }
-    }
-
-    public static class SessionWithTestFailureAndIncorrectMockitoUsage {
-        @Mock IMethods mock;
-
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-        @Test public void unfinished_stubbing_with_other_failure() {
-            when(mock.simpleMethod());
-            assertTrue(false);
-        }
-    }
-
-    public static class SessionWithManuallyInitializedMock {
-        @Mock IMethods mock;
-        IMethods mock2 = Mockito.mock(IMethods.class, "manual mock");
-
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void manual_mock_preserves_its_settings() {
-            assertEquals("mock", mockingDetails(mock).getMockCreationSettings().getMockName().toString());
-            assertEquals("manual mock", mockingDetails(mock2).getMockCreationSettings().getMockName().toString());
-        }
-    }
-
-    public static class SessionWithUpdatedStrictness {
-        @Mock IMethods mock;
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void manual_mock_preserves_its_settings() {
-            when(mock.simpleMethod(1)).thenReturn("foo");
-
-            //when
-            mockito.setStrictness(Strictness.LENIENT);
-
-            //then no exception is thrown, even though the arg is different
-            mock.simpleMethod(2);
-        }
-    }
-
-    public static class SessionWithOverriddenFailure {
-        @Mock IMethods mock;
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking(new RuntimeException("Boo!"));
-        }
-
-        @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-        @Test public void invalid_mockito_usage() {
-            verify(mock);
-        }
-    }
-
-    public static class SessionWithInitMocksFailure {
-        @InjectMocks private ConstructorFail sut;
-        MockitoSession mockito;
-
-        @Before
-        public void before() {
-            mockito = Mockito.mockitoSession().initMocks(this).startMocking();
-        }
-
-        @After public void after() {
-            if (mockito != null) {
-                //so that we reduce amount of exceptions for easier assertions
-                //otherwise we would get an NPE here
-                mockito.finishMocking();
-            }
-        }
-
-        @Test public void test1() {
-            //should fail the same way
-        }
-
-        @Test public void test2() {
-            //should fail the same way
-        }
-
-        static class ConstructorFail {
-            ConstructorFail() {
-                throw new RuntimeException("Boo!");
-            }
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java b/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
deleted file mode 100644
index 4bf343f179..0000000000
--- a/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.spies;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.Conditions.methodsInStackTrace;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class PartialMockingWithSpiesTest extends TestBase {
-
-    @Before
-    public void pleaseMakeStackTracesClean() {
-        makeStackTracesClean();
-    }
-
-    class InheritMe {
-        private String inherited = "100$";
-        protected String getInherited() {
-            return inherited;
-        }
-    }
-
-    class Person extends InheritMe {
-        private final Name defaultName = new Name("Default name");
-
-        public String getName() {
-            return guessName().name;
-        }
-
-        Name guessName() {
-            return defaultName;
-        }
-
-        public String howMuchDidYouInherit() {
-            return getInherited();
-        }
-
-        public String getNameButDelegateToMethodThatThrows() {
-            throwSomeException();
-            return guessName().name;
-        }
-
-        private void throwSomeException() {
-            throw new RuntimeException("boo");
-        }
-    }
-
-    class Name {
-        private final String name;
-
-        public Name(String name) {
-            this.name = name;
-        }
-    }
-
-    Person spy = spy(new Person());
-
-    @Test
-    public void shouldCallRealMethdsEvenDelegatedToOtherSelfMethod() {
-        // when
-        String name = spy.getName();
-
-        // then
-        assertEquals("Default name", name);
-    }
-
-    @Test
-    public void shouldAllowStubbingOfMethodsThatDelegateToOtherMethods() {
-        // when
-        when(spy.getName()).thenReturn("foo");
-
-        // then
-        assertEquals("foo", spy.getName());
-    }
-
-    @Test
-    public void shouldAllowStubbingWithThrowablesMethodsThatDelegateToOtherMethods() {
-        // when
-        doThrow(new RuntimeException("appetite for destruction"))
-            .when(spy).getNameButDelegateToMethodThatThrows();
-
-        // then
-        try {
-            spy.getNameButDelegateToMethodThatThrows();
-            fail();
-        } catch(Exception e) {
-            assertEquals("appetite for destruction", e.getMessage());
-        }
-    }
-
-    @Test
-    public void shouldStackTraceGetFilteredOnUserExceptions() {
-        try {
-            // when
-            spy.getNameButDelegateToMethodThatThrows();
-            fail();
-        } catch (Throwable t) {
-            // then
-            Assertions.assertThat(t).has(methodsInStackTrace(
-                    "throwSomeException",
-                    "getNameButDelegateToMethodThatThrows",
-                    "shouldStackTraceGetFilteredOnUserExceptions"
-                    ));
-        }
-    }
-
-//    @Test //manual verification
-    public void verifyTheStackTrace() {
-        spy.getNameButDelegateToMethodThatThrows();
-    }
-
-    @Test
-    public void shouldVerify() {
-        // when
-        spy.getName();
-
-        // then
-        verify(spy).guessName();
-    }
-
-    @Test
-    public void shouldStub() {
-        // given
-        when(spy.guessName()).thenReturn(new Name("John"));
-        // when
-        String name = spy.getName();
-        // then
-        assertEquals("John", name);
-    }
-
-    @Test
-    public void shouldDealWithPrivateFieldsOfSubclasses() {
-        assertEquals("100$", spy.howMuchDidYouInherit());
-    }
-}
diff --git a/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java b/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
deleted file mode 100644
index 503c246953..0000000000
--- a/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.spies;
-
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.List;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.ClassFileVersion;
-import net.bytebuddy.description.modifier.Visibility;
-import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
-import net.bytebuddy.implementation.FixedValue;
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings({"unchecked"})
-public class SpyingOnInterfacesTest extends TestBase {
-
-    @Test
-    public void shouldFailFastWhenCallingRealMethodOnInterface() throws Exception {
-        List<?> list = mock(List.class);
-        try {
-            //when
-            when(list.get(0)).thenCallRealMethod();
-            //then
-            fail();
-        } catch (MockitoException e) {
-        }
-    }
-
-    @Test
-    public void shouldFailInRuntimeWhenCallingRealMethodOnInterface() throws Exception {
-        //given
-        List<Object> list = mock(List.class);
-        when(list.get(0)).thenAnswer(
-                new Answer<Object>() {
-                    public Object answer(InvocationOnMock invocation) throws Throwable {
-                        return invocation.callRealMethod();
-                    }
-                }
-        );
-        try {
-            //when
-            list.get(0);
-            //then
-            fail();
-        } catch (MockitoException e) {
-        }
-    }
-
-    @Test
-    public void shouldAllowDelegatingToDefaultMethod() throws Exception {
-        assumeTrue("Test can only be executed on Java 8 capable VMs", ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V8));
-
-        Class<?> type = new ByteBuddy()
-                .makeInterface()
-                .defineMethod("foo", String.class, Visibility.PUBLIC)
-                .intercept(FixedValue.value("bar"))
-                .make()
-                .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
-                .getLoaded();
-
-        Object object = mock(type);
-
-        //when
-        when(type.getMethod("foo").invoke(object)).thenCallRealMethod();
-        //then
-        Assertions.assertThat(type.getMethod("foo").invoke(object)).isEqualTo((Object) "bar");
-        type.getMethod("foo").invoke(verify(object));
-    }
-
-    @Test
-    public void shouldAllowSpyingOnDefaultMethod() throws Exception {
-        assumeTrue("Test can only be executed on Java 8 capable VMs", ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V8));
-
-        Class<?> iFace = new ByteBuddy()
-                .makeInterface()
-                .defineMethod("foo", String.class, Visibility.PUBLIC)
-                .intercept(FixedValue.value("bar"))
-                .make()
-                .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
-                .getLoaded();
-
-        Class<?> impl = new ByteBuddy()
-                .subclass(iFace)
-                .make()
-                .load(iFace.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
-                .getLoaded();
-
-        Object object = spy(impl.newInstance());
-
-        //when
-        Assertions.assertThat(impl.getMethod("foo").invoke(object)).isEqualTo((Object) "bar");
-        //then
-        impl.getMethod("foo").invoke(verify(object));
-    }
-}
diff --git a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
deleted file mode 100644
index 9b7df28705..0000000000
--- a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stacktrace;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.Conditions.firstMethodInStackTrace;
-
-import org.assertj.core.api.Assertions;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class StackTraceFilteringTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    @After
-    public void resetState() {
-        super.resetState();
-    }
-
-    @Before
-    public void setup() {
-        makeStackTracesClean();
-    }
-
-    @Test
-    public void shouldFilterStackTraceOnVerify() {
-        try {
-            verify(mock).simpleMethod();
-            fail();
-        } catch (WantedButNotInvoked e) {
-            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerify"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStackTraceOnVerifyNoMoreInteractions() {
-        mock.oneArg(true);
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoMoreInteractions"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStackTraceOnVerifyZeroInteractions() {
-        mock.oneArg(true);
-        try {
-            verifyZeroInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyZeroInteractions"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStackTraceOnVerifyNoInteractions() {
-        mock.oneArg(true);
-        try {
-            verifyNoInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoInteractions"));
-        }
-    }
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test
-    public void shouldFilterStacktraceOnMockitoException() {
-        verify(mock);
-        try {
-            verify(mock).oneArg(true);
-            fail();
-        } catch (MockitoException expected) {
-            Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceOnMockitoException"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStacktraceWhenVerifyingInOrder() {
-        InOrder inOrder = inOrder(mock);
-        mock.oneArg(true);
-        mock.oneArg(false);
-
-        inOrder.verify(mock).oneArg(false);
-        try {
-            inOrder.verify(mock).oneArg(true);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStacktraceWhenInOrderThrowsMockitoException() {
-        try {
-            inOrder();
-            fail();
-        } catch (MockitoException expected) {
-            Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderThrowsMockitoException"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStacktraceWhenInOrderVerifies() {
-        try {
-            InOrder inOrder = inOrder(mock);
-            inOrder.verify(null);
-            fail();
-        } catch (MockitoException expected) {
-            Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies"));
-        }
-    }
-
-    @Test
-    public void shouldFilterStackTraceWhenThrowingExceptionFromMockHandler() {
-        try {
-            when(mock.oneArg(true)).thenThrow(new Exception());
-            fail();
-        } catch (MockitoException expected) {
-            Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStackTraceWhenThrowingExceptionFromMockHandler"));
-        }
-    }
-
-    @Test
-    public void shouldShowProperExceptionStackTrace() throws Exception {
-        when(mock.simpleMethod()).thenThrow(new RuntimeException());
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (RuntimeException e) {
-            Assertions.assertThat(e).has(firstMethodInStackTrace("shouldShowProperExceptionStackTrace"));
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java b/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java
deleted file mode 100644
index e98c26d925..0000000000
--- a/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-import static org.mockito.Mockito.when;
-
-import org.assertj.core.api.Assertions;
-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;
-
-public class LenientMockAnnotationTest {
-
-    public @Rule MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
-    @Mock(lenient = true) IMethods lenientMock;
-    @Mock IMethods regularMock;
-
-    @Test
-    public void mock_is_lenient() {
-        when(lenientMock.simpleMethod("1")).thenReturn("1");
-        when(regularMock.simpleMethod("2")).thenReturn("2");
-
-        //then lenient mock does not throw:
-        ProductionCode.simpleMethod(lenientMock, "3");
-
-        //but regular mock throws:
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                ProductionCode.simpleMethod(regularMock,"4");
-            }
-        }).isInstanceOf(PotentialStubbingProblem.class);
-    }
-}
diff --git a/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java b/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java
deleted file mode 100644
index 635b59deca..0000000000
--- a/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-import static org.mockito.Mockito.when;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Before;
-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;
-
-public class PotentialStubbingSensitivityTest {
-
-    @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
-    @Mock IMethods mock;
-
-    @Before
-    public void setup() {
-        when(mock.simpleMethod("1")).thenReturn("1");
-    }
-
-    @Test
-    public void allows_stubbing_with_different_arg_in_test_code() {
-        //although we are calling 'simpleMethod' with different argument
-        //Mockito understands that this is stubbing in the test code and does not trigger PotentialStubbingProblem
-        when(mock.simpleMethod("2")).thenReturn("2");
-
-        //methods in anonymous inner classes are ok, too
-        new Runnable() {
-            public void run() {
-                when(mock.simpleMethod("3")).thenReturn("3");
-            }
-        }.run();
-
-        //avoiding unnecessary stubbing failures:
-        mock.simpleMethod("1");
-        mock.simpleMethod("2");
-        mock.simpleMethod("3");
-    }
-
-    @Test
-    public void reports_potential_stubbing_problem_in_production_code() {
-        //when
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() throws Throwable {
-                ProductionCode.simpleMethod(mock, "2");
-            }
-        }).isInstanceOf(PotentialStubbingProblem.class);
-    }
-}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
deleted file mode 100644
index 010fa89a0b..0000000000
--- a/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-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;
-
-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;
-
-//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() {
-            public void call() throws Throwable {
-                ProductionCode.simpleMethod(strictStubsMock, 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
deleted file mode 100644
index 4a70467f8b..0000000000
--- a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-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;
-
-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;
-
-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 {
-                ProductionCode.simpleMethod(mock, "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
deleted file mode 100644
index aea447e679..0000000000
--- a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
-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;
-
-@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() {
-            public void call() {
-                ProductionCode.simpleMethod(mock, "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
deleted file mode 100644
index afacfaa246..0000000000
--- a/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-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;
-
-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;
-
-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() {
-            public void call() {
-                ProductionCode.simpleMethod(mock, 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() {
-            public void call() {
-                ProductionCode.simpleMethod(mock, 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
deleted file mode 100644
index 9af022008e..0000000000
--- a/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.strictness;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
-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;
-
-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() {
-            public void call() {
-                ProductionCode.simpleMethod(mock, "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/MisusingStubbingTest.java b/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java
deleted file mode 100644
index c799d618d4..0000000000
--- a/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.validateMockitoUsage;
-
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-public class MisusingStubbingTest extends TestBase {
-
-    @Test
-    public void clean_state_after_not_a_mock() {
-        //when
-        assertThatThrownBy(() ->
-            doReturn(100).when("not a mock"));
-
-        //then
-        validateMockitoUsage();
-    }
-
-    @Test
-    public void clean_state_after_null_passed() {
-        //when
-        assertThatThrownBy(() ->
-            doReturn(100).when(null));
-
-        //then
-        validateMockitoUsage();
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java b/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java
deleted file mode 100644
index 277c6a19c5..0000000000
--- a/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.withSettings;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.Answers;
-
-//Reproduces issue #1551
-public class SmartNullsGenericBugTest {
-
-    @Test
-    public void smart_nulls_generic_bug_generic_T() {
-        ConcreteDao concreteDao = mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
-
-        final Entity result = concreteDao.findById();
-
-        Assertions.assertThat(result)
-            .as("#1551")
-            .isNotNull();
-    }
-
-    @Test
-    public void smart_nulls_generic_bug_generic_M() {
-        ConcreteDao concreteDao = mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
-
-        final String other = concreteDao.find();
-
-        Assertions.assertThat(other)
-            .as("#1551 - CCannot resolve type")
-            .isNull();
-    }
-
-    @Test
-    public void smart_nulls_generic_bug_generic_M_provided_in_args() {
-        ConcreteDao concreteDao = mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
-
-        final String other = concreteDao.findArgs(1, "plop");
-
-        Assertions.assertThat(other)
-            .as("#1551")
-            .isEqualTo("");
-    }
-
-    @Test
-    public void smart_nulls_generic_bug_generic_M_provided_as_varargs() {
-        ConcreteDao concreteDao = mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
-
-        final String other = concreteDao.findVarargs(42, "plip", "plop");
-
-        Assertions.assertThat(other)
-            .as("#1551")
-            .isEqualTo("");
-    }
-
-    static class AbstractDao<T> {
-        T findById() {
-            return null;
-        }
-        <M> M find() { return null; }
-        <M> M findArgs(int idx, M arg) { return null; }
-        <M> M findVarargs(int idx, M... args) { return null; }
-    }
-
-    static class Entity { }
-    static class ConcreteDao extends AbstractDao<Entity> { }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java b/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
deleted file mode 100644
index 2abbb4f90a..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockitoutil.ConcurrentTesting.concurrently;
-import static org.mockitoutil.JUnitResultAssert.assertThat;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoSession;
-import org.mockito.StateMaster;
-import org.mockito.exceptions.misusing.PotentialStubbingProblem;
-import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
-import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-import org.mockitousage.strictness.ProductionCode;
-
-public class StrictStubbingEndToEndTest {
-
-    JUnitCore junit = new JUnitCore();
-
-    @After public void after() {
-        new StateMaster().clearMockitoListeners();
-    }
-
-    @Test public void finish_mocking_exception_does_not_hide_the_exception_from_test() {
-        Result result = junit.run(UnnecessaryStubbing.class);
-        assertThat(result)
-                //both exceptions are reported to JUnit:
-                .fails("unnecessary_stubbing", IllegalStateException.class)
-                .fails("unnecessary_stubbing", UnnecessaryStubbingException.class);
-    }
-
-    @Test public void does_not_report_unused_stubbing_if_mismatch_reported() {
-        Result result = junit.run(ReportMismatchButNotUnusedStubbing.class);
-        assertThat(result).fails(1, PotentialStubbingProblem.class);
-    }
-
-    @Test public void strict_stubbing_does_not_leak_to_other_tests() {
-        Result result = junit.run(LenientStrictness1.class, StrictStubsPassing.class, LenientStrictness2.class);
-        //all tests pass, lenient test cases contain incorrect stubbing
-        assertThat(result).succeeds(5);
-    }
-
-    @Test public void detects_unfinished_session() {
-        Result result = junit.run(UnfinishedMocking.class);
-        assertThat(result)
-            .fails(UnfinishedMockingSessionException.class, "\n" +
-                "Unfinished mocking session detected.\n" +
-                "Previous MockitoSession was not concluded with 'finishMocking()'.\n" +
-                "For examples of correct usage see javadoc for MockitoSession class.");
-    }
-
-    @Test public void concurrent_sessions_in_different_threads() throws Exception {
-        final Map<Class, Result> results = new ConcurrentHashMap<Class, Result>();
-        concurrently(new Runnable() {
-                         public void run() {
-                             results.put(StrictStubsPassing.class, junit.run(StrictStubsPassing.class));
-                         }
-                     }, new Runnable() {
-                         public void run() {
-                             results.put(ReportMismatchButNotUnusedStubbing.class, junit.run(ReportMismatchButNotUnusedStubbing.class));
-                         }
-                     }
-        );
-
-        assertThat(results.get(StrictStubsPassing.class)).succeeds(1);
-        assertThat(results.get(ReportMismatchButNotUnusedStubbing.class)).fails(1);
-    }
-
-    public static class UnnecessaryStubbing {
-        @Mock IMethods mock;
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void unnecessary_stubbing() {
-            given(mock.simpleMethod("1")).willReturn("one");
-            throw new IllegalStateException();
-        }
-    }
-
-    public static class ReportMismatchButNotUnusedStubbing {
-        @Mock IMethods mock;
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void mismatch() {
-            given(mock.simpleMethod(1)).willReturn("");
-            ProductionCode.simpleMethod(mock, 2);
-        }
-    }
-
-    public static class StrictStubsPassing {
-        @Mock IMethods mock;
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
-
-        @After public void after() {
-            mockito.finishMocking();
-        }
-
-        @Test public void used() {
-            given(mock.simpleMethod(1)).willReturn("");
-            mock.simpleMethod(1);
-        }
-    }
-
-    public static class LenientStrictness1 {
-        @Mock IMethods mock = Mockito.mock(IMethods.class);
-
-        @Test public void unused() {
-            given(mock.simpleMethod(1)).willReturn("");
-        }
-
-        @Test public void mismatch() {
-            given(mock.simpleMethod(2)).willReturn("");
-            mock.simpleMethod(3);
-        }
-    }
-
-    public static class LenientStrictness2 {
-        @Mock IMethods mock = Mockito.mock(IMethods.class);
-
-        @Test public void unused() {
-            given(mock.simpleMethod(1)).willReturn("");
-        }
-
-        @Test public void mismatch() {
-            given(mock.simpleMethod(2)).willReturn("");
-            mock.simpleMethod(3);
-        }
-    }
-
-    public static class UnfinishedMocking {
-        @Mock IMethods mock;
-        MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
-
-        @Test public void unused() {
-            given(mock.simpleMethod("1")).willReturn("one");
-        }
-
-        @Test public void unused2() {
-            given(mock.simpleMethod("1")).willReturn("one");
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java b/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
deleted file mode 100644
index 37195cb29a..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockitoutil.ThrowableAssert.assertThat;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.After;
-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.mockitousage.strictness.ProductionCode;
-
-public class StrictStubbingTest {
-
-    @Mock IMethods mock;
-
-    MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
-
-    @After public void after() {
-        //Some tests already invoke below but that's ok
-        mockito.finishMocking();
-    }
-
-    @Test public void no_interactions() throws Throwable {
-        //expect no exception
-        mockito.finishMocking();
-    }
-
-    @Test public void few_interactions() throws Throwable {
-        mock.simpleMethod(100);
-        mock.otherMethod();
-    }
-
-    @Test public void few_verified_interactions() throws Throwable {
-        //when
-        mock.simpleMethod(100);
-        mock.otherMethod();
-
-        //and
-        verify(mock).simpleMethod(100);
-        verify(mock).otherMethod();
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test public void stubbed_method_is_implicitly_verified() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-        mock.simpleMethod(100);
-
-        //no exceptions:
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-        mock.simpleMethod(100); // <- implicitly verified
-        mock.simpleMethod(200); // <- unverified
-
-        //expect
-        assertThat(new Runnable() {
-            public void run() {
-                verifyNoMoreInteractions(mock);
-            }
-        }).throwsException(NoInteractionsWanted.class);
-    }
-
-    @Test public void stubbing_argument_mismatch() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-
-        //stubbing argument mismatch is detected
-        assertThat(new Runnable() {
-            public void run() {
-                ProductionCode.simpleMethod(mock, 200);
-            }
-        }).throwsException(PotentialStubbingProblem.class);
-    }
-
-    @Test public void unused_stubbing() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-
-        //unused stubbing is reported
-        assertThat(new Runnable() {
-            public void run() {
-                mockito.finishMocking();
-            }
-        }).throwsException(UnnecessaryStubbingException.class);
-    }
-
-    private static void assertUnusedStubbingsWhen(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, int unusedStubbingsCount) {
-        Assertions.assertThatThrownBy(shouldRaiseThrowable)
-            .isInstanceOf(UnnecessaryStubbingException.class)
-            .hasMessageContaining(unusedStubbingsCount + " unnecessary stubbing");
-    }
-
-    @Test public void repeated_unnecessary_stubbing() {
-        given(mock.simpleMethod("1")).willReturn("one");
-        given(mock.simpleMethod("2")).willReturn("three");
-        given(mock.simpleMethod("1")).willReturn("two");  //repeat 1x
-        given(mock.simpleMethod("1")).willReturn("four"); //repeat 2x
-
-        mock.simpleMethod("1");
-        mock.simpleMethod("2");
-
-        assertUnusedStubbingsWhen(() -> mockito.finishMocking(), 2);
-    }
-
-    @Test public void repeated_unnecessary_stubbing_willReturn() {
-        willReturn("one").given(mock).simpleMethod("1");
-        willReturn("three").given(mock).simpleMethod("2");
-        willReturn("two").given(mock).simpleMethod("1");
-        willReturn("four").given(mock).simpleMethod("1");
-
-        mock.simpleMethod("1");
-        mock.simpleMethod("2");
-
-        assertUnusedStubbingsWhen(() -> mockito.finishMocking(), 2);
-    }
-
-    @Test public void unnecessary_stubbing_with_any_matchers() {
-        given(mock.simpleMethod((String) any())).willReturn("one");
-        given(mock.simpleMethod(anyString())).willReturn("three");
-
-        mock.simpleMethod("1");
-
-        assertUnusedStubbingsWhen(() -> mockito.finishMocking(), 1);
-    }
-
-    @Test public void unnecessary_stubbing_with_mixed_matchers() {
-        given(mock.simpleMethod(anyString())).willReturn("one");
-        given(mock.simpleMethod("foo")).willReturn("three");
-
-        mock.simpleMethod("1");
-
-        assertUnusedStubbingsWhen(() -> mockito.finishMocking(), 1);
-    }
-
-    @Test public void unnecessary_stubbing_with_stubs_only() {
-        given(mock.simpleMethod(anyString())).willReturn("one");
-        given(mock.simpleMethod("foo")).willReturn("three");
-
-        assertUnusedStubbingsWhen(() -> mockito.finishMocking(), 2);
-    }
-
-    @Test public void unnecessary_stubbing_with_mixed_matchers_willReturn() {
-        willReturn("one").given(mock).simpleMethod(anyString());
-        willReturn("three").given(mock).simpleMethod("foo");
-
-        mock.simpleMethod("1");
-
-        assertUnusedStubbingsWhen(() -> mockito.finishMocking(), 1);
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
deleted file mode 100644
index 863b7a88b4..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class StubbingConsecutiveAnswersTest extends TestBase {
-
-    @Mock
-    private IMethods mock;
-
-    @Test
-    public void should_return_consecutive_values() throws Exception {
-        when(mock.simpleMethod())
-                .thenReturn("one")
-                .thenReturn("two")
-                .thenReturn("three");
-
-        assertEquals("one", mock.simpleMethod());
-        assertEquals("two", mock.simpleMethod());
-        assertEquals("three", mock.simpleMethod());
-        assertEquals("three", mock.simpleMethod());
-        assertEquals("three", mock.simpleMethod());
-    }
-
-    @Test
-    public void should_return_consecutive_values_for_two_nulls() throws Exception {
-        when(mock.simpleMethod()).thenReturn(null, (String[]) null);
-
-        assertNull(mock.simpleMethod());
-        assertNull(mock.simpleMethod());
-    }
-
-    @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");
-
-        assertEquals("one", mock.simpleMethod());
-        assertEquals("two", mock.simpleMethod());
-        assertEquals("three", mock.simpleMethod());
-        assertEquals("three", mock.simpleMethod());
-        assertEquals("three", mock.simpleMethod());
-    }
-
-    @Test
-    public void should_return_consecutive_value_and_throw_exceptions_set_by_shorten_return_methods() {
-        when(mock.simpleMethod()).thenReturn("zero")
-                                 .thenReturn("one", "two")
-                                 .thenThrow(new NullPointerException(), new RuntimeException())
-                                 .thenReturn("three")
-                                 .thenThrow(new IllegalArgumentException());
-
-        assertEquals("zero", mock.simpleMethod());
-        assertEquals("one", mock.simpleMethod());
-        assertEquals("two", mock.simpleMethod());
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (RuntimeException expected) { }
-        assertEquals("three", mock.simpleMethod());
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-    }
-
-    @Test
-    public void should_throw_consecutively() throws Exception {
-        when(mock.simpleMethod()).thenThrow(new RuntimeException())
-                                 .thenThrow(new IllegalArgumentException())
-                                 .thenThrow(new NullPointerException());
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (RuntimeException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-    }
-
-    @Test
-    public void should_throw_consecutively_set_by_shorten_then_throw_method() throws Exception {
-        when(mock.simpleMethod()).thenThrow(new RuntimeException(),
-                                            new IllegalArgumentException(),
-                                            new NullPointerException());
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (RuntimeException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-    }
-
-    @Test
-    public void should_throw_classes() throws Exception {
-        // Unavoidable JDK7+ 'unchecked generic array creation' warning
-        when(mock.simpleMethod()).thenThrow(IllegalArgumentException.class);
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void should_throw_consecutively_classes_set_by_shorten_then_throw_method() throws Exception {
-        // Unavoidable JDK7+ 'unchecked generic array creation' warning
-        when(mock.simpleMethod()).thenThrow(RuntimeException.class,
-                                            IllegalArgumentException.class,
-                                            NullPointerException.class);
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (RuntimeException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-    }
-
-    @Test
-    public void should_mix_consecutive_returns_with_exceptions() throws Exception {
-        when(mock.simpleMethod())
-                .thenThrow(new IllegalArgumentException())
-                .thenReturn("one")
-                .thenThrow(new NullPointerException())
-                .thenReturn(null);
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-
-        assertEquals("one", mock.simpleMethod());
-
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-
-        assertEquals(null, mock.simpleMethod());
-        assertEquals(null, mock.simpleMethod());
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_validate_consecutive_exception() throws Exception {
-        when(mock.simpleMethod())
-                .thenReturn("one")
-                .thenThrow(new Exception());
-    }
-
-    @Test
-    public void should_stub_void_method_and_continue_throwing() throws Exception {
-        doThrow(new IllegalArgumentException())
-        .doNothing()
-        .doThrow(new NullPointerException())
-        .when(mock).voidMethod();
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (IllegalArgumentException expected) { }
-
-        mock.voidMethod();
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-    }
-
-    @Test
-    public void should_stub_void_method() throws Exception {
-        doNothing()
-        .doThrow(new NullPointerException())
-        .doNothing()
-        .when(mock)
-        .voidMethod();
-
-        mock.voidMethod();
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (NullPointerException expected) { }
-
-        mock.voidMethod();
-        mock.voidMethod();
-    }
-
-    @Test(expected = MockitoException.class)
-    public void should_validate_consecutive_exception_for_void_method() throws Exception {
-        doNothing()
-        .doThrow(new Exception())
-        .when(mock)
-        .voidMethod();
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java b/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
deleted file mode 100644
index b530d2c941..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import java.io.IOException;
-
-import org.assertj.core.api.Assertions;
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockitousage.IMethods;
-import org.mockitousage.MethodsImpl;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("serial")
-public class StubbingUsingDoReturnTest extends TestBase {
-
-    @Mock private IMethods mock;
-
-    @After public void reset_state() {
-        super.resetState();
-    }
-
-    @Test
-    public void should_stub() throws Exception {
-        doReturn("foo").when(mock).simpleMethod();
-        doReturn("bar").when(mock).simpleMethod();
-
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_stub_with_args() throws Exception {
-        doReturn("foo").when(mock).simpleMethod("foo");
-        doReturn("bar").when(mock).simpleMethod(eq("one"), anyInt());
-
-        Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
-        Assertions.assertThat(mock.simpleMethod("one", 234)).isEqualTo("bar");
-        Assertions.assertThat(mock.simpleMethod("xxx", 234)).isEqualTo(null);
-    }
-
-    class FooRuntimeException extends RuntimeException {}
-
-    @Test
-    public void should_stub_with_throwable() throws Exception {
-        doThrow(new FooRuntimeException()).when(mock).voidMethod();
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (FooRuntimeException e) {}
-    }
-
-    @Test
-    public void should_allow_setting_valid_checked_exception() throws Exception {
-        doThrow(new IOException()).when(mock).throwsIOException(0);
-
-        try {
-            mock.throwsIOException(0);
-            fail();
-        } catch (IOException e) {}
-    }
-
-    class FooCheckedException extends Exception {}
-
-    @Test
-    public void should_detect_invalid_checked_exception() throws Exception {
-        try {
-            doThrow(new FooCheckedException()).when(mock).throwsIOException(0);
-            fail();
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("Checked exception is invalid");
-        }
-    }
-
-    @Test
-    public void should_scream_when_return_set_for_void() throws Exception {
-        try {
-            doReturn("foo").when(mock).voidMethod();
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e)
-                .hasMessageContaining("void method")
-                .hasMessageContaining("cannot");
-        }
-    }
-
-    @Test
-    public void should_scream_when_not_a_mock_passed() throws Exception {
-        try {
-            doReturn("foo").when("foo").toString();
-            fail();
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("Argument passed to when() is not a mock");
-        }
-    }
-
-    @Test
-    public void should_scream_when_null_passed() throws Exception {
-        try {
-            doReturn("foo").when((Object) null).toString();
-            fail();
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("Argument passed to when() is null");
-        }
-    }
-
-    @Test
-    public void should_allow_chained_stubbing() {
-        doReturn("foo")
-                .doThrow(new RuntimeException())
-                .doReturn("bar")
-                .when(mock).simpleMethod();
-
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("foo");
-        try {
-            mock.simpleMethod();
-            fail();
-        } catch (RuntimeException expected) { }
-
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("bar");
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("bar");
-    }
-
-    @Test
-    public void should_allow_consecutive_return_values() {
-        doReturn("foo", "bar")
-                .doThrow(new RuntimeException())
-                .doReturn(430L, new byte[0], "qix")
-                .when(mock).objectReturningMethodNoArgs();
-
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("foo");
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("bar");
-        try {
-            mock.objectReturningMethodNoArgs();
-            fail("exception not raised");
-        } catch (RuntimeException expected) { }
-
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(430L);
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(new byte[0]);
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("qix");
-        Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("qix");
-    }
-
-    @Test
-    public void should_allow_do_call_real_method_in_chained_stubbing() throws Exception {
-        MethodsImpl methods = mock(MethodsImpl.class);
-        doReturn("A").doCallRealMethod()
-                .when(methods).simpleMethod();
-
-        Assertions.assertThat(methods.simpleMethod()).isEqualTo("A");
-        Assertions.assertThat(methods.simpleMethod()).isEqualTo(null);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void should_allow_chained_stubbing_with_exception_class() throws Exception {
-        doReturn("whatever").doThrow(IllegalArgumentException.class).when(mock).simpleMethod();
-
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("whatever");
-        mock.simpleMethod();
-    }
-
-    @Test
-    public void should_allow_chained_stubbing_on_void_methods() {
-        doNothing()
-                .doNothing()
-                .doThrow(new RuntimeException())
-                .when(mock).voidMethod();
-
-        mock.voidMethod();
-        mock.voidMethod();
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (RuntimeException e) {}
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (RuntimeException e) {}
-    }
-
-    @Test
-    public void should_stub_with_generic_answer() {
-        doAnswer(new Answer<Object>() {
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                return "foo";
-            }
-        })
-        .when(mock).simpleMethod();
-
-        Assertions.assertThat(mock.simpleMethod()).isEqualTo("foo");
-    }
-
-    @Test
-    public void should_not_allow_do_nothing_on_non_voids() {
-        try {
-            doNothing().when(mock).simpleMethod();
-            fail();
-        } catch (MockitoException e) {
-            assertThat(e).hasMessageContaining("Only void methods can doNothing()");
-        }
-    }
-
-    @Test
-    public void should_stubbing_be_treated_as_interaction() throws Exception {
-        doReturn("foo").when(mock).simpleMethod();
-        mock.simpleMethod();
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void should_verify_stubbed_call() throws Exception {
-        doReturn("foo").when(mock).simpleMethod();
-        mock.simpleMethod();
-        mock.simpleMethod();
-
-        verify(mock, times(2)).simpleMethod();
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test
-    public void should_allow_stubbing_to_string() throws Exception {
-        doReturn("test").when(mock).toString();
-        Assertions.assertThat(mock.toString()).isEqualTo("test");
-    }
-
-    @Test
-    public void should_detect_invalid_return_type() throws Exception {
-        try {
-            doReturn("foo").when(mock).booleanObjectReturningMethod();
-            fail();
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("String cannot be returned by booleanObjectReturningMethod()" +
-                    "\n" +
-                    "booleanObjectReturningMethod() should return Boolean");
-        }
-    }
-
-    @Test
-    public void should_detect_when_null_assigned_to_boolean() throws Exception {
-        try {
-            doReturn(null).when(mock).intReturningMethod();
-            fail();
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("null cannot be returned by intReturningMethod");
-        }
-    }
-
-    @Test
-    public void should_allow_stubbing_when_types_match_signature() throws Exception {
-        doReturn("foo").when(mock).objectReturningMethodNoArgs();
-        doReturn("foo").when(mock).simpleMethod();
-        doReturn(1).when(mock).intReturningMethod();
-        doReturn(2).when(mock).intReturningMethod();
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
deleted file mode 100644
index 199eb86f3c..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static java.util.Collections.singletonList;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.verify;
-import static org.mockitoutil.TestBase.filterLineNo;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoSession;
-import org.mockito.StateMaster;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.framework.DefaultMockitoSession;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockito.quality.Strictness;
-import org.mockitousage.IMethods;
-
-public class StubbingWarningsTest {
-
-    private static final String TEST_NAME = "test.name";
-
-    @Mock IMethods mock;
-
-    SimpleMockitoLogger logger = new SimpleMockitoLogger();
-    MockitoSession mockito = new DefaultMockitoSession(singletonList((Object) this), TEST_NAME, Strictness.WARN, logger);
-
-    @After public void after() {
-        StateMaster stateMaster = new StateMaster();
-        stateMaster.reset();
-        stateMaster.clearMockitoListeners();
-    }
-
-    @Test public void few_interactions() throws Throwable {
-        //when
-        mock.simpleMethod(100);
-        mock.otherMethod();
-
-        //expect no exception
-        mockito.finishMocking();
-        logger.assertEmpty();
-    }
-
-    @Test public void stubbing_used() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-        mock.simpleMethod(100);
-
-        //then
-        mockito.finishMocking();
-        logger.assertEmpty();
-    }
-
-    @Test public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-        mock.simpleMethod(100); // <- stubbing is used
-        mock.simpleMethod(200); // <- other method should not generate arg mismatch
-
-        //then
-        mockito.finishMocking();
-        logger.assertEmpty();
-    }
-
-    @Test public void stubbing_argument_mismatch() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-        mock.simpleMethod(200);
-
-        mockito.finishMocking();
-
-        //TODO - currently we warn about "Unused" instead of "Arg mismatch" below
-        //because it was simpler to implement. This can be improved given we put priority to improve the warnings.
-        //then
-        assertEquals(filterLineNo(
-            "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" +
-            "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.stubbing_argument_mismatch(StubbingWarningsTest.java:0)\n"),
-                filterLineNo(logger.getLoggedInfo()));
-    }
-
-    @Test public void unused_stubbing() throws Throwable {
-        //when
-        given(mock.simpleMethod(100)).willReturn("100");
-
-        mockito.finishMocking();
-
-        //then
-        assertEquals(filterLineNo(
-            "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" +
-            "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.unused_stubbing(StubbingWarningsTest.java:0)\n"),
-                filterLineNo(logger.getLoggedInfo()));
-    }
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test(expected = MockitoException.class) public void unfinished_verification_without_throwable() throws Throwable {
-        //when
-        verify(mock);
-
-        mockito.finishMocking();
-    }
-
-    @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
-    @Test public void unfinished_verification_with_throwable() throws Throwable {
-        //when
-        verify(mock);
-
-        mockito.finishMocking(new AssertionError());
-
-        // then
-        logger.assertEmpty();
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
deleted file mode 100644
index 97dac76ab4..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.within;
-import static org.mockito.AdditionalAnswers.answer;
-import static org.mockito.AdditionalAnswers.answerVoid;
-import static org.mockito.AdditionalAnswers.answersWithDelay;
-import static org.mockito.AdditionalAnswers.returnsArgAt;
-import static org.mockito.AdditionalAnswers.returnsFirstArg;
-import static org.mockito.AdditionalAnswers.returnsLastArg;
-import static org.mockito.AdditionalAnswers.returnsSecondArg;
-import static org.mockito.BDDMockito.any;
-import static org.mockito.BDDMockito.anyInt;
-import static org.mockito.BDDMockito.anyString;
-import static org.mockito.BDDMockito.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.mock;
-import static org.mockito.BDDMockito.times;
-import static org.mockito.BDDMockito.verify;
-
-import java.util.Date;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer1;
-import org.mockito.stubbing.Answer2;
-import org.mockito.stubbing.Answer3;
-import org.mockito.stubbing.Answer4;
-import org.mockito.stubbing.Answer5;
-import org.mockito.stubbing.Answer6;
-import org.mockito.stubbing.VoidAnswer1;
-import org.mockito.stubbing.VoidAnswer2;
-import org.mockito.stubbing.VoidAnswer3;
-import org.mockito.stubbing.VoidAnswer4;
-import org.mockito.stubbing.VoidAnswer5;
-import org.mockito.stubbing.VoidAnswer6;
-import org.mockitousage.IMethods;
-
-@RunWith(MockitoJUnitRunner.class)
-public class StubbingWithAdditionalAnswersTest {
-
-    @Mock IMethods iMethods;
-
-    @Test
-    public void can_return_arguments_of_invocation() throws Exception {
-        given(iMethods.objectArgMethod(any())).will(returnsFirstArg());
-        given(iMethods.threeArgumentMethod(eq(0), any(), anyString())).will(returnsSecondArg());
-        given(iMethods.threeArgumentMethod(eq(1), any(), anyString())).will(returnsLastArg());
-
-        assertThat(iMethods.objectArgMethod("first")).isEqualTo("first");
-        assertThat(iMethods.threeArgumentMethod(0, "second", "whatever")).isEqualTo("second");
-        assertThat(iMethods.threeArgumentMethod(1, "whatever", "last")).isEqualTo("last");
-    }
-
-    @Test
-    public void can_return_after_delay() throws Exception {
-        final long sleepyTime = 500L;
-
-        given(iMethods.objectArgMethod(any())).will(answersWithDelay(sleepyTime, returnsFirstArg()));
-
-        final Date before = new Date();
-        assertThat(iMethods.objectArgMethod("first")).isEqualTo("first");
-        final Date after = new Date();
-
-        final long timePassed = after.getTime() - before.getTime();
-        assertThat(timePassed).isCloseTo(sleepyTime, within(15L));
-    }
-
-    @Test
-    public void can_return_expanded_arguments_of_invocation() throws Exception {
-        given(iMethods.varargsObject(eq(1), any())).will(returnsArgAt(3));
-
-        assertThat(iMethods.varargsObject(1, "bob", "alexander", "alice", "carl")).isEqualTo("alice");
-    }
-
-    @Test
-    public void can_return_primitives_or_wrappers() throws Exception {
-        given(iMethods.toIntPrimitive(anyInt())).will(returnsFirstArg());
-        given(iMethods.toIntWrapper(anyInt())).will(returnsFirstArg());
-
-        assertThat(iMethods.toIntPrimitive(1)).isEqualTo(1);
-        assertThat(iMethods.toIntWrapper(1)).isEqualTo(1);
-    }
-
-    @Test
-    public void can_return_based_on_strongly_types_one_parameter_function() throws Exception {
-        given(iMethods.simpleMethod(anyString()))
-                .will(answer(new Answer1<String, String>() {
-                    public String answer(String s) {
-                        return s;
-                    }
-                }));
-
-        assertThat(iMethods.simpleMethod("string")).isEqualTo("string");
-    }
-
-    @Test
-    public void will_execute_a_void_based_on_strongly_typed_one_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-
-        given(iMethods.simpleMethod(anyString()))
-                .will(answerVoid(new VoidAnswer1<String>() {
-                    public void answer(String s) {
-                        target.simpleMethod(s);
-                    }
-                }));
-
-        // invoke on iMethods
-        iMethods.simpleMethod("string");
-
-        // expect the answer to write correctly to "target"
-        verify(target, times(1)).simpleMethod("string");
-    }
-
-    @Test
-    public void can_return_based_on_strongly_typed_two_parameter_function() throws Exception {
-        given(iMethods.simpleMethod(anyString(), anyInt()))
-            .will(answer(new Answer2<String, String, Integer>() {
-                public String answer(String s, Integer i) {
-                    return s + "-" + i;
-                }
-            }));
-
-        assertThat(iMethods.simpleMethod("string",1)).isEqualTo("string-1");
-    }
-
-    @Test
-    public void will_execute_a_void_based_on_strongly_typed_two_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-
-        given(iMethods.simpleMethod(anyString(), anyInt()))
-            .will(answerVoid(new VoidAnswer2<String, Integer>() {
-                public void answer(String s, Integer i) {
-                    target.simpleMethod(s, i);
-                }
-            }));
-
-        // invoke on iMethods
-        iMethods.simpleMethod("string",1);
-
-        // expect the answer to write correctly to "target"
-        verify(target, times(1)).simpleMethod("string", 1);
-    }
-
-    @Test
-    public void can_return_based_on_strongly_typed_three_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-        given(iMethods.threeArgumentMethodWithStrings(anyInt(), anyString(), anyString()))
-                .will(answer(new Answer3<String, Integer, String, String>() {
-                    public String answer(Integer i, String s1, String s2) {
-                        target.threeArgumentMethodWithStrings(i, s1, s2);
-                        return "answered";
-                    }
-                }));
-
-        assertThat(iMethods.threeArgumentMethodWithStrings(1, "string1", "string2")).isEqualTo("answered");
-        verify(target, times(1)).threeArgumentMethodWithStrings(1, "string1", "string2");
-    }
-
-    @Test
-    public void will_execute_a_void_based_on_strongly_typed_three_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-
-        given(iMethods.threeArgumentMethodWithStrings(anyInt(), anyString(), anyString()))
-                .will(answerVoid(new VoidAnswer3<Integer, String, String>() {
-                    public void answer(Integer i, String s1, String s2) {
-                        target.threeArgumentMethodWithStrings(i, s1, s2);
-                    }
-                }));
-
-        // invoke on iMethods
-        iMethods.threeArgumentMethodWithStrings(1, "string1", "string2");
-
-        // expect the answer to write correctly to "target"
-        verify(target, times(1)).threeArgumentMethodWithStrings(1, "string1", "string2");
-    }
-
-    @Test
-    public void can_return_based_on_strongly_typed_four_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-        given(iMethods.fourArgumentMethod(anyInt(), anyString(), anyString(), any(boolean[].class)))
-                .will(answer(new Answer4<String, Integer, String, String, boolean[]>() {
-                    public String answer(Integer i, String s1, String s2, boolean[] a) {
-                        target.fourArgumentMethod(i, s1, s2, a);
-                        return "answered";
-                    }
-                }));
-
-        boolean[] booleanArray = { true, false };
-        assertThat(iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray)).isEqualTo("answered");
-        verify(target, times(1)).fourArgumentMethod(1, "string1", "string2", booleanArray);
-    }
-
-    @Test
-    public void will_execute_a_void_based_on_strongly_typed_four_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-
-        given(iMethods.fourArgumentMethod(anyInt(), anyString(), anyString(), any(boolean[].class)))
-                .will(answerVoid(new VoidAnswer4<Integer, String, String, boolean[]>() {
-                    public void answer(Integer i, String s1, String s2, boolean[] a) {
-                        target.fourArgumentMethod(i, s1, s2, a);
-                    }
-                }));
-
-        // invoke on iMethods
-        boolean[] booleanArray = { true, false };
-        iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray);
-
-        // expect the answer to write correctly to "target"
-        verify(target, times(1)).fourArgumentMethod(1, "string1", "string2", booleanArray);
-    }
-
-    @Test
-    public void can_return_based_on_strongly_typed_five_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt()))
-                .will(answer(new Answer5<String, String, Integer, Integer, Integer, Integer>() {
-                    public String answer(String s1, Integer i1, Integer i2, Integer i3, Integer i4) {
-                        target.simpleMethod(s1, i1, i2, i3, i4);
-                        return "answered";
-                    }
-                }));
-
-        assertThat(iMethods.simpleMethod("hello", 1, 2, 3, 4)).isEqualTo("answered");
-        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4);
-    }
-
-    @Test
-    public void will_execute_a_void_based_on_strongly_typed_five_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-
-        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt()))
-                .will(answerVoid(new VoidAnswer5<String, Integer, Integer, Integer, Integer>() {
-                    public void  answer(String s1, Integer i1, Integer i2, Integer i3, Integer i4) {
-                        target.simpleMethod(s1, i1, i2, i3, i4);
-                    }
-                }));
-
-        // invoke on iMethods
-        iMethods.simpleMethod("hello", 1, 2, 3, 4);
-
-        // expect the answer to write correctly to "target"
-        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4);
-    }
-
-    @Test
-    public void can_return_based_on_strongly_typed_six_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt()))
-                .will(answer(new Answer6<String, String, Integer, Integer, Integer, Integer, Integer>() {
-                    public String answer(String s1, Integer i1, Integer i2, Integer i3, Integer i4, Integer i5) {
-                        target.simpleMethod(s1, i1, i2, i3, i4, i5);
-                        return "answered";
-                    }
-                }));
-
-        assertThat(iMethods.simpleMethod("hello", 1, 2, 3, 4, 5)).isEqualTo("answered");
-        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4, 5);
-    }
-
-    @Test
-    public void will_execute_a_void_returning_strongly_typed_six_parameter_function() throws Exception {
-        final IMethods target = mock(IMethods.class);
-
-        given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt()))
-                .will(answerVoid(new VoidAnswer6<String, Integer, Integer, Integer, Integer, Integer>() {
-                    public void answer(String s1, Integer i1, Integer i2, Integer i3, Integer i4, Integer i5) {
-                        target.simpleMethod(s1, i1, i2, i3, i4, i5);
-                    }
-                }));
-
-        // invoke on iMethods
-        iMethods.simpleMethod("hello", 1, 2, 3, 4, 5);
-
-        // expect the answer to write correctly to "target"
-        verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4, 5);
-    }
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java
deleted file mode 100644
index 71e96ad7db..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.mockito.Mockito.doThrow;
-
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockitoutil.TestBase;
-
-//issue 1514
-@SuppressWarnings({ "serial", "unchecked", "rawtypes" })
-public class StubbingWithBadThrowablesTest extends TestBase {
-
-    @Mock List mock;
-
-    @Test
-    public void handles_bad_exception() {
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                doThrow(UninstantiableException.class).when(mock).clear();
-            }
-        }).isInstanceOf(InstantiationError.class); //because the exception cannot be instantiated
-
-        //ensure that the state is cleaned
-        Mockito.validateMockitoUsage();
-    }
-
-    abstract static class UninstantiableException extends RuntimeException {}
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
deleted file mode 100644
index b83161069e..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-import java.lang.reflect.Method;
-import java.util.Set;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class StubbingWithCustomAnswerTest extends TestBase {
-    @Mock
-    private IMethods mock;
-
-    @Test
-    public void shouldAnswer() throws Exception {
-        when(mock.simpleMethod(anyString())).thenAnswer(new Answer<String>() {
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                String arg =  invocation.getArgument(0);
-
-                return invocation.getMethod().getName() + "-" + arg;
-            }
-        });
-
-        assertEquals("simpleMethod-test", mock.simpleMethod("test"));
-    }
-
-    @Test
-    public void shouldAnswerWithThenAnswerAlias() throws Exception {
-        RecordCall recordCall = new RecordCall();
-        Set<?> mockedSet = (Set<?>) when(mock(Set.class).isEmpty()).then(recordCall).getMock();
-
-        mockedSet.isEmpty();
-
-        assertTrue(recordCall.isCalled());
-    }
-
-    @Test
-    public void shouldAnswerConsecutively() throws Exception {
-        when(mock.simpleMethod())
-                .thenAnswer(new Answer<String>() {
-                    public String answer(InvocationOnMock invocation) throws Throwable {
-                        return invocation.getMethod().getName();
-                    }
-                })
-                .thenReturn("Hello")
-                .thenAnswer(new Answer<String>() {
-                    public String answer(InvocationOnMock invocation) throws Throwable {
-                        return invocation.getMethod().getName() + "-1";
-                    }
-                });
-
-        assertEquals("simpleMethod", mock.simpleMethod());
-        assertEquals("Hello", mock.simpleMethod());
-        assertEquals("simpleMethod-1", mock.simpleMethod());
-        assertEquals("simpleMethod-1", mock.simpleMethod());
-    }
-
-    @Test
-    public void shouldAnswerVoidMethod() throws Exception {
-        RecordCall recordCall = new RecordCall();
-
-        doAnswer(recordCall).when(mock).voidMethod();
-
-        mock.voidMethod();
-        assertTrue(recordCall.isCalled());
-    }
-
-    @Test
-    public void shouldAnswerVoidMethodConsecutively() throws Exception {
-        RecordCall call1 = new RecordCall();
-        RecordCall call2 = new RecordCall();
-
-        doAnswer(call1)
-        .doThrow(new UnsupportedOperationException())
-        .doAnswer(call2)
-        .when(mock).voidMethod();
-
-        mock.voidMethod();
-        assertTrue(call1.isCalled());
-        assertFalse(call2.isCalled());
-
-        try {
-            mock.voidMethod();
-            fail();
-        } catch (UnsupportedOperationException e) {
-        }
-
-        mock.voidMethod();
-        assertTrue(call2.isCalled());
-    }
-
-    @Test
-    public void shouldMakeSureTheInterfaceDoesNotChange() throws Exception {
-        when(mock.simpleMethod(anyString())).thenAnswer(new Answer<String>() {
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                assertTrue(invocation.getArguments().getClass().isArray());
-                assertEquals(Method.class, invocation.getMethod().getClass());
-
-                return "assertions passed";
-            }
-        });
-
-        assertEquals("assertions passed", mock.simpleMethod("test"));
-    }
-
-    private static class RecordCall implements Answer<Object> {
-        private boolean called = false;
-
-        public boolean isCalled() {
-            return called;
-        }
-
-        public Object answer(InvocationOnMock invocation) throws Throwable {
-            called = true;
-            return null;
-        }
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
deleted file mode 100644
index 3798ca735f..0000000000
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.stubbing;
-
-import static org.hamcrest.CoreMatchers.sameInstance;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import java.io.IOException;
-import java.io.Reader;
-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;
-import org.junit.rules.ExpectedException;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings({ "serial", "unchecked", "rawtypes" })
-public class StubbingWithThrowablesTest extends TestBase {
-
-    private LinkedList mock;
-
-    private Map mockTwo;
-
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
-    @Before
-    public void setup() {
-        mock = mock(LinkedList.class);
-        mockTwo = mock(HashMap.class);
-    }
-
-    @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
-    public void shouldSetThrowableToVoidMethod() throws Exception {
-        IllegalArgumentException expected = new IllegalArgumentException("thrown by mock");
-
-        doThrow(expected).when(mock).clear();
-
-        exception.expect(sameInstance(expected));
-
-        mock.clear();
-
-    }
-
-    @Test
-    public void shouldLastStubbingVoidBeImportant() throws Exception {
-        doThrow(new ExceptionOne()).when(mock).clear();
-        doThrow(new ExceptionTwo()).when(mock).clear();
-
-        exception.expect(ExceptionTwo.class);
-
-        mock.clear();
-    }
-
-    @Test
-    public void shouldFailStubbingThrowableOnTheSameInvocationDueToAcceptableLimitation() throws Exception {
-        when(mock.size()).thenThrow(new ExceptionOne());
-
-        exception.expect(ExceptionOne.class);
-
-        when(mock.size()).thenThrow(new ExceptionTwo());
-    }
-
-    @Test
-    public void shouldAllowSettingCheckedException() throws Exception {
-        Reader reader = mock(Reader.class);
-        IOException ioException = new IOException();
-
-        when(reader.read()).thenThrow(ioException);
-
-        exception.expect(sameInstance(ioException));
-
-        reader.read();
-    }
-
-    @Test
-    public void shouldAllowSettingError() throws Exception {
-        Error error = new Error();
-
-        when(mock.add("quake")).thenThrow(error);
-
-        exception.expect(Error.class);
-
-        mock.add("quake");
-    }
-
-    @Test
-    public void shouldNotAllowNullExceptionType() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot stub with null throwable");
-
-        when(mock.add(null)).thenThrow((Exception) null);
-    }
-
-    @Test
-    public void shouldInstantiateExceptionClassOnInteraction() {
-        when(mock.add(null)).thenThrow(NaughtyException.class);
-
-        exception.expect(NaughtyException.class);
-
-        mock.add(null);
-    }
-
-    @Test
-    public void shouldInstantiateExceptionClassWithOngoingStubbingOnInteraction() {
-        doThrow(NaughtyException.class).when(mock).add(null);
-
-        exception.expect(NaughtyException.class);
-
-        mock.add(null);
-    }
-
-    @Test
-    public void shouldNotAllowSettingInvalidCheckedException() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Checked exception is invalid for this method");
-
-        when(mock.add("monkey island")).thenThrow(new Exception());
-    }
-
-    @Test
-    public void shouldNotAllowSettingNullThrowable() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot stub with null throwable");
-
-        when(mock.add("monkey island")).thenThrow((Throwable) null);
-    }
-
-    @Test
-    public void shouldNotAllowSettingNullThrowableArray() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Cannot stub with null throwable");
-
-        when(mock.add("monkey island")).thenThrow((Throwable[]) null);
-    }
-
-    @Test
-    public void shouldNotAllowSettingNullThrowableClass() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        when(mock.isEmpty()).thenThrow((Class) null);
-    }
-
-    @Test
-    public void shouldNotAllowSettingNullThrowableClasses() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class[]) null);
-    }
-
-    @Test
-    public void shouldNotAllowSettingNullVarArgThrowableClass() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class) null);
-    }
-
-    @Test
-    public void doThrowShouldNotAllowSettingNullThrowableClass() {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        doThrow((Class) null).when(mock).isEmpty();
-    }
-
-    @Test
-    public void doThrowShouldNotAllowSettingNullThrowableClasses() throws Exception {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        doThrow(RuntimeException.class, (Class) null).when(mock).isEmpty();
-    }
-
-    @Test
-    public void doThrowShouldNotAllowSettingNullVarArgThrowableClasses() throws Exception {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        doThrow(RuntimeException.class, (Class[]) null).when(mock).isEmpty();
-    }
-
-    @Test
-    public void shouldNotAllowSettingNullVarArgsThrowableClasses() throws Exception {
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Exception type cannot be null");
-
-        when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class<RuntimeException>[]) null);
-    }
-
-    @Test
-    public void shouldNotAllowDifferentCheckedException() throws Exception {
-        IMethods mock = mock(IMethods.class);
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Checked exception is invalid for this method");
-
-        when(mock.throwsIOException(0)).thenThrow(CheckedException.class);
-    }
-
-    @Test
-    public void shouldNotAllowCheckedExceptionWhenErrorIsDeclared() throws Exception {
-        IMethods mock = mock(IMethods.class);
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Checked exception is invalid for this method");
-
-        when(mock.throwsError(0)).thenThrow(CheckedException.class);
-    }
-
-    @Test
-    public void shouldNotAllowCheckedExceptionWhenNothingIsDeclared() throws Exception {
-        IMethods mock = mock(IMethods.class);
-
-        exception.expect(MockitoException.class);
-        exception.expectMessage("Checked exception is invalid for this method");
-
-        when(mock.throwsNothing(true)).thenThrow(CheckedException.class);
-    }
-
-    @Test
-    public void shouldMixThrowablesAndReturnsOnDifferentMocks() throws Exception {
-        when(mock.add("ExceptionOne")).thenThrow(new ExceptionOne());
-        when(mock.getLast()).thenReturn("last");
-        doThrow(new ExceptionTwo()).when(mock).clear();
-
-        doThrow(new ExceptionThree()).when(mockTwo).clear();
-        when(mockTwo.containsValue("ExceptionFour")).thenThrow(new ExceptionFour());
-        when(mockTwo.get("Are you there?")).thenReturn("Yes!");
-
-        assertNull(mockTwo.get("foo"));
-        assertTrue(mockTwo.keySet().isEmpty());
-        assertEquals("Yes!", mockTwo.get("Are you there?"));
-        try {
-            mockTwo.clear();
-            fail();
-        } catch (ExceptionThree e) {
-        }
-        try {
-            mockTwo.containsValue("ExceptionFour");
-            fail();
-        } catch (ExceptionFour e) {
-        }
-
-        assertNull(mock.getFirst());
-        assertEquals("last", mock.getLast());
-        try {
-            mock.add("ExceptionOne");
-            fail();
-        } catch (ExceptionOne e) {
-        }
-        try {
-            mock.clear();
-            fail();
-        } catch (ExceptionTwo e) {
-        }
-    }
-
-    @Test
-    public void shouldStubbingWithThrowableBeVerifiable() {
-        when(mock.size()).thenThrow(new RuntimeException());
-        doThrow(new RuntimeException()).when(mock).clone();
-
-        try {
-            mock.size();
-            fail();
-        } catch (RuntimeException e) {
-        }
-
-        try {
-            mock.clone();
-            fail();
-        } catch (RuntimeException e) {
-        }
-
-        verify(mock).size();
-        verify(mock).clone();
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test
-    public void shouldStubbingWithThrowableFailVerification() {
-        when(mock.size()).thenThrow(new RuntimeException());
-        doThrow(new RuntimeException()).when(mock).clone();
-
-        verifyNoInteractions(mock);
-
-        mock.add("test");
-
-        try {
-            verify(mock).size();
-            fail();
-        } catch (WantedButNotInvoked e) {
-        }
-
-        try {
-            verify(mock).clone();
-            fail();
-        } catch (WantedButNotInvoked e) {
-        }
-
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-        }
-    }
-
-    private class ExceptionOne extends RuntimeException {
-    }
-
-    private class ExceptionTwo extends RuntimeException {
-    }
-
-    private class ExceptionThree extends RuntimeException {
-    }
-
-    private class ExceptionFour extends RuntimeException {
-    }
-
-    private class CheckedException extends Exception {
-    }
-
-    public class NaughtyException extends RuntimeException {
-        public NaughtyException() {
-            throw new RuntimeException("boo!");
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
deleted file mode 100644
index acffe23400..0000000000
--- a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class BasicVerificationInOrderTest extends TestBase {
-
-    private IMethods mockOne;
-    private IMethods mockTwo;
-    private IMethods mockThree;
-    private InOrder inOrder;
-
-    @Before
-    public void setUp() {
-        mockOne = mock(IMethods.class);
-        mockTwo = mock(IMethods.class);
-        mockThree = mock(IMethods.class);
-
-        inOrder = inOrder(mockOne, mockTwo, mockThree);
-
-        mockOne.simpleMethod(1);
-        mockTwo.simpleMethod(2);
-        mockTwo.simpleMethod(2);
-        mockThree.simpleMethod(3);
-        mockTwo.simpleMethod(2);
-        mockOne.simpleMethod(4);
-    }
-
-    @Test
-    public void shouldVerifyInOrder() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldVerifyInOrderUsingAtLeastOnce() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(4);
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldVerifyInOrderWhenExpectingSomeInvocationsToBeCalledZeroTimes() {
-        inOrder.verify(mockOne, times(0)).oneArg(false);
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockTwo, times(0)).simpleMethod(22);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-        inOrder.verify(mockThree, times(0)).oneArg(false);
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldFailWhenFirstMockCalledTwice() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        try {
-            inOrder.verify(mockOne).simpleMethod(1);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailWhenLastMockCalledTwice() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-        try {
-            inOrder.verify(mockOne).simpleMethod(4);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test(expected = VerificationInOrderFailure.class)
-    public void shouldFailOnFirstMethodBecauseOneInvocationWanted() {
-        inOrder.verify(mockOne, times(0)).simpleMethod(1);
-    }
-
-    @Test(expected = VerificationInOrderFailure.class)
-    public void shouldFailOnFirstMethodBecauseOneInvocationWantedAgain() {
-        inOrder.verify(mockOne, times(2)).simpleMethod(1);
-    }
-
-    @Test
-    public void shouldFailOnSecondMethodBecauseFourInvocationsWanted() {
-        inOrder.verify(mockOne, times(1)).simpleMethod(1);
-        try {
-            inOrder.verify(mockTwo, times(4)).simpleMethod(2);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnSecondMethodBecauseTwoInvocationsWantedAgain() {
-        inOrder.verify(mockOne, times(1)).simpleMethod(1);
-        try {
-            inOrder.verify(mockTwo, times(0)).simpleMethod(2);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnLastMethodBecauseOneInvocationWanted() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree, atLeastOnce()).simpleMethod(3);
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        try {
-            inOrder.verify(mockOne, times(0)).simpleMethod(4);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnLastMethodBecauseOneInvocationWantedAgain() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree, atLeastOnce()).simpleMethod(3);
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        try {
-            inOrder.verify(mockOne, times(2)).simpleMethod(4);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    /* ------------- */
-
-    @Test(expected = ArgumentsAreDifferent.class)
-    public void shouldFailOnFirstMethodBecauseDifferentArgsWanted() {
-        inOrder.verify(mockOne).simpleMethod(100);
-    }
-
-    @Test(expected = WantedButNotInvoked.class)
-    public void shouldFailOnFirstMethodBecauseDifferentMethodWanted() {
-        inOrder.verify(mockOne).oneArg(true);
-    }
-
-    @Test
-    public void shouldFailOnSecondMethodBecauseDifferentArgsWanted() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        try {
-            inOrder.verify(mockTwo, times(2)).simpleMethod(-999);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnSecondMethodBecauseDifferentMethodWanted() {
-        inOrder.verify(mockOne, times(1)).simpleMethod(1);
-        try {
-            inOrder.verify(mockTwo, times(2)).oneArg(true);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnLastMethodBecauseDifferentArgsWanted() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        try {
-            inOrder.verify(mockOne).simpleMethod(-666);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnLastMethodBecauseDifferentMethodWanted() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        try {
-            inOrder.verify(mockOne).oneArg(false);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    /* -------------- */
-
-    @Test
-    public void shouldFailWhenLastMethodVerifiedFirst() {
-        inOrder.verify(mockOne).simpleMethod(4);
-        try {
-            inOrder.verify(mockOne).simpleMethod(1);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailWhenMiddleMethodVerifiedFirst() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        try {
-            inOrder.verify(mockOne).simpleMethod(1);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailWhenMiddleMethodVerifiedFirstInAtLeastOnceMode() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        try {
-            inOrder.verify(mockOne).simpleMethod(1);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-        }
-    }
-
-    @Test
-    public void shouldFailOnVerifyNoMoreInteractions() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-
-        try {
-            verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-            fail();
-        } catch (NoInteractionsWanted e) {
-        }
-    }
-
-    @Test(expected = NoInteractionsWanted.class)
-    public void shouldFailOnVerifyZeroInteractions() {
-        verifyZeroInteractions(mockOne);
-    }
-
-    @Test(expected = NoInteractionsWanted.class)
-    public void shouldFailOnVerifyNoInteractions() {
-        verifyNoInteractions(mockOne);
-    }
-
-    @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
deleted file mode 100644
index 811edaf9e8..0000000000
--- a/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import java.util.List;
-
-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.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class BasicVerificationTest extends TestBase {
-
-    @Mock private List<String> mock;
-    @Mock private List<String> mockTwo;
-
-    @Test
-    public void shouldVerify() throws Exception {
-        mock.clear();
-        verify(mock).clear();
-
-        mock.add("test");
-        verify(mock).add("test");
-
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test(expected=WantedButNotInvoked.class)
-    public void shouldFailVerification() throws Exception {
-        verify(mock).clear();
-    }
-
-    @Test
-    public void shouldFailVerificationOnMethodArgument() throws Exception {
-        mock.clear();
-        mock.add("foo");
-
-        verify(mock).clear();
-
-        assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            @Override
-            public void call() {
-                verify(mock).add("bar");
-            }
-        }).isInstanceOf(ArgumentsAreDifferent.class);
-    }
-
-    @Test
-    public void shouldFailOnWrongMethod() throws Exception {
-        mock.clear();
-        mock.clear();
-
-        mockTwo.add("add");
-
-        verify(mock, atLeastOnce()).clear();
-        verify(mockTwo, atLeastOnce()).add("add");
-        try {
-            verify(mockTwo, atLeastOnce()).add("foo");
-            fail();
-        } catch (WantedButNotInvoked e) {}
-    }
-
-    @Test
-    public void shouldDetectRedundantInvocation() throws Exception {
-        mock.clear();
-        mock.add("foo");
-        mock.add("bar");
-
-        verify(mock).clear();
-        verify(mock).add("foo");
-
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldDetectWhenInvokedMoreThanOnce() throws Exception {
-        mock.add("foo");
-        mock.clear();
-        mock.clear();
-
-        verify(mock).add("foo");
-
-        try {
-            verify(mock).clear();
-            fail();
-        } catch (TooManyActualInvocations e) {}
-    }
-
-    @Test
-    public void shouldVerifyStubbedMethods() throws Exception {
-        when(mock.add("test")).thenReturn(Boolean.FALSE);
-
-        mock.add("test");
-
-        verify(mock).add("test");
-    }
-
-
-    @Test
-    public void shouldDetectWhenOverloadedMethodCalled() throws Exception {
-        IMethods mockThree = mock(IMethods.class);
-
-        mockThree.varargs((Object[]) new Object[] {});
-        try {
-            verify(mockThree).varargs((String[]) new String[] {});
-            fail();
-        } catch(WantedButNotInvoked e) {}
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/CustomVerificationTest.java b/src/test/java/org/mockitousage/verification/CustomVerificationTest.java
deleted file mode 100644
index 519f4648f0..0000000000
--- a/src/test/java/org/mockitousage/verification/CustomVerificationTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.invocation.Invocation;
-import org.mockito.verification.VerificationMode;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class CustomVerificationTest extends TestBase {
-
-    @Mock IMethods mock;
-
-    @Test
-    public void custom_verification_with_old_api() {
-        //given:
-        mock.simpleMethod("a", 10);
-
-        //expect:
-        verify(mock, ignoreParametersUsingOldApi()).simpleMethod();
-
-        try {
-            verify(mock, ignoreParametersUsingOldApi()).otherMethod();
-            fail();
-        } catch (MockitoAssertionError e) {}
-    }
-
-    //Old api still supported, see https://github.com/mockito/mockito/issues/730
-    private VerificationMode ignoreParametersUsingOldApi() {
-        return new VerificationMode() {
-            public void verify(VerificationData data) {
-                //use old api
-                InvocationMatcher target = data.getWanted();
-
-                //sanity check the new api
-                if (data.getTarget() != target) {
-                    throw new RuntimeException("Sanity check");
-                }
-
-                //look for the relevant invocation and exit if found
-                for (Invocation invocation : data.getAllInvocations()) {
-                    if (target.getInvocation().getMethod().getName().equals(invocation.getMethod().getName())) {
-                        return;
-                    }
-                }
-
-                //verification failed!
-                throw new MockitoAssertionError("Expected method with name: " + target + " not found in:\n" + data.getAllInvocations());
-            }
-            public VerificationMode description(String description) {
-                return this;
-            }
-        };
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
deleted file mode 100644
index cdad5ed98b..0000000000
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class DescriptiveMessagesOnVerificationInOrderErrorsTest extends TestBase {
-
-    private IMethods one;
-    private IMethods two;
-    private IMethods three;
-    private InOrder inOrder;
-
-    @Before
-    public void setup() {
-        one = Mockito.mock(IMethods.class);
-        two = Mockito.mock(IMethods.class);
-        three = Mockito.mock(IMethods.class);
-
-        one.simpleMethod(1);
-        one.simpleMethod(11);
-        two.simpleMethod(2);
-        two.simpleMethod(2);
-        three.simpleMethod(3);
-
-        inOrder = inOrder(one, two, three);
-    }
-
-    @Test
-    public void shouldPrintVerificationInOrderErrorAndShowBothWantedAndPrevious() {
-        inOrder.verify(one).simpleMethod(1);
-        inOrder.verify(two, atLeastOnce()).simpleMethod(2);
-
-        try {
-            inOrder.verify(one, atLeastOnce()).simpleMethod(11);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-            String expected =
-                    "\n" +
-                    "Verification in order failure" +
-                    "\n" +
-                    "Wanted but not invoked:" +
-                    "\n" +
-                    "iMethods.simpleMethod(11);" +
-                    "\n" +
-                    "-> at ";
-
-            assertThat(e).hasMessageContaining(expected);
-
-            String expectedCause =
-                "\n" +
-                "Wanted anywhere AFTER following interaction:" +
-                "\n" +
-                "iMethods.simpleMethod(2);" +
-                "\n" +
-                "-> at ";
-
-            assertThat(e).hasMessageContaining(expectedCause);
-        }
-    }
-
-    @Test
-    public void shouldPrintVerificationInOrderErrorAndShowWantedOnly() {
-        try {
-            inOrder.verify(one).differentMethod();
-            fail();
-        } catch (WantedButNotInvoked e) {
-            String expected =
-                    "\n" +
-                    "Wanted but not invoked:" +
-                    "\n" +
-                    "iMethods.differentMethod();" +
-                    "\n" +
-                    "-> at";
-
-            assertThat(e).hasMessageContaining(expected);
-        }
-    }
-
-    @Test
-    public void shouldPrintVerificationInOrderErrorAndShowWantedAndActual() {
-        try {
-            inOrder.verify(one).simpleMethod(999);
-            fail();
-        } catch (org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent e) {
-            assertThat(e).hasMessageContaining("have different arguments");
-        }
-    }
-
-    @Test
-    public void shouldNotSayArgumentsAreDifferent() {
-        //this is the last invocation so any next verification in order should simply say wanted but not invoked
-        inOrder.verify(three).simpleMethod(3);
-        try {
-            inOrder.verify(one).simpleMethod(999);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-            assertThat(e).hasMessageContaining("Wanted but not invoked");
-        }
-    }
-
-    @Test
-    public void shouldPrintMethodThatWasNotInvoked() {
-        inOrder.verify(one).simpleMethod(1);
-        inOrder.verify(one).simpleMethod(11);
-        inOrder.verify(two, times(2)).simpleMethod(2);
-        inOrder.verify(three).simpleMethod(3);
-        try {
-            inOrder.verify(three).simpleMethod(999);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-            String expectedMessage =
-                    "\n" +
-                    "Verification in order failure" +
-                    "\n" +
-                    "Wanted but not invoked:" +
-                    "\n" +
-                    "iMethods.simpleMethod(999);";
-            assertThat(e).hasMessageContaining(expectedMessage);
-        }
-    }
-
-    @Test
-    public void shouldPrintTooManyInvocations() {
-        inOrder.verify(one).simpleMethod(1);
-        inOrder.verify(one).simpleMethod(11);
-        try {
-            inOrder.verify(two, times(1)).simpleMethod(2);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-            String expectedMessage =
-                    "\n" +
-                    "Verification in order failure:" +
-                    "\n" +
-                    "iMethods.simpleMethod(2);" +
-                    "\n" +
-                    "Wanted 1 time:" +
-                    "\n" +
-                    "-> at";
-            assertThat(e).hasMessageContaining(expectedMessage);
-
-            String expectedCause =
-                "\n" +
-                "But was 2 times:" +
-                "\n" +
-                "-> at";
-            assertThat(e).hasMessageContaining(expectedCause);
-        }
-    }
-
-    @Test
-    public void shouldPrintTooFewInvocations() {
-        two.simpleMethod(2);
-
-        inOrder.verify(one, atLeastOnce()).simpleMethod(anyInt());
-        inOrder.verify(two, times(2)).simpleMethod(2);
-        inOrder.verify(three, atLeastOnce()).simpleMethod(3);
-
-        try {
-            inOrder.verify(two, times(2)).simpleMethod(2);
-            fail();
-        } catch (VerificationInOrderFailure e) {
-            String expectedMessage =
-                    "\n" +
-                    "Verification in order failure:" +
-                    "\n" +
-                    "iMethods.simpleMethod(2);" +
-                    "\n" +
-                    "Wanted 2 times:" +
-                    "\n" +
-                    "-> at";
-            assertThat(e).hasMessageContaining(expectedMessage);
-
-            String expectedCause =
-                "\n" +
-                "But was 1 time:" +
-                "\n" +
-                "-> at";
-
-            assertThat(e).hasMessageContaining(expectedCause);
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
deleted file mode 100644
index 7452d0e627..0000000000
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
+++ /dev/null
@@ -1,456 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.AdditionalMatchers.aryEq;
-import static org.mockito.Mockito.*;
-
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.NeverWantedButInvoked;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class DescriptiveMessagesWhenVerificationFailsTest extends TestBase {
-
-    private IMethods mock;
-
-    @Before
-    public void setup() {
-        mock = Mockito.mock(IMethods.class, "iMethods");
-    }
-
-    @Test
-    public void should_print_method_name() {
-        try {
-            verify(mock).simpleMethod();
-            fail();
-        } catch (WantedButNotInvoked e) {
-            String expectedMessage =
-                    "\n" +
-                    "Wanted but not invoked:" +
-                    "\n" +
-                    "iMethods.simpleMethod();" +
-                    "\n" +
-                    "-> at";
-            assertThat(e).hasMessageContaining(expectedMessage);
-        }
-    }
-
-    private class Foo {
-        public String toString() {
-            return "foo";
-        }
-    }
-
-    @Test
-    public void should_print_method_name_and_arguments() {
-        try {
-            verify(mock).threeArgumentMethod(12, new Foo(), "xx");
-            fail();
-        } catch (WantedButNotInvoked e) {
-            assertThat(e).hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")");
-        }
-    }
-
-    @Test
-    public void should_print_actual_and_wanted_in_line() {
-        mock.varargs(1, 2);
-
-        try {
-            verify(mock).varargs(1, 1000);
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            String wanted =
-                    "\n" +
-                    "Argument(s) are different! Wanted:" +
-                    "\n" +
-                    "iMethods.varargs(1, 1000);";
-
-            assertThat(e).hasMessageContaining(wanted);
-
-            String actual =
-                    "\n" +
-                    "Actual invocations have different arguments:" +
-                    "\n" +
-                    "iMethods.varargs(1, 2);";
-
-            assertThat(e).hasMessageContaining(actual);
-        }
-    }
-
-    @Test
-    public void should_print_actual_and_wanted_in_multiple_lines() {
-        mock.varargs("this is very long string", "this is another very long string");
-
-        try {
-            verify(mock).varargs("x", "y", "z");
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            String wanted =
-                    "\n" +
-                    "Argument(s) are different! Wanted:" +
-                    "\n" +
-                    "iMethods.varargs(" +
-                    "\n" +
-                    "    \"x\"," +
-                    "\n" +
-                    "    \"y\"," +
-                    "\n" +
-                    "    \"z\"" +
-                    "\n" +
-                    ");";
-
-            assertThat(e).hasMessageContaining(wanted);
-
-            String actual =
-                    "\n" +
-                    "Actual invocations have different arguments:" +
-                    "\n" +
-                    "iMethods.varargs(" +
-                    "\n" +
-                    "    \"this is very long string\"," +
-                    "\n" +
-                    "    \"this is another very long string\"" +
-                    "\n" +
-                    ");";
-
-            assertThat(e).hasMessageContaining(actual);
-        }
-    }
-
-    @Test
-    public void should_print_actual_and_wanted_when_actual_method_name_and_wanted_method_name_are_the_same() {
-        mock.simpleMethod();
-
-        try {
-            verify(mock).simpleMethod(10);
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e).hasMessageContaining("simpleMethod(10)").hasMessageContaining("simpleMethod()");
-        }
-    }
-
-    @Test
-    public void should_print_actual_and_unverified_wanted_when_the_difference_is_about_arguments() {
-        mock.twoArgumentMethod(1, 1);
-        mock.twoArgumentMethod(2, 2);
-
-        verify(mock).twoArgumentMethod(1, 1);
-        try {
-            verify(mock).twoArgumentMethod(2, 1000);
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e).hasMessageContaining("(2, 1000)").hasMessageContaining("(2, 2)");
-        }
-    }
-
-    @Test
-    public void should_print_first_unexpected_invocation() {
-        mock.oneArg(true);
-        mock.oneArg(false);
-        mock.threeArgumentMethod(1, "2", "3");
-
-        verify(mock).oneArg(true);
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            String expectedMessage =
-                    "\n" +
-                    "No interactions wanted here:" +
-                    "\n" +
-                    "-> at";
-            assertThat(e).hasMessageContaining(expectedMessage);
-
-            String expectedCause =
-                    "\n" +
-                    "But found this interaction on mock '" + mock + "':" +
-                    "\n" +
-                    "-> at";
-            assertThat(e).hasMessageContaining(expectedCause);
-        }
-    }
-
-    @Test
-    public void should_print_first_unexpected_invocation_when_verifying_zero_interactions() {
-        mock.twoArgumentMethod(1, 2);
-        mock.threeArgumentMethod(1, "2", "3");
-
-        try {
-            verifyZeroInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            String expected =
-                    "\n" +
-                    "No interactions wanted here:" +
-                    "\n" +
-                    "-> at";
-
-            assertThat(e).hasMessageContaining(expected);
-
-            String expectedCause =
-                "\n" +
-                "But found this interaction on mock '" + mock + "':" +
-                "\n" +
-                "-> at";
-
-            assertThat(e).hasMessageContaining(expectedCause);
-        }
-    }
-
-    @Test
-    public void should_print_first_unexpected_invocation_when_verifying_no_interactions() {
-        mock.twoArgumentMethod(1, 2);
-        mock.threeArgumentMethod(1, "2", "3");
-
-        try {
-            verifyNoInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            String expected =
-                "\n" +
-                    "No interactions wanted here:" +
-                    "\n" +
-                    "-> at";
-
-            assertThat(e).hasMessageContaining(expected);
-
-            String expectedCause =
-                "\n" +
-                    "But found these interactions on mock '" + mock + "':" +
-                    "\n" +
-                    "-> at";
-
-            assertThat(e).hasMessageContaining(expectedCause);
-        }
-    }
-
-    @Test
-    public void should_print_method_name_when_verifying_at_least_once() throws Exception {
-        try {
-            verify(mock, atLeastOnce()).twoArgumentMethod(1, 2);
-            fail();
-        } catch (WantedButNotInvoked e) {
-            assertThat(e).hasMessageContaining("twoArgumentMethod(1, 2)");
-        }
-    }
-
-    @Test
-    public void should_print_method_when_matcher_used() throws Exception {
-        try {
-            verify(mock, atLeastOnce()).twoArgumentMethod(anyInt(), eq(100));
-            fail();
-        } catch (WantedButNotInvoked e) {
-            String expectedMessage =
-                "\n" +
-                "Wanted but not invoked:" +
-                "\n" +
-                "iMethods.twoArgumentMethod(\n" +
-                "    <any integer>,\n" +
-                "    100\n" +
-                ");";
-            assertThat(e).hasMessageContaining(expectedMessage);
-        }
-    }
-
-    @Test
-    public void should_print_method_when_missing_invocation_with_array_matcher() {
-        mock.oneArray(new boolean[] { true, false, false });
-
-        try {
-            verify(mock).oneArray(aryEq(new boolean[] { false, false, false }));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e)
-                .hasMessageContaining("[false, false, false]")
-                .hasMessageContaining("[true, false, false]");
-        }
-    }
-
-    @Test
-    public void should_print_method_when_missing_invocation_with_vararg_matcher() {
-        mock.varargsString(10, "xxx", "yyy", "zzz");
-
-        try {
-            verify(mock).varargsString(10, "111", "222", "333");
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e)
-                .hasMessageContaining("111")
-                .hasMessageContaining("\"xxx\"");
-        }
-    }
-
-    @Test
-    public void should_print_method_when_missing_invocation_with_matcher() {
-        mock.simpleMethod("foo");
-
-        try {
-            verify(mock).simpleMethod(matches("burrito from Exmouth"));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e)
-                .hasMessageContaining("matches(\"burrito from Exmouth\")")
-                .hasMessageContaining("\"foo\"");
-        }
-    }
-
-    @Test
-    public void should_print_null_arguments() throws Exception {
-        mock.simpleMethod(null, (Integer) null);
-        try {
-            verify(mock).simpleMethod("test");
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e).hasMessageContaining("simpleMethod(null, null);");
-        }
-    }
-
-    @Test
-    public void should_say_never_wanted_but_invoked() throws Exception {
-        mock.simpleMethod(1);
-
-        verify(mock, never()).simpleMethod(2);
-        try {
-            verify(mock, never()).simpleMethod(1);
-            fail();
-        } catch (NeverWantedButInvoked e) {
-            assertThat(e)
-                .hasMessageContaining("Never wanted here:")
-                .hasMessageContaining("But invoked here:");
-        }
-    }
-
-    @Test
-    public void should_show_right_actual_method() throws Exception {
-        mock.simpleMethod(9191);
-        mock.simpleMethod("foo");
-
-        try {
-            verify(mock).simpleMethod("bar");
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e)
-                .hasMessageContaining("bar")
-                .hasMessageContaining("foo");
-        }
-    }
-
-    @Mock private IMethods iHavefunkyName;
-
-    @Test
-    public void should_print_field_name_when_annotations_used() throws Exception {
-        iHavefunkyName.simpleMethod(10);
-
-        try {
-            verify(iHavefunkyName).simpleMethod(20);
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            assertThat(e)
-                .hasMessageContaining("iHavefunkyName.simpleMethod(20)")
-                .hasMessageContaining("iHavefunkyName.simpleMethod(10)");
-        }
-    }
-
-    @Test
-    public void should_print_interactions_on_mock_when_ordinary_verification_fail() throws Exception {
-        mock.otherMethod();
-        mock.booleanReturningMethod();
-
-        try {
-            verify(mock).simpleMethod();
-            fail();
-        } catch (WantedButNotInvoked e) {
-//            assertContains("")
-        }
-    }
-
-    @Mock private IMethods veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock;
-
-    @Test
-    public void should_never_break_method_string_when_no_args_in_method() throws Exception {
-        try {
-            verify(veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock).simpleMethod();
-            fail();
-        } catch(WantedButNotInvoked e) {
-            assertThat(e).hasMessageContaining("veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock.simpleMethod()");
-        }
-    }
-
-    @Test
-    public void should_print_method_name_and_arguments_of_other_interactions_with_different_methods() throws Exception {
-        try {
-            mock.arrayMethod(new String[] {"a", "b", "c"});
-            mock.forByte((byte) 25);
-
-            verify(mock).threeArgumentMethod(12, new Foo(), "xx");
-            fail();
-        } catch (WantedButNotInvoked e) {
-            assertThat(e)
-                .hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")")
-                .hasMessageContaining("iMethods.arrayMethod([\"a\", \"b\", \"c\"])")
-                .hasMessageContaining("iMethods.forByte((byte) 0x19)");
-        }
-    }
-
-    @Test
-    @Ignore("issue 380 related")
-    public void should_print_method_name_and_arguments_of_other_interactions_of_same_method() throws Exception {
-        try {
-            mock.forByte((byte) 25);
-            mock.forByte((byte) 12);
-
-            verify(mock).forByte((byte) 42);
-            fail();
-        } catch (WantedButNotInvoked e) {
-            assertThat(e)
-                .hasMessageContaining("iMethods.forByte(42)")
-                .hasMessageContaining("iMethods.forByte(25)")
-                .hasMessageContaining("iMethods.forByte(12)");
-        }
-    }
-
-    @Test
-    @Ignore("issue 380 related")
-    public void test1() {
-        AnInterface m = Mockito.mock(AnInterface.class);
-
-        for (int i = 1; i <= 2; i++) {
-            m.foo(i);
-        }
-
-        verify(m).foo(1);
-        verify(m).foo(2);
-        verify(m).foo(3); // XXX: doesn't mention the parameters of foo(1) and foo(2)
-        verify(m).foo(4);
-    }
-
-    @Test
-    @Ignore("issue 380 related")
-    public void test2() {
-        AnInterface m = Mockito.mock(AnInterface.class);
-
-        for (int i = 1; i <= 4; i++) {
-            m.foo(i);
-        }
-
-        verify(m).foo(1);
-        verify(m).foo(2);
-        verify(m).foo(5); // XXX: doesn't mention foo(4) at all
-    }
-
-    public interface AnInterface {
-        void foo(int i);
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java b/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
deleted file mode 100644
index 841387d789..0000000000
--- a/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class NoMoreInteractionsVerificationTest extends TestBase {
-
-    private LinkedList mock;
-
-    @Before
-    public void setup() {
-        mock = mock(LinkedList.class);
-    }
-
-    @Test
-    public void shouldStubbingNotRegisterRedundantInteractions() throws Exception {
-        when(mock.add("one")).thenReturn(true);
-        when(mock.add("two")).thenReturn(true);
-
-        mock.add("one");
-
-        verify(mock).add("one");
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test
-    public void shouldVerifyWhenWantedNumberOfInvocationsUsed() throws Exception {
-        mock.add("one");
-        mock.add("one");
-        mock.add("one");
-
-        verify(mock, times(3)).add("one");
-
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test
-    public void shouldVerifyNoInteractionsAsManyTimesAsYouWant() throws Exception {
-        verifyNoMoreInteractions(mock);
-        verifyNoMoreInteractions(mock);
-
-        verifyZeroInteractions(mock);
-        verifyZeroInteractions(mock);
-
-        verifyNoInteractions(mock);
-        verifyNoInteractions(mock);
-    }
-
-    @Test
-    public void shouldFailZeroInteractionsVerification() throws Exception {
-        mock.clear();
-
-        try {
-            verifyZeroInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldFailNoMoreInteractionsVerification() throws Exception {
-        mock.clear();
-
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldFailNoInteractionsVerification() throws Exception {
-        mock.clear();
-
-        try {
-            verifyNoInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldPrintAllInvocationsWhenVerifyingNoMoreInvocations() throws Exception {
-        mock.add(1);
-        mock.add(2);
-        mock.clear();
-
-        verify(mock).add(2);
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            assertThat(e).hasMessageContaining("list of all invocations");
-        }
-    }
-
-    @Test
-    public void shouldNotContainAllInvocationsWhenSingleUnwantedFound() throws Exception {
-        mock.add(1);
-
-        try {
-            verifyNoMoreInteractions(mock);
-            fail();
-        } catch (NoInteractionsWanted e) {
-            assertThat(e.getMessage()).doesNotContain("list of all invocations");
-        }
-    }
-
-    @Test
-    public void shouldVerifyOneMockButFailOnOther() throws Exception {
-        List<String> list = mock(List.class);
-        Map<String, Integer> map = mock(Map.class);
-
-        list.add("one");
-        list.add("one");
-
-        map.put("one", 1);
-
-        verify(list, times(2)).add("one");
-
-        verifyNoMoreInteractions(list);
-        try {
-            verifyZeroInteractions(map);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldVerifyOneMockButFailOnOtherVerifyNoInteractions() throws Exception {
-        List<String> list = mock(List.class);
-        Map<String, Integer> map = mock(Map.class);
-
-        list.add("one");
-        list.add("one");
-
-        map.put("one", 1);
-
-        verify(list, times(2)).add("one");
-
-        verifyNoMoreInteractions(list);
-        try {
-            verifyNoInteractions(map);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @SuppressWarnings("all")
-    @Test(expected=MockitoException.class)
-    public void verifyNoMoreInteractionsShouldScreamWhenNullPassed() throws Exception {
-        verifyNoMoreInteractions((Object[])null);
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java b/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java
deleted file mode 100644
index 47c409109e..0000000000
--- a/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class PrintingVerboseTypesWithArgumentsTest extends TestBase {
-
-    class Boo {
-        public void withLong(long x) {
-        }
-
-        public void withLongAndInt(long x, int y) {
-        }
-    }
-
-    @Test
-    public void should_not_report_argument_types_when_to_string_is_the_same() {
-        //given
-        Boo boo = mock(Boo.class);
-        boo.withLong(100);
-
-        try {
-            //when
-            verify(boo).withLong(eq(100));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            //then
-            assertThat(e)
-                .hasMessageContaining("withLong((Integer) 100);")
-                .hasMessageContaining("withLong((Long) 100L);");
-        }
-    }
-
-    @Test
-    public void should_show_the_type_of_only_the_argument_that_doesnt_match() {
-        //given
-        Boo boo = mock(Boo.class);
-        boo.withLongAndInt(100, 200);
-
-        try {
-            //when
-            verify(boo).withLongAndInt(eq(100), eq(200));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            //then
-            assertThat(e)
-                .hasMessageContaining("withLongAndInt((Integer) 100, 200)")
-                .hasMessageContaining("withLongAndInt((Long) 100L, 200)");
-        }
-    }
-
-    @Test
-    public void should_show_the_type_of_the_mismatching_argument_when_output_descriptions_for_invocations_are_different() {
-        //given
-        Boo boo = mock(Boo.class);
-        boo.withLongAndInt(100, 200);
-
-        try {
-            //when
-            verify(boo).withLongAndInt(eq(100), any(Integer.class));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            //then
-            Assertions.assertThat(e.getMessage())
-                      .contains("withLongAndInt(\n" +
-                                        "    (Long) 100L,\n" +
-                                        "    200\n" +
-                                        ")")
-                      .contains("withLongAndInt(\n" +
-                                        "    (Integer) 100,\n" +
-                                        "    <any java.lang.Integer>\n" +
-                                        ")");
-        }
-    }
-
-    @Test
-    public void should_not_show_types_when_argument_value_is_different() {
-        //given
-        Boo boo = mock(Boo.class);
-        boo.withLongAndInt(100, 200);
-
-        try {
-            //when
-            verify(boo).withLongAndInt(eq(100L), eq(230));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            //then
-            assertThat(e)
-                .hasMessageContaining("withLongAndInt(100L, 200)")
-                .hasMessageContaining("withLongAndInt(100L, 230)");
-        }
-    }
-
-    class Foo {
-
-        private final int x;
-
-        public Foo(int x) {
-            this.x = x;
-        }
-
-        public boolean equals(Object obj) {
-            return x == ((Foo) obj).x;
-        }
-
-        public int hashCode() {
-            return 1;
-        }
-
-        public String toString() {
-            return "foo";
-        }
-    }
-
-    @Test
-    public void should_not_show_types_when_types_are_the_same_even_if_to_string_gives_the_same_result() {
-        //given
-        IMethods mock = mock(IMethods.class);
-        mock.simpleMethod(new Foo(10));
-
-        try {
-            //when
-            verify(mock).simpleMethod(new Foo(20));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-            //then
-            assertThat(e).hasMessageContaining("simpleMethod(foo)");
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/RelaxedVerificationInOrderTest.java b/src/test/java/org/mockitousage/verification/RelaxedVerificationInOrderTest.java
deleted file mode 100644
index c4744cfaf9..0000000000
--- a/src/test/java/org/mockitousage/verification/RelaxedVerificationInOrderTest.java
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.exceptions.verification.NeverWantedButInvoked;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-/**
- * ignored since 'relaxed' in order verification is not implemented (too complex to bother, maybe later).
- */
-public class RelaxedVerificationInOrderTest extends TestBase {
-
-    private IMethods mockOne;
-    private IMethods mockTwo;
-    private IMethods mockThree;
-    private InOrder inOrder;
-
-    @Before
-    public void setUp() {
-        mockOne = mock(IMethods.class);
-        mockTwo = mock(IMethods.class);
-        mockThree = mock(IMethods.class);
-
-        inOrder = inOrder(mockOne, mockTwo, mockThree);
-
-        mockOne.simpleMethod(1);
-        mockTwo.simpleMethod(2);
-        mockTwo.simpleMethod(2);
-        mockThree.simpleMethod(3);
-        mockTwo.simpleMethod(2);
-        mockOne.simpleMethod(4);
-    }
-
-    @Test
-    public void shouldVerifyInOrderAllInvocations() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldVerifyInOrderAndBeRelaxed() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-
-        verifyNoMoreInteractions(mockThree);
-    }
-
-    @Test
-    public void shouldAllowFirstChunkBeforeLastInvocation() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-
-        try {
-            verifyNoMoreInteractions(mockTwo);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldAllowAllChunksBeforeLastInvocation() {
-        inOrder.verify(mockTwo, times(3)).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-
-        verifyNoMoreInteractions(mockTwo);
-    }
-
-    @Test
-    public void shouldVerifyDetectFirstChunkOfInvocationThatExistInManyChunks() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        try {
-            verifyNoMoreInteractions(mockTwo);
-            fail();
-        } catch(NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldVerifyDetectAllChunksOfInvocationThatExistInManyChunks() {
-        inOrder.verify(mockTwo, times(3)).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-        verifyNoMoreInteractions(mockTwo);
-    }
-
-    @Test
-    public void shouldVerifyInteractionsFromAllChunksWhenAtLeastOnceMode() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        verifyNoMoreInteractions(mockTwo);
-        try {
-            inOrder.verify(mockThree).simpleMethod(3);
-            fail();
-        } catch (VerificationInOrderFailure e) {}
-    }
-
-    @Test
-    public void shouldVerifyInteractionsFromFirstChunk() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        try {
-            verifyNoMoreInteractions(mockTwo);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test(expected=VerificationInOrderFailure.class)
-    public void shouldFailVerificationOfNonFirstChunk() {
-        inOrder.verify(mockTwo, times(1)).simpleMethod(2);
-    }
-
-    @Test
-    public void shouldPassOnCombinationOfTimesAndAtLeastOnce() {
-        mockTwo.simpleMethod(2);
-
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        verifyNoMoreInteractions(mockTwo);
-    }
-
-    @Test
-    public void shouldPassOnEdgyCombinationOfTimesAndAtLeastOnce() {
-        mockTwo.simpleMethod(2);
-        mockThree.simpleMethod(3);
-
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-
-        verifyNoMoreInteractions(mockThree);
-    }
-
-    @Test
-    public void shouldVerifyInOrderMockTwoAndThree() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        verifyNoMoreInteractions(mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldVerifyInOrderMockOneAndThree() {
-        inOrder.verify(mockOne).simpleMethod(1);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockOne).simpleMethod(4);
-        verifyNoMoreInteractions(mockOne, mockThree);
-    }
-
-    @Test
-    public void shouldVerifyInOrderOnlyTwoInvocations() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-    }
-
-    @Test
-    public void shouldVerifyInOrderOnlyMockTwo() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        inOrder.verify(mockTwo).simpleMethod(2);
-        verifyNoMoreInteractions(mockTwo);
-    }
-
-    @Test
-    public void shouldVerifyMockTwoCalledTwice() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-    }
-
-    @Test
-    public void shouldVerifyMockTwoCalledAtLeastOnce() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-    }
-
-    @Test(expected=WantedButNotInvoked.class)
-    public void shouldFailOnWrongMethodCalledOnMockTwo() {
-        inOrder.verify(mockTwo, atLeastOnce()).differentMethod();
-    }
-
-    @Test
-    public void shouldAllowTimesZeroButOnlyInOrder() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        inOrder.verify(mockOne, times(0)).simpleMethod(1);
-
-        try {
-            verify(mockOne, times(0)).simpleMethod(1);
-            fail();
-        } catch (NeverWantedButInvoked e) {}
-    }
-
-    @Test
-    public void shouldFailTimesZeroInOrder() {
-        inOrder.verify(mockTwo, times(2)).simpleMethod(2);
-        try {
-            inOrder.verify(mockThree, times(0)).simpleMethod(3);
-            fail();
-        } catch (VerificationInOrderFailure e) {}
-    }
-
-    @Test(expected=VerificationInOrderFailure.class)
-    public void shouldFailWhenMockTwoWantedZeroTimes() {
-        inOrder.verify(mockTwo, times(0)).simpleMethod(2);
-    }
-
-    @Test
-    public void shouldVerifyLastInvocation() {
-        inOrder.verify(mockOne).simpleMethod(4);
-    }
-
-    @Test
-    public void shouldVerifySecondAndLastInvocation() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-    }
-
-    @Test
-    public void shouldVerifySecondAndLastInvocationWhenAtLeastOnceUsed() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-        inOrder.verify(mockOne).simpleMethod(4);
-    }
-
-    @Test
-    public void shouldFailOnLastTwoInvocationsInWrongOrder() {
-        inOrder.verify(mockOne).simpleMethod(4);
-        try {
-            inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
-            fail();
-        } catch (VerificationInOrderFailure e) {}
-    }
-
-    @Test
-    public void shouldFailOnLastAndFirstInWrongOrder() {
-        inOrder.verify(mockOne).simpleMethod(4);
-        try {
-            inOrder.verify(mockOne).simpleMethod(1);
-            fail();
-        } catch (VerificationInOrderFailure e) {}
-    }
-
-    @Test
-    public void shouldFailOnWrongMethodAfterLastInvocation() {
-        inOrder.verify(mockOne).simpleMethod(4);
-        try {
-            inOrder.verify(mockOne).simpleMethod(999);
-            fail();
-        } catch (VerificationInOrderFailure e) {}
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationExcludingStubsTest.java b/src/test/java/org/mockitousage/verification/VerificationExcludingStubsTest.java
deleted file mode 100644
index 75270ff537..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationExcludingStubsTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-@SuppressWarnings("unchecked")
-public class VerificationExcludingStubsTest extends TestBase {
-
-    @Mock IMethods mock;
-
-    @Test
-    public void shouldAllowToExcludeStubsForVerification() throws Exception {
-        //given
-        when(mock.simpleMethod()).thenReturn("foo");
-
-        //when
-        String stubbed = mock.simpleMethod(); //irrelevant call because it is stubbing
-        mock.objectArgMethod(stubbed);
-
-        //then
-        verify(mock).objectArgMethod("foo");
-
-        //verifyNoMoreInteractions fails:
-        try { verifyNoMoreInteractions(mock); fail(); } catch (NoInteractionsWanted e) {}
-
-        //but it works when stubs are ignored:
-        ignoreStubs(mock);
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test
-    public void shouldExcludeFromVerificationInOrder() throws Exception {
-        //given
-        when(mock.simpleMethod()).thenReturn("foo");
-
-        //when
-        mock.objectArgMethod("1");
-        mock.objectArgMethod("2");
-        mock.simpleMethod(); //calling the stub
-
-        //then
-        InOrder inOrder = inOrder(ignoreStubs(mock));
-        inOrder.verify(mock).objectArgMethod("1");
-        inOrder.verify(mock).objectArgMethod("2");
-        inOrder.verifyNoMoreInteractions();
-        verifyNoMoreInteractions(mock);
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void shouldIgnoringStubsDetectNulls() throws Exception {
-        ignoreStubs(mock, null);
-    }
-
-    @Test(expected = NotAMockException.class)
-    public void shouldIgnoringStubsDetectNonMocks() throws Exception {
-        ignoreStubs(mock, new Object());
-    }
-
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationInOrderMixedWithOrdiraryVerificationTest.java b/src/test/java/org/mockitousage/verification/VerificationInOrderMixedWithOrdiraryVerificationTest.java
deleted file mode 100644
index dd11f92172..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationInOrderMixedWithOrdiraryVerificationTest.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class VerificationInOrderMixedWithOrdiraryVerificationTest extends TestBase {
-
-    private IMethods mockOne;
-    private IMethods mockTwo;
-    private IMethods mockThree;
-    private InOrder inOrder;
-
-    @Before
-    public void setUp() {
-        mockOne = mock(IMethods.class);
-        mockTwo = mock(IMethods.class);
-        mockThree = mock(IMethods.class);
-
-        mockOne.simpleMethod(1);
-        mockOne.simpleMethod(1);
-        mockTwo.simpleMethod(2);
-        mockThree.simpleMethod(3);
-        mockThree.simpleMethod(4);
-
-        inOrder = inOrder(mockOne, mockThree);
-    }
-
-    @Test
-    public void shouldMixVerificationInOrderAndOrdinaryVerification() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockThree).simpleMethod(4);
-        verify(mockTwo).simpleMethod(2);
-
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldAllowOrdinarilyVerifyingMockPassedToInOrderObject() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-
-        verify(mockThree).simpleMethod(3);
-        verify(mockThree).simpleMethod(4);
-        verify(mockTwo).simpleMethod(2);
-
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldAllowRedundantVerifications() {
-        verify(mockOne, atLeastOnce()).simpleMethod(1);
-        verify(mockTwo).simpleMethod(2);
-        verify(mockThree).simpleMethod(3);
-        verify(mockThree).simpleMethod(4);
-
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockThree).simpleMethod(4);
-
-        verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-    }
-
-    @Test
-    public void shouldFailOnNoMoreInteractions() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockThree).simpleMethod(3);
-        inOrder.verify(mockThree).simpleMethod(4);
-
-        try {
-            verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldFailOnNoMoreInteractionsOnMockVerifiedInOrder() {
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-        inOrder.verify(mockThree).simpleMethod(3);
-        verify(mockTwo).simpleMethod(2);
-
-        try {
-            verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
-            fail();
-        } catch (NoInteractionsWanted e) {}
-    }
-
-    @Test
-    public void shouldAllowOneMethodVerifiedInOrder() {
-        verify(mockTwo).simpleMethod(2);
-        verify(mockOne, atLeastOnce()).simpleMethod(1);
-
-        inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-    }
-
-    @Test
-    public void shouldFailOnLastInvocationTooEarly() {
-        inOrder.verify(mockThree).simpleMethod(4);
-
-        verify(mockThree).simpleMethod(4);
-        verify(mockTwo).simpleMethod(2);
-
-        try {
-            inOrder.verify(mockOne, atLeastOnce()).simpleMethod(1);
-            fail();
-        } catch (VerificationInOrderFailure e) {}
-    }
-
-    @Test(expected=MockitoException.class)
-    public void shouldScreamWhenUnfamiliarMockPassedToInOrderObject() {
-        inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(1);
-    }
-
-    @Test
-    public void shouldUseEqualsToVerifyMethodArguments() {
-        mockOne = mock(IMethods.class);
-
-        String textOne = "test";
-        String textTwo = new String(textOne);
-
-        assertEquals(textOne, textTwo);
-        assertNotSame(textOne, textTwo);
-
-        mockOne.simpleMethod(textOne);
-        mockOne.simpleMethod(textTwo);
-
-        verify(mockOne, times(2)).simpleMethod(textOne);
-
-        inOrder = inOrder(mockOne);
-        inOrder.verify(mockOne, times(2)).simpleMethod(textOne);
-    }
-
-    @Test
-    public void shouldUseEqualsToVerifyMethodVarargs() {
-        mockOne = mock(IMethods.class);
-
-        String textOne = "test";
-        String textTwo = new String(textOne);
-
-        assertEquals(textOne, textTwo);
-        assertNotSame(textOne, textTwo);
-
-        mockOne.varargsObject(1, textOne, textOne);
-        mockOne.varargsObject(1, textTwo, textTwo);
-
-        verify(mockOne, times(2)).varargsObject(1, textOne, textOne);
-
-        inOrder = inOrder(mockOne);
-        inOrder.verify(mockOne, times(2)).varargsObject(1, textOne, textOne);
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationInOrderWithCallsTest.java b/src/test/java/org/mockitousage/verification/VerificationInOrderWithCallsTest.java
deleted file mode 100644
index 0a92cd6e04..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationInOrderWithCallsTest.java
+++ /dev/null
@@ -1,497 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.mockito.Mockito.*;
-
-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.MockitoException;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class VerificationInOrderWithCallsTest extends TestBase {
-
-    @Mock private IMethods mockOne;
-    @Mock private IMethods mockTwo;
-    @Rule
-    public ExpectedException exceptionRule = ExpectedException.none();
-
-    @Test
-    public void shouldFailWhenMethodNotCalled(){
-        // Given
-        mockOne.oneArg( 1 );
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "Verification in order failure" );
-        exceptionRule.expectMessage( "Wanted but not invoked" );
-        exceptionRule.expectMessage( "mockOne.oneArg(2)" );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 2 );
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldFailWhenMethodCalledTooFewTimes(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "Verification in order failure" );
-        exceptionRule.expectMessage( "mockOne.oneArg(2)" );
-        exceptionRule.expectMessage( "Wanted 2 times" );
-        exceptionRule.expectMessage( "But was 1 time" );
-
-        // When
-        verifier.verify( mockOne, calls(2)).oneArg( 2 );
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldFailWhenSingleMethodCallsAreOutOfSequence(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 2 );
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "Verification in order failure" );
-        exceptionRule.expectMessage( "Wanted but not invoked" );
-        exceptionRule.expectMessage( "mockOne.oneArg(1)" );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldFailWhenDifferentMethodCallsAreOutOfSequence(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.voidMethod();
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "Verification in order failure" );
-        exceptionRule.expectMessage( "Wanted but not invoked" );
-        exceptionRule.expectMessage( "mockOne.oneArg(1)" );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldFailWhenMethodCallsOnDifferentMocksAreOutOfSequence(){
-        // Given
-        mockOne.voidMethod();
-        mockTwo.voidMethod();
-
-        InOrder verifier = inOrder( mockOne, mockTwo );
-        verifier.verify( mockTwo, calls(1)).voidMethod();
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "Verification in order failure" );
-        exceptionRule.expectMessage( "Wanted but not invoked" );
-        exceptionRule.expectMessage( "mockOne.voidMethod()" );
-
-        // When
-        verifier.verify( mockOne, calls(1)).voidMethod();
-
-        // Then - expected exception thrown
-    }
-
-
-    @Test
-    public void shouldAllowSequentialCallsToCallsForSingleMethod(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(2)).oneArg( 2 );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifyNoMoreInteractions(mockOne);
-        verifier.verifyNoMoreInteractions();
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldAllowSequentialCallsToCallsForDifferentMethods(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.voidMethod();
-        mockOne.voidMethod();
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(2)).voidMethod();
-        verifier.verify( mockOne, calls(1)).oneArg(1);
-        verifyNoMoreInteractions(mockOne);
-        verifier.verifyNoMoreInteractions();
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldAllowSequentialCallsToCallsForMethodsOnDifferentMocks(){
-        // Given
-        mockOne.voidMethod();
-        mockTwo.voidMethod();
-        mockTwo.voidMethod();
-        mockOne.voidMethod();
-
-        InOrder verifier = inOrder( mockOne, mockTwo );
-
-        // When
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockTwo, calls(2)).voidMethod();
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifyNoMoreInteractions(mockOne);
-        verifyNoMoreInteractions(mockTwo);
-        verifier.verifyNoMoreInteractions();
-
-        // Then - no exception thrown
-    }
-
-
-    @Test
-    public void shouldAllowFewerCallsForSingleMethod(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).oneArg( 2 );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).oneArg( 2 );
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldNotVerifySkippedCallsWhenFewerCallsForSingleMethod(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).oneArg( 2 );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        exceptionRule.expect( NoInteractionsWanted.class );
-
-        // When
-        verifyNoMoreInteractions( mockOne );
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForSingleMethod(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).oneArg( 2 );
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "No interactions wanted here" );
-
-        // When
-        verifier.verifyNoMoreInteractions();
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldAllowFewerCallsForDifferentMethods(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.voidMethod();
-        mockOne.voidMethod();
-        mockOne.oneArg( 1 );
-        mockOne.voidMethod();
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldNotVerifySkippedCallsWhenFewerCallsForDifferentMethods(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.voidMethod();
-        mockOne.voidMethod();
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        exceptionRule.expect( NoInteractionsWanted.class );
-
-        // When
-        verifyNoMoreInteractions( mockOne );
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForDifferentMethods(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.voidMethod();
-        mockOne.voidMethod();
-
-        InOrder verifier = inOrder( mockOne );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "No interactions wanted here" );
-
-        // When
-        verifier.verifyNoMoreInteractions();
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldAllowFewerCallsForMethodsOnDifferentMocks(){
-        // Given
-        mockOne.voidMethod();
-        mockTwo.voidMethod();
-        mockTwo.voidMethod();
-        mockOne.voidMethod();
-        mockTwo.voidMethod();
-
-        InOrder verifier = inOrder( mockOne, mockTwo );
-
-        // When
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockTwo, calls(1)).voidMethod();
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockTwo, calls(1)).voidMethod();
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldNotVerifySkippedCallsWhenFewerCallsForMethodsOnDifferentMocks(){
-        // Given
-        mockOne.voidMethod();
-        mockTwo.voidMethod();
-        mockTwo.voidMethod();
-        mockOne.voidMethod();
-
-        InOrder verifier = inOrder( mockOne, mockTwo );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockTwo, calls(1)).voidMethod();
-        verifier.verify( mockOne, calls(1)).voidMethod();
-
-        exceptionRule.expect(NoInteractionsWanted.class);
-
-        // When
-        verifyNoMoreInteractions( mockTwo );
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForMethodsOnDifferentMocks(){
-        // Given
-        mockOne.voidMethod();
-        mockTwo.voidMethod();
-        mockTwo.voidMethod();
-
-        InOrder verifier = inOrder( mockOne, mockTwo );
-        verifier.verify( mockOne, calls(1)).voidMethod();
-        verifier.verify( mockTwo, calls(1)).voidMethod();
-
-        exceptionRule.expect( VerificationInOrderFailure.class );
-        exceptionRule.expectMessage( "No interactions wanted here" );
-
-        // When
-        verifier.verifyNoMoreInteractions();
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldVerifyWithCallsAfterUseOfTimes(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, times(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(2)).oneArg( 2 );
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldVerifyWithCallsAfterUseOfAtLeast(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, atLeast(1)).oneArg( 1 );
-        verifier.verify( mockOne, calls(2)).oneArg( 2 );
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldVerifyWithTimesAfterUseOfCalls(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, times(2)).oneArg( 2 );
-        verifier.verify( mockOne, times(1)).oneArg( 1 );
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldVerifyWithAtLeastAfterUseOfCalls(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 2 );
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, atLeast(1)).oneArg( 2 );
-        verifier.verify( mockOne, atLeast(1)).oneArg( 1 );
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldVerifyWithTimesAfterCallsInSameChunk(){
-        // Given
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 1 );
-        mockOne.oneArg( 1 );
-
-        InOrder verifier = inOrder( mockOne );
-
-        // When
-        verifier.verify( mockOne, calls(1)).oneArg( 1 );
-        verifier.verify( mockOne, times(2)).oneArg( 1 );
-        verifier.verifyNoMoreInteractions();
-
-        // Then - no exception thrown
-    }
-
-    @Test
-    public void shouldFailToCreateCallsWithZeroArgument(){
-        // Given
-        InOrder verifier = inOrder( mockOne );
-        exceptionRule.expect( MockitoException.class );
-        exceptionRule.expectMessage( "Negative and zero values are not allowed here" );
-
-        // When
-        verifier.verify( mockOne, calls(0)).voidMethod();
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldFailToCreateCallsWithNegativeArgument(){
-        // Given
-        InOrder verifier = inOrder( mockOne );
-        exceptionRule.expect( MockitoException.class );
-        exceptionRule.expectMessage( "Negative and zero values are not allowed here" );
-
-        // When
-        verifier.verify( mockOne, calls(-1)).voidMethod();
-
-        // Then - expected exception thrown
-    }
-
-    @Test
-    public void shouldFailToCreateCallsForNonInOrderVerification(){
-        // Given
-        mockOne.voidMethod();
-        exceptionRule.expect( MockitoException.class );
-        exceptionRule.expectMessage( "calls is only intended to work with InOrder" );
-
-        // When
-        verify( mockOne, calls(1)).voidMethod();
-
-        // Then - expected exception thrown
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationInOrderWithTimeoutTest.java b/src/test/java/org/mockitousage/verification/VerificationInOrderWithTimeoutTest.java
deleted file mode 100644
index 1d29839b1e..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationInOrderWithTimeoutTest.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.mockito.Mockito.after;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.junit.MockitoJUnit.rule;
-
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.VerificationInOrderFailure;
-import org.mockito.junit.MockitoRule;
-import org.mockitousage.IMethods;
-import org.mockitoutil.async.AsyncTesting;
-
-public class VerificationInOrderWithTimeoutTest {
-
-    @Rule public MockitoRule mockito = rule();
-
-    @Mock private IMethods mock1;
-    @Mock private IMethods mock2;
-
-    private AsyncTesting async;
-
-    @Before public void setUp() {
-        async = new AsyncTesting();
-    }
-
-    @After public void tearDown() {
-        async.cleanUp();
-    }
-
-    @Test
-    public void should_not_allow_in_order_with_after() {
-        // expect
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                inOrder(mock1).verify(mock1, after(100)).oneArg('a');
-            }
-        }).isInstanceOf(MockitoException.class).hasMessageContaining("not implemented to work with InOrder");
-        //TODO specific exception
-    }
-
-    @Test
-    public void should_verify_in_order_with_timeout() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'c'));
-        async.runAfter(200, callMock(mock2, 'b'));
-
-        // then
-        InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock1, timeout(100)).oneArg('a');
-        inOrder.verify(mock2, timeout(500)).oneArg('b');
-    }
-
-    @Test
-    public void should_verify_in_order_with_timeout_and_fail() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(100, callMock(mock2, 'b'));
-
-        // then
-        final InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock2, timeout(300)).oneArg('b');
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                inOrder.verify(mock1, timeout(300)).oneArg('a');
-            }
-        }).isInstanceOf(VerificationInOrderFailure.class)
-            .hasMessageContaining("Wanted but not invoked:\nmock1.oneArg('a');")
-            .hasMessageContaining("Wanted anywhere AFTER following interaction:\nmock2.oneArg('b');");
-    }
-
-    @Test
-    public void should_verify_in_order_with_times_x() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'a'));
-        async.runAfter(200, callMock(mock2, 'b'));
-        async.runAfter(250, callMock(mock2, 'b'));
-
-        // then
-        InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock1, timeout(100).times(2)).oneArg('a');
-        inOrder.verify(mock2, timeout(500).times(2)).oneArg('b');
-    }
-
-    @Test
-    public void should_verify_in_order_with_times_x_and_fail() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'a'));
-        async.runAfter(200, callMock(mock2, 'b'));
-        async.runAfter(250, callMock(mock2, 'b'));
-
-        // then
-        final InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock2, timeout(500).times(2)).oneArg('b');
-
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                inOrder.verify(mock1, timeout(100).times(2)).oneArg('a');
-            }
-        }).isInstanceOf(VerificationInOrderFailure.class)
-            .hasMessageContaining("Wanted but not invoked:\nmock1.oneArg('a');")
-            .hasMessageContaining("Wanted anywhere AFTER following interaction:\nmock2.oneArg('b');");
-    }
-
-    @Test
-    public void should_not_allow_in_order_with_only() {
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            @Override
-            public void call() throws Throwable {
-                inOrder(mock1).verify(mock1, timeout(200).only()).oneArg('a');
-            }
-        }).isInstanceOf(MockitoException.class).hasMessageContaining("not implemented to work with InOrder");
-        //TODO specific exception
-    }
-
-    @Test
-    public void should_verify_in_order_with_at_least_once() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'a'));
-        async.runAfter(100, callMock(mock2, 'b'));
-        async.runAfter(120, callMock(mock2, 'b'));
-
-        // then
-        InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock1, timeout(200).atLeastOnce()).oneArg('a');
-        inOrder.verify(mock2, timeout(500).atLeastOnce()).oneArg('b');
-    }
-
-    @Test
-    public void should_verify_in_order_with_at_least_once_and_fail() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'a'));
-        async.runAfter(100, callMock(mock2, 'b'));
-        async.runAfter(120, callMock(mock2, 'b'));
-
-        // then
-        final InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock2, timeout(300).atLeastOnce()).oneArg('b');
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                inOrder.verify(mock1, timeout(500).atLeastOnce()).oneArg('a');
-            }
-        }).isInstanceOf(VerificationInOrderFailure.class)
-            .hasMessageContaining("Wanted but not invoked:\nmock1.oneArg('a');")
-            .hasMessageContaining("Wanted anywhere AFTER following interaction:\nmock2.oneArg('b');");
-    }
-
-    @Test
-    public void should_verify_in_order_with_at_least_x() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'a'));
-        async.runAfter(100, callMock(mock2, 'b'));
-        async.runAfter(120, callMock(mock2, 'b'));
-
-        // then
-        InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock1, timeout(200).atLeast(2)).oneArg('a');
-        inOrder.verify(mock2, timeout(500).atLeast(2)).oneArg('b');
-    }
-
-    @Test
-    public void should_verify_in_order_with_at_least_x_and_fail() {
-        // when
-        async.runAfter(20, callMock(mock1, 'a'));
-        async.runAfter(50, callMock(mock1, 'a'));
-        async.runAfter(100, callMock(mock2, 'b'));
-        async.runAfter(120, callMock(mock2, 'b'));
-
-        // then
-        final InOrder inOrder = inOrder(mock1, mock2);
-        inOrder.verify(mock2, timeout(300).atLeast(2)).oneArg('b');
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            public void call() {
-                inOrder.verify(mock1, timeout(500).atLeast(2)).oneArg('a');
-            }
-        }).isInstanceOf(AssertionError.class)
-            .hasMessageContaining("Verification in order failure");
-    }
-
-    private Runnable callMock(final IMethods mock, final char c) {
-        return new Runnable() {
-            @Override
-            public void run() {
-                mock.oneArg(c);
-            }
-        };
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationStartedListenerTest.java b/src/test/java/org/mockitousage/verification/VerificationStartedListenerTest.java
deleted file mode 100644
index 6f93458989..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationStartedListenerTest.java
+++ /dev/null
@@ -1,127 +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 org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.listeners.VerificationStartedEvent;
-import org.mockito.listeners.VerificationStartedListener;
-import org.mockitoutil.TestBase;
-
-/**
- * This test demonstrates how verification started listeners work.
- * The test cases are contrived but they provide necessary coverage.
- * For rationale, see https://github.com/mockito/mockito/issues/1191
- */
-public class VerificationStartedListenerTest extends TestBase {
-
-    @Test
-    public void verified_mock_can_be_replaced() throws Exception {
-        //given
-        final List mock1 = mock(List.class);
-        mock1.clear(); //register clear() on mock1
-
-        //when
-        List mock2 = mock(List.class, Mockito.withSettings().verificationStartedListeners(new VerificationStartedListener() {
-            public void onVerificationStarted(VerificationStartedEvent event) {
-                //this is a hack to simulate desired behavior
-                event.setMock(mock1);
-            }
-        }));
-
-        //then verified mock is not mock2 that was passed to 'verify' but the replacement: mock1
-        List verifiedMock = verify(mock2);
-        assertEquals(mock1, verifiedMock);
-
-        //and verification is successful because mock1.clear() was called
-        verifiedMock.clear();
-
-        //this test is admittedly contrived. it's goal is to provide coverage for the key functionality of the listener
-        //see the discussion at https://github.com/mockito/mockito/issues/1191
-    }
-
-    @Test
-    public void verification_started_event_contains_correct_mock() throws Exception {
-        //given
-        final List<Object> container = new ArrayList<Object>();
-
-        List mock = mock(List.class, Mockito.withSettings().verificationStartedListeners(new VerificationStartedListener() {
-            public void onVerificationStarted(VerificationStartedEvent event) {
-                //this is a hack to simulate desired behavior
-                container.add(event.getMock());
-            }
-        }));
-
-        //when
-        verify(mock, never()).clear();
-
-        //then
-        Assertions.assertThat(container).containsExactly(mock);
-    }
-
-    @Test
-    public void listeners_are_executed_in_sequence() throws Exception {
-        //given
-        final List<Object> container = new ArrayList<Object>();
-        final List mock1 = mock(List.class);
-
-        List mock2 = mock(List.class, Mockito.withSettings().verificationStartedListeners(new VerificationStartedListener() {
-            public void onVerificationStarted(VerificationStartedEvent event) {
-                //this is a hack to simulate desired behavior
-                container.add(event.getMock());
-                event.setMock(mock1);
-            }
-        }, new VerificationStartedListener() {
-            @Override
-            public void onVerificationStarted(VerificationStartedEvent event) {
-                container.add(event.getMock());
-            }
-        }));
-
-        //when
-        verify(mock2, never()).clear();
-
-        //ensure that:
-        // 1. listeners were notified in sequence
-        // 2. the state set by 1st listeners affects 2nd listener
-        Assertions.assertThat(container).containsExactly(mock2, mock1);
-
-        //there is no particular reason we decided on that behavior
-        //we want to have a consistent and documented behavior of the verification started listener
-    }
-
-    @Test
-    public void shows_clean_exception_when_null_array_passed() throws Exception {
-        try {
-            //when
-            Mockito.withSettings().verificationStartedListeners(null);
-            fail();
-        } catch (MockitoException e) {
-            assertEquals("verificationStartedListeners() does not accept null vararg array. See the Javadoc.", e.getMessage());
-        }
-    }
-
-    @Test
-    public void shows_clean_exception_when_null_listener_passed() throws Exception {
-        try {
-            //when
-            Mockito.withSettings().verificationStartedListeners(mock(VerificationStartedListener.class), null);
-            fail();
-        } catch (MockitoException e) {
-            assertEquals("verificationStartedListeners() does not accept null listeners. See the Javadoc.", e.getMessage());
-        }
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java b/src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java
deleted file mode 100644
index 4b7493c147..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.fail;
-import static org.mockito.AdditionalMatchers.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Matchers;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-public class VerificationUsingMatchersTest extends TestBase {
-
-    private IMethods mock;
-
-    @Before
-    public void setUp() {
-        mock = Mockito.mock(IMethods.class);
-    }
-
-    @Test
-    public void shouldVerifyExactNumberOfInvocationsUsingMatcher() {
-        mock.simpleMethod(1);
-        mock.simpleMethod(2);
-        mock.simpleMethod(3);
-
-        verify(mock, times(3)).simpleMethod(anyInt());
-    }
-
-    @Test
-    public void shouldVerifyUsingSameMatcher() {
-        Object one = new String("1243");
-        Object two = new String("1243");
-        Object three = new String("1243");
-
-        assertNotSame(one, two);
-        assertEquals(one, two);
-        assertEquals(two, three);
-
-        mock.oneArg(one);
-        mock.oneArg(two);
-
-        verify(mock).oneArg(same(one));
-        verify(mock, times(2)).oneArg(two);
-
-        try {
-            verify(mock).oneArg(same(three));
-            fail();
-        } catch (WantedButNotInvoked e) {
-        }
-    }
-
-    @Test
-    public void shouldVerifyUsingMixedMatchers() {
-        mock.threeArgumentMethod(11, "", "01234");
-
-        try {
-            verify(mock).threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), Matchers.contains("123"));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-        }
-
-        mock.threeArgumentMethod(8, new Object(), "01234");
-
-        try {
-            verify(mock).threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), Matchers.contains("123"));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-        }
-
-        mock.threeArgumentMethod(8, "", "no match");
-
-        try {
-            verify(mock).threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), Matchers.contains("123"));
-            fail();
-        } catch (ArgumentsAreDifferent e) {
-        }
-
-        mock.threeArgumentMethod(8, "", "123");
-
-        verify(mock).threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), Matchers.contains("123"));
-    }
-}
diff --git a/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java b/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java
deleted file mode 100644
index bb7f105cc8..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationWithAfterTest.java
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-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;
-
-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;
-
-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(600)).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
deleted file mode 100644
index 0c50578f6c..0000000000
--- a/src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.verification;
-
-import static org.mockito.Mockito.after;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.verify;
-import static org.mockito.junit.MockitoJUnit.rule;
-import static org.mockitoutil.Stopwatch.createNotStarted;
-
-import java.util.concurrent.TimeUnit;
-
-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.mockito.Mock;
-import org.mockito.exceptions.verification.TooFewActualInvocations;
-import org.mockito.junit.MockitoRule;
-import org.mockitousage.IMethods;
-import org.mockitoutil.Stopwatch;
-import org.mockitoutil.async.AsyncTesting;
-
-public class VerificationWithTimeoutTest {
-
-    @Rule public MockitoRule mockito = rule();
-
-    private Stopwatch watch = createNotStarted();
-
-    @Mock private IMethods mock;
-
-    private AsyncTesting async;
-
-    @Before
-    public void setUp() {
-        async = new AsyncTesting();
-    }
-
-    @After
-    public void tearDown() {
-        async.cleanUp();
-    }
-
-    @Test
-    public void should_verify_with_timeout() {
-        // when
-        async.runAfter(50, callMock('c'));
-        async.runAfter(500, callMock('c'));
-
-        // then
-        verify(mock, timeout(200).only()).oneArg('c');
-        verify(mock).oneArg('c'); //sanity check
-    }
-
-    @Test
-    public void should_verify_with_timeout_and_fail() {
-        // when
-        async.runAfter(200, callMock('c'));
-
-        // then
-        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
-    @Ignore //TODO nice to have
-    public void should_verify_with_timeout_and_fail_early() {
-        // when
-        callMock('c');
-        callMock('c');
-
-        watch.start();
-
-        // then
-        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 should_verify_with_times_x() {
-        // when
-        async.runAfter(50, callMock('c'));
-        async.runAfter(100, callMock('c'));
-        async.runAfter(600, callMock('c'));
-
-        // then
-        verify(mock, timeout(300).times(2)).oneArg('c');
-    }
-
-    @Test
-    public void should_verify_with_times_x_and_fail() {
-        // when
-        async.runAfter(10, callMock('c'));
-        async.runAfter(200, callMock('c'));
-
-        // then
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            @Override
-            public void call() {
-                verify(mock, timeout(100).times(2)).oneArg('c');
-            }
-        }).isInstanceOf(TooFewActualInvocations.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(TooFewActualInvocations.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
-    @Ignore("not testable, probably timeout().only() does not make sense")
-    public void should_verify_with_only_and_fail() {
-        // when
-        async.runAfter(10, callMock('c'));
-        async.runAfter(50, callMock('c'));
-
-        // then
-        Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
-            @Override
-            public void call() {
-                verify(mock, after(200).only()).oneArg('c');
-            }
-        }).isInstanceOf(AssertionError.class);
-    }
-
-    @Test
-    @Ignore //TODO nice to have
-    public void should_verify_with_only_and_fail_early() {
-        // when
-        callMock('c');
-        callMock('c');
-
-        watch.start();
-
-        // then
-        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) {
-        return new Runnable() {
-            @Override
-            public void run() {
-                mock.oneArg(c);
-            }
-        };
-    }
-}
diff --git a/src/test/java/org/mockitoutil/ClassLoadersTest.java b/src/test/java/org/mockitoutil/ClassLoadersTest.java
deleted file mode 100644
index 51e973be66..0000000000
--- a/src/test/java/org/mockitoutil/ClassLoadersTest.java
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockitoutil.ClassLoaders.currentClassLoader;
-import static org.mockitoutil.ClassLoaders.excludingClassLoader;
-import static org.mockitoutil.ClassLoaders.isolatedClassLoader;
-import static org.mockitoutil.ClassLoaders.jdkClassLoader;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.Mockito;
-
-public class ClassLoadersTest {
-
-    public static final String CLASS_NAME_DEPENDING_ON_INTERFACE = "org.mockitoutil.ClassLoadersTest$ClassUsingInterface1";
-    public static final String INTERFACE_NAME = "org.mockitoutil.ClassLoadersTest$Interface1";
-
-    @Test(expected = ClassNotFoundException.class)
-    public void isolated_class_loader_cannot_load_classes_when_no_given_prefix() throws Exception {
-        // given
-        ClassLoader cl = isolatedClassLoader().build();
-
-        // when
-        cl.loadClass("org.mockito.Mockito");
-
-        // then raises CNFE
-    }
-
-    @Test
-    public void isolated_class_loader_cannot_load_classes_if_no_code_source_path() throws Exception {
-        // given
-        ClassLoader cl = isolatedClassLoader()
-                .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
-                .build();
-
-        // when
-        try {
-            cl.loadClass(CLASS_NAME_DEPENDING_ON_INTERFACE);
-            fail();
-        } catch (ClassNotFoundException e) {
-            // then
-            assertThat(e).hasMessageContaining(CLASS_NAME_DEPENDING_ON_INTERFACE);
-        }
-    }
-
-    @Test
-    public void isolated_class_loader_cannot_load_classes_if_dependent_classes_do_not_match_the_prefixes() throws Exception {
-        // given
-        ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
-                .build();
-
-        // when
-        try {
-            cl.loadClass(CLASS_NAME_DEPENDING_ON_INTERFACE);
-            fail();
-        } catch (NoClassDefFoundError e) {
-            // then
-            assertThat(e).hasMessageContaining("org/mockitoutil/ClassLoadersTest$Interface1");
-        }
-    }
-
-    @Test
-    public void isolated_class_loader_can_load_classes_when_dependent_classes_are_matching_the_prefixes() throws Exception {
-        // given
-        ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
-                .withPrivateCopyOf(INTERFACE_NAME)
-                .build();
-
-        // when
-        Class<?> aClass = cl.loadClass(CLASS_NAME_DEPENDING_ON_INTERFACE);
-
-        // then
-        assertThat(aClass).isNotNull();
-        assertThat(aClass.getClassLoader()).isEqualTo(cl);
-        assertThat(aClass.getInterfaces()[0].getClassLoader()).isEqualTo(cl);
-    }
-
-    @Test
-    public void isolated_class_loader_can_load_classes_isolated_classes_in_isolation() throws Exception {
-        // given
-        ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
-                .build();
-
-        // when
-        Class<?> aClass = cl.loadClass(AClass.class.getName());
-
-        // then
-        assertThat(aClass).isNotNull();
-        assertThat(aClass).isNotSameAs(AClass.class);
-        assertThat(aClass.getClassLoader()).isEqualTo(cl);
-    }
-
-    @Test
-    public void isolated_class_loader_cannot_load_classes_if_prefix_excluded() throws Exception {
-        // given
-        ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
-                .without(AClass.class.getName())
-                .build();
-
-        // when
-        try {
-            cl.loadClass(AClass.class.getName());
-            fail();
-        } catch (ClassNotFoundException e) {
-            // then
-            assertThat(e).hasMessageContaining("org.mockitoutil")
-                         .hasMessageContaining(AClass.class.getName());
-        }
-    }
-
-    @Test
-    public void isolated_class_loader_has_no_parent() throws Exception {
-        ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withPrivateCopyOf(CLASS_NAME_DEPENDING_ON_INTERFACE)
-                .withPrivateCopyOf(INTERFACE_NAME)
-                .build();
-
-        assertThat(cl.getParent()).isNull();
-    }
-
-    @Test(expected = ClassNotFoundException.class)
-    public void excluding_class_loader_cannot_load_classes_when_no_correct_source_url_set() throws Exception {
-        // given
-        ClassLoader cl = excludingClassLoader()
-                .withCodeSourceUrlOf(this.getClass())
-                .build();
-
-        // when
-        cl.loadClass("org.mockito.Mockito");
-
-        // then class CNFE
-    }
-
-    @Test
-    public void excluding_class_loader_can_load_classes_when_correct_source_url_set() throws Exception {
-        // given
-        ClassLoader cl = excludingClassLoader()
-                .withCodeSourceUrlOf(Mockito.class)
-                .build();
-
-        // when
-        cl.loadClass("org.mockito.Mockito");
-
-        // then class successfully loaded
-    }
-
-    @Test
-    public void excluding_class_loader_cannot_load_class_when_excluded_prefix_match_class_to_load() throws Exception {
-        // given
-        ClassLoader cl = excludingClassLoader()
-                .withCodeSourceUrlOf(Mockito.class)
-                .without("org.mockito.BDDMockito")
-                .build();
-
-        cl.loadClass("org.mockito.Mockito");
-
-        // when
-        try {
-            cl.loadClass("org.mockito.BDDMockito");
-            fail("should have raise a ClassNotFoundException");
-        } catch (ClassNotFoundException e) {
-            assertThat(e.getMessage()).contains("org.mockito.BDDMockito");
-        }
-
-        // then class successfully loaded
-    }
-
-    @Test
-    public void can_not_load_a_class_not_previously_registered_in_builder() throws Exception {
-        // given
-        ClassLoader cl = ClassLoaders
-                .inMemoryClassLoader()
-                .withClassDefinition("yop.Dude", SimpleClassGenerator.makeMarkerInterface("yop.Dude"))
-                .build();
-
-        // when
-        try {
-            cl.loadClass("not.Defined");
-            fail();
-        } catch (ClassNotFoundException e) {
-            // then
-            assertThat(e.getMessage()).contains("not.Defined");
-        }
-    }
-
-    @Test
-    public void can_load_a_class_in_memory_from_bytes() throws Exception {
-        // given
-        ClassLoader cl = ClassLoaders
-                .inMemoryClassLoader()
-                .withClassDefinition("yop.Dude", SimpleClassGenerator.makeMarkerInterface("yop.Dude"))
-                .build();
-
-        // when
-        Class<?> aClass = cl.loadClass("yop.Dude");
-
-        // then
-        assertThat(aClass).isNotNull();
-        assertThat(aClass.getClassLoader()).isEqualTo(cl);
-        assertThat(aClass.getName()).isEqualTo("yop.Dude");
-    }
-
-    @Test
-    public void cannot_load_a_class_file_not_in_parent() throws Exception {
-        // given
-        ClassLoader cl = ClassLoaders
-                .inMemoryClassLoader()
-                .withParent(jdkClassLoader())
-                .build();
-
-        cl.loadClass("java.lang.String");
-
-        try {
-            // when
-            cl.loadClass("org.mockito.Mockito");
-            fail("should have not found Mockito class");
-        } catch (ClassNotFoundException e) {
-            // then
-            assertThat(e.getMessage()).contains("org.mockito.Mockito");
-        }
-    }
-
-    @Test
-    public void can_list_all_classes_reachable_in_a_classloader() throws Exception {
-        ClassLoader classLoader = ClassLoaders.inMemoryClassLoader()
-                                              .withParent(jdkClassLoader())
-                                              .withClassDefinition("a.A", SimpleClassGenerator.makeMarkerInterface("a.A"))
-                                              .withClassDefinition("a.b.B", SimpleClassGenerator.makeMarkerInterface("a.b.B"))
-                                              .withClassDefinition("c.C", SimpleClassGenerator.makeMarkerInterface("c.C"))
-//                .withCodeSourceUrlOf(ClassLoaders.class)
-                                              .build();
-
-        assertThat(ClassLoaders.in(classLoader).listOwnedClasses()).containsOnly("a.A", "a.b.B", "c.C");
-        assertThat(ClassLoaders.in(classLoader).omit("b", "c").listOwnedClasses()).containsOnly("a.A");
-    }
-
-    @Test
-    public void return_bootstrap_classloader() throws Exception {
-        assertThat(jdkClassLoader()).isNotEqualTo(Mockito.class.getClassLoader());
-        assertThat(jdkClassLoader()).isNotEqualTo(ClassLoaders.class.getClassLoader());
-        assertThat(jdkClassLoader()).isEqualTo(Number.class.getClassLoader());
-        assertThat(jdkClassLoader()).isEqualTo(null);
-    }
-
-    @Test
-    public void return_current_classloader() throws Exception {
-        assertThat(currentClassLoader()).isEqualTo(this.getClass().getClassLoader());
-    }
-
-    @Test
-    public void can_run_in_given_classloader() throws Exception {
-        // given
-        final ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withCodeSourceUrlOf(Assertions.class)
-                .withPrivateCopyOf("org.assertj.core")
-                .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
-                .without(AClass.class.getName())
-                .build();
-
-        final AtomicBoolean executed = new AtomicBoolean(false);
-
-        // when
-        ClassLoaders.using(cl).execute(new Runnable() {
-            @Override
-            public void run() {
-                assertThat(this.getClass().getClassLoader()).describedAs("runnable is reloaded in given classloader").isEqualTo(cl);
-                assertThat(Thread.currentThread().getContextClassLoader()).describedAs("Thread context classloader is using given classloader").isEqualTo(cl);
-
-                try {
-                    assertThat(Thread.currentThread()
-                                     .getContextClassLoader()
-                                     .loadClass("java.lang.String"))
-                            .describedAs("can load JDK type")
-                            .isNotNull();
-                    assertThat(Thread.currentThread()
-                                     .getContextClassLoader()
-                                     .loadClass("org.mockitoutil.ClassLoadersTest$ClassUsingInterface1"))
-                            .describedAs("can load classloader types")
-                            .isNotNull();
-                } catch (ClassNotFoundException cnfe) {
-                    Assertions.fail("should not have raised a CNFE", cnfe);
-                }
-                executed.set(true);
-            }
-        });
-
-        // then
-        assertThat(executed.get()).isEqualTo(true);
-    }
-
-
-    @Test
-    public void cannot_load_runnable_in_given_classloader_if_some_type_cant_be_loaded() throws Exception {
-        // given
-        final ClassLoader cl = isolatedClassLoader()
-                .withCurrentCodeSourceUrls()
-                .withPrivateCopyOf(ClassLoadersTest.class.getPackage().getName())
-                .without(AClass.class.getName())
-                .build();
-
-        // when
-        try {
-            ClassLoaders.using(cl).execute(new Runnable() {
-                @Override
-                public void run() {
-                    AClass cant_be_found = new AClass();
-                }
-            });
-            Assertions.fail("should have raised a ClassNotFoundException");
-        } catch (IllegalStateException ise) {
-            // then
-            assertThat(ise).hasCauseInstanceOf(NoClassDefFoundError.class)
-                           .hasMessageContaining("AClass");
-        }
-    }
-
-    @SuppressWarnings("unused")
-    static class AClass {
-    }
-
-    @SuppressWarnings("unused")
-    static class ClassUsingInterface1 implements Interface1 {
-    }
-
-    @SuppressWarnings("unused")
-    interface Interface1 {
-    }
-}
diff --git a/src/test/java/org/mockitoutil/JUnitResultAssert.java b/src/test/java/org/mockitoutil/JUnitResultAssert.java
deleted file mode 100644
index e920ae1dd6..0000000000
--- a/src/test/java/org/mockitoutil/JUnitResultAssert.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.util.collections.Iterables.firstOf;
-import static org.mockitoutil.TestBase.filterLineNo;
-
-import java.util.List;
-
-import org.junit.runner.Result;
-import org.junit.runner.notification.Failure;
-
-/**
- * Assertion utility for cleaner & easier to debug tests that inspect on JUnit's Result object
- */
-public class JUnitResultAssert {
-    private Result result;
-
-    private JUnitResultAssert(Result result) {
-        this.result = result;
-    }
-
-    public void isSuccessful() {
-        if (result.wasSuccessful()) {
-            return;
-        }
-
-        throw new AssertionError(formatFailures(result.getFailures()));
-    }
-
-    /**
-     * @param expectedFailureCount - expected number of failures
-     * @param expectedException - the exception of each failure
-     */
-    public JUnitResultAssert fails(int expectedFailureCount, Class expectedException) {
-        fails(expectedFailureCount);
-        for (Failure f : result.getFailures()) {
-            if (!expectedException.isInstance(f.getException())) {
-                throw new AssertionError("Incorrect failure type, expected: " + expectedException + ", actual: " + f.getException().getClass().getSimpleName() + "\n" +
-                        formatFailures(result.getFailures()));
-            }
-        }
-        return this;
-    }
-
-    /**
-     * @param expectedFailureCount - exact number of expected failures
-     */
-    public JUnitResultAssert fails(int expectedFailureCount) {
-        if (result.getFailures().size() != expectedFailureCount) {
-            throw new AssertionError("Wrong number of failures, expected: " + expectedFailureCount + ", actual: " + result.getFailures().size() + "\n" +
-                    formatFailures(result.getFailures()));
-        }
-        return this;
-    }
-
-    /**
-     * @param expectedExceptions - failures must match the supplied sequence in order,
-     *                           if supplied input is empty, this method is a no-op
-     */
-    public JUnitResultAssert failsExactly(Class ... expectedExceptions) {
-        fails(expectedExceptions.length);
-        int i = 0;
-        for (Failure f : result.getFailures()) {
-            if (!expectedExceptions[i].isInstance(f.getException())) {
-                throw new AssertionError("Actual failure #" + (i+1)
-                        + " should be of type: " + expectedExceptions[i].getSimpleName()
-                        + " but is of type: " + f.getException().getClass().getSimpleName()
-                        + "\n" + formatFailures(result.getFailures()));
-            }
-            i++;
-        }
-        return this;
-    }
-
-    /**
-     * Expects single failure with specific exception and exception message.
-     * Automatically filters line numbers from exception messages.
-     */
-    public JUnitResultAssert fails(Class expectedException, String exceptionMessage) {
-        fails(1, expectedException);
-        Failure f = firstOf(result.getFailures());
-        assertEquals(filterLineNo(exceptionMessage), filterLineNo(f.getException().getMessage()));
-        return this;
-    }
-
-    /**
-     * Expects failure of given test method with given exception
-     */
-    public JUnitResultAssert fails(String methodName, Class expectedException) {
-        for (Failure f : result.getFailures()) {
-            if (methodName.equals(f.getDescription().getMethodName()) && expectedException.isInstance(f.getException())) {
-                return this;
-            }
-        }
-        throw new AssertionError("Method '" + methodName + "' did not fail with: " + expectedException.getSimpleName()
-                + "\n" + formatFailures(result.getFailures()));
-    }
-
-    /**
-     * Expects given amount of failures, with given exception triggered by given test method
-     */
-    public JUnitResultAssert fails(int expectedFailureCount, String methodName, Class expectedException) {
-        return fails(expectedFailureCount, expectedException)
-                .fails(methodName, expectedException);
-    }
-
-    public JUnitResultAssert succeeds(int successCount) {
-        int i = result.getRunCount() - result.getFailureCount();
-        if (i != successCount) {
-            throw new AssertionError("Expected " + successCount + " passes but " + i + "/" + result.getRunCount() + " passed." +
-                    "\n" + formatFailures(result.getFailures()));
-        }
-        return this;
-    }
-
-    private static String formatFailures(List<Failure> failures) {
-        if (failures.isEmpty()) {
-            return "<no failures>";
-        }
-        StringBuilder sb = new StringBuilder("There were " + failures.size() + " test failures:\n");
-        int count = 0;
-        for (Failure f : failures) {
-            sb.append("  <-----> ").append(++count).append(". ").append(f.getTrace()).append("\n");
-        }
-
-        return sb.toString();
-    }
-
-    /**
-     * Clean assertions for JUnit's result object
-     */
-    public static JUnitResultAssert assertThat(Result result) {
-        return new JUnitResultAssert(result);
-    }
-}
diff --git a/src/test/java/org/mockitoutil/SafeJUnitRule.java b/src/test/java/org/mockitoutil/SafeJUnitRule.java
deleted file mode 100644
index db256d5870..0000000000
--- a/src/test/java/org/mockitoutil/SafeJUnitRule.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import org.assertj.core.api.AbstractThrowableAssert;
-import org.assertj.core.api.Assertions;
-import org.junit.rules.MethodRule;
-import org.junit.runners.model.FrameworkMethod;
-import org.junit.runners.model.Statement;
-
-/**
- * Junit rule for testing exception handling other JUnit rules, like Mockito JUnit rules.
- * Makes it easy to assert on expected exceptions triggered by the rule under test.
- */
-public class SafeJUnitRule implements MethodRule {
-
-    private final MethodRule testedRule;
-    private FailureAssert failureAssert = null;
-    private Runnable successAssert = new Runnable() { public void run() { } };
-
-    /**
-     * Wraps rule under test with exception handling so that it is easy to assert on exceptions fired from the tested rule.
-     */
-    public SafeJUnitRule(MethodRule testedRule) {
-        this.testedRule = testedRule;
-    }
-
-    public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
-        return new Statement() {
-            public void evaluate() throws Throwable {
-                try {
-                    testedRule.apply(base, method, target).evaluate();
-                    successAssert.run();
-                } catch (Throwable t) {
-                    if (failureAssert == null) {
-                        throw t;
-                    }
-                    failureAssert.doAssert(t);
-                    return;
-                }
-                if (failureAssert != null) {
-                    //looks like the user expects a throwable but it was not thrown!
-                    throw new ExpectedThrowableNotReported("Expected the tested rule to throw an exception but it did not.");
-                }
-            }
-        };
-    }
-
-    /**
-     * Expects that _after_ the test, the rule will fire specific exception with specific exception message
-     */
-    public void expectFailure(final Class<? extends Throwable> expected, final String expectedMessage) {
-        this.expectFailure(new FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertThrowable(t, expected).hasMessage(expectedMessage);
-            }
-        });
-    }
-
-    /**
-     * Expects that _after_ the test, the rule will fire specific exception with specific exception message
-     */
-    public void expectFailure(final Class<? extends Throwable> expected) {
-        this.expectFailure(new FailureAssert() {
-            public void doAssert(Throwable t) {
-                assertThrowable(t, expected);
-            }
-        });
-    }
-
-    private static AbstractThrowableAssert assertThrowable(Throwable throwable, Class<? extends Throwable> expected) {
-        return Assertions.assertThat(throwable).isInstanceOf(expected);
-    }
-
-    /**
-     * Expects that _after_ the test, the rule will fire an exception
-     */
-    public void expectFailure(FailureAssert failureAssert) {
-        this.failureAssert = failureAssert;
-    }
-
-    /**
-     * Expects that _after_ the test, given assert will run
-     */
-    public void expectSuccess(Runnable successAssert) {
-        this.successAssert = successAssert;
-    }
-
-    /**
-     * Offers a way to assert the throwable triggered by the tested rule
-     */
-    public interface FailureAssert {
-        void doAssert(Throwable t);
-    }
-
-    /**
-     * Thrown when user expects the tested rule to throw an exception but no exception was thrown
-     */
-    class ExpectedThrowableNotReported extends Throwable {
-        public ExpectedThrowableNotReported(String message) {
-            super(message);
-        }
-    }
-}
diff --git a/src/test/java/org/mockitoutil/SafeJUnitRuleTest.java b/src/test/java/org/mockitoutil/SafeJUnitRuleTest.java
deleted file mode 100644
index acbf27af9e..0000000000
--- a/src/test/java/org/mockitoutil/SafeJUnitRuleTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
-
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.junit.rules.MethodRule;
-import org.junit.runners.model.FrameworkMethod;
-import org.junit.runners.model.Statement;
-
-public class SafeJUnitRuleTest {
-
-    MethodRuleStub delegate = new MethodRuleStub();
-    SafeJUnitRule rule = new SafeJUnitRule(delegate);
-
-    @Test public void happy_path_no_exception() throws Throwable {
-        //when
-        rule.apply(new Statement() {
-            public void evaluate() throws Throwable {
-                //all good
-            }
-        }, mock(FrameworkMethod.class), this).evaluate();
-
-        //then
-        assertTrue(delegate.statementEvaluated);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void regular_failing_test() throws Throwable {
-        //when
-        rule.apply(new Statement() {
-            public void evaluate() throws Throwable {
-                throw new IllegalArgumentException();
-            }
-        }, mock(FrameworkMethod.class), this).evaluate();
-    }
-
-    @Test public void rule_threw_exception() throws Throwable {
-        //expect
-        rule.expectFailure(AssertionError.class, "x");
-
-        //when
-        rule.apply(new Statement() {
-            public void evaluate() throws Throwable {
-                throw new AssertionError("x");
-            }
-        }, mock(FrameworkMethod.class), this).evaluate();
-    }
-
-    @Test public void expected_exception_but_no_exception() throws Throwable {
-        //expect
-        rule.expectFailure(AssertionError.class, "x");
-
-        //when
-        try {
-            rule.apply(new Statement() {
-                public void evaluate() throws Throwable {
-                    //all good
-                }
-            }, mock(FrameworkMethod.class), this).evaluate();
-            fail();
-
-        //then
-        } catch (SafeJUnitRule.ExpectedThrowableNotReported t) {
-            //yup, expected
-        }
-    }
-
-    @Test public void expected_exception_message_did_not_match() throws Throwable {
-        //expect
-        rule.expectFailure(AssertionError.class, "FOO");
-
-        //when
-        try {
-            rule.apply(new Statement() {
-                public void evaluate() throws Throwable {
-                    throw new AssertionError("BAR");
-                }
-            }, mock(FrameworkMethod.class), this).evaluate();
-            fail();
-        } catch (AssertionError throwable) {
-            Assertions.assertThat(throwable).hasMessageContaining("Expecting message");
-        }
-    }
-
-    @Test public void expected_exception_type_did_not_match() throws Throwable {
-        //expect
-        rule.expectFailure(AssertionError.class, "x");
-
-        //when
-        try {
-            rule.apply(new Statement() {
-                public void evaluate() throws Throwable {
-                    throw new RuntimeException("x");
-                }
-            }, mock(FrameworkMethod.class), this).evaluate();
-            fail();
-        } catch (AssertionError throwable) {
-            Assertions.assertThat(throwable).hasMessageContaining("but was:");
-        }
-    }
-
-    @Test public void expected_exception_assert_did_not_match() throws Throwable {
-        //expect
-        rule.expectFailure(new SafeJUnitRule.FailureAssert() {
-            public void doAssert(Throwable t) {
-                throw new AssertionError("x");
-            }
-        });
-
-        //when
-        try {
-            rule.apply(new Statement() {
-                public void evaluate() throws Throwable {
-                    throw new RuntimeException();
-                }
-            }, mock(FrameworkMethod.class), this).evaluate();
-            fail();
-        } catch (AssertionError throwable) {
-            assertEquals(throwable.getMessage(), "x");
-        }
-    }
-
-    private static class MethodRuleStub implements MethodRule {
-        private boolean statementEvaluated;
-        public Statement apply(final Statement base, FrameworkMethod method, Object target) {
-            return new Statement() {
-                public void evaluate() throws Throwable {
-                    statementEvaluated = true;
-                    base.evaluate();
-                }
-            };
-        }
-    }
-}
diff --git a/src/test/java/org/mockitoutil/SimpleClassGenerator.java b/src/test/java/org/mockitoutil/SimpleClassGenerator.java
deleted file mode 100644
index 8920122910..0000000000
--- a/src/test/java/org/mockitoutil/SimpleClassGenerator.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import static org.objectweb.asm.Opcodes.*;
-
-import org.objectweb.asm.ClassWriter;
-
-public class SimpleClassGenerator {
-
-    public static byte[] makeMarkerInterface(String qualifiedName) {
-        String relativePath = qualifiedName.replace('.', '/');
-
-        ClassWriter cw = new ClassWriter(0);
-        cw.visit(V1_6, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, relativePath, null, "java/lang/Object", null);
-        cw.visitEnd();
-
-        return cw.toByteArray();
-    }
-
-}
diff --git a/src/test/java/org/mockitoutil/SimplePerRealmReloadingClassLoader.java b/src/test/java/org/mockitoutil/SimplePerRealmReloadingClassLoader.java
deleted file mode 100644
index 1f49afb1ba..0000000000
--- a/src/test/java/org/mockitoutil/SimplePerRealmReloadingClassLoader.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.Callable;
-
-/**
- * Custom classloader to load classes in hierarchic realm.
- *
- * Each class can be reloaded in the realm if the LoadClassPredicate says so.
- */
-public class SimplePerRealmReloadingClassLoader extends URLClassLoader {
-
-    private final Map<String,Class<?>> classHashMap = new HashMap<String, Class<?>>();
-    private ReloadClassPredicate reloadClassPredicate;
-
-    public SimplePerRealmReloadingClassLoader(ReloadClassPredicate reloadClassPredicate) {
-        super(getPossibleClassPathsUrls());
-        this.reloadClassPredicate = reloadClassPredicate;
-    }
-
-    public SimplePerRealmReloadingClassLoader(ClassLoader parentClassLoader, ReloadClassPredicate reloadClassPredicate) {
-        super(getPossibleClassPathsUrls(), parentClassLoader);
-        this.reloadClassPredicate = reloadClassPredicate;
-    }
-
-    private static URL[] getPossibleClassPathsUrls() {
-        return new URL[]{
-                obtainClassPath(),
-                obtainClassPath("org.mockito.Mockito"),
-                obtainClassPath("net.bytebuddy.ByteBuddy")
-        };
-    }
-
-    private static URL obtainClassPath() {
-        String className = SimplePerRealmReloadingClassLoader.class.getName();
-        return obtainClassPath(className);
-    }
-
-    private static URL obtainClassPath(String className) {
-        String path = className.replace('.', '/') + ".class";
-        String url = SimplePerRealmReloadingClassLoader.class.getClassLoader().getResource(path).toExternalForm();
-
-        try {
-            return new URL(url.substring(0, url.length() - path.length()));
-        } catch (MalformedURLException e) {
-            throw new RuntimeException("Classloader couldn't obtain a proper classpath URL", e);
-        }
-    }
-
-
-
-    @Override
-    public Class<?> loadClass(String qualifiedClassName) throws ClassNotFoundException {
-        if(reloadClassPredicate.acceptReloadOf(qualifiedClassName)) {
-            // return customLoadClass(qualifiedClassName);
-//            Class<?> loadedClass = findLoadedClass(qualifiedClassName);
-            if(!classHashMap.containsKey(qualifiedClassName)) {
-                Class<?> foundClass = findClass(qualifiedClassName);
-                saveFoundClass(qualifiedClassName, foundClass);
-                return foundClass;
-            }
-
-            return classHashMap.get(qualifiedClassName);
-        }
-        return useParentClassLoaderFor(qualifiedClassName);
-    }
-
-    private void saveFoundClass(String qualifiedClassName, Class<?> foundClass) {
-        classHashMap.put(qualifiedClassName, foundClass);
-    }
-
-
-    private Class<?> useParentClassLoaderFor(String qualifiedName) throws ClassNotFoundException {
-        return super.loadClass(qualifiedName);
-    }
-
-
-    public Object doInRealm(String callableCalledInClassLoaderRealm) throws Exception {
-        ClassLoader current = Thread.currentThread().getContextClassLoader();
-        try {
-            Thread.currentThread().setContextClassLoader(this);
-            Object instance = this.loadClass(callableCalledInClassLoaderRealm).getConstructor().newInstance();
-            if (instance instanceof Callable) {
-                Callable<?> callableInRealm = (Callable<?>) instance;
-                return callableInRealm.call();
-            }
-        } finally {
-            Thread.currentThread().setContextClassLoader(current);
-        }
-        throw new IllegalArgumentException("qualified name '" + callableCalledInClassLoaderRealm + "' should represent a class implementing Callable");
-    }
-
-
-    public Object doInRealm(String callableCalledInClassLoaderRealm, Class<?>[] argTypes, Object[] args) throws Exception {
-        ClassLoader current = Thread.currentThread().getContextClassLoader();
-        try {
-            Thread.currentThread().setContextClassLoader(this);
-            Object instance = this.loadClass(callableCalledInClassLoaderRealm).getConstructor(argTypes).newInstance(args);
-            if (instance instanceof Callable) {
-                Callable<?> callableInRealm = (Callable<?>) instance;
-                return callableInRealm.call();
-            }
-        } finally {
-            Thread.currentThread().setContextClassLoader(current);
-        }
-
-        throw new IllegalArgumentException("qualified name '" + callableCalledInClassLoaderRealm + "' should represent a class implementing Callable");
-    }
-
-
-    public interface ReloadClassPredicate {
-        boolean acceptReloadOf(String qualifiedName);
-    }
-}
diff --git a/src/test/java/org/mockitoutil/TestBaseTest.java b/src/test/java/org/mockitoutil/TestBaseTest.java
deleted file mode 100644
index 81e5477db9..0000000000
--- a/src/test/java/org/mockitoutil/TestBaseTest.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-public class TestBaseTest extends TestBase {
-
-    @Test public void filters_line_no_from_stack_trace() {
-        assertEquals("", filterLineNo(""));
-        assertEquals("asdf", filterLineNo("asdf"));
-        assertEquals("asdf (FooBar.java:0) blah", filterLineNo("asdf (FooBar.java:23) blah"));
-        assertEquals("asdf\n(FooBar.java:0)\nblah", filterLineNo("asdf\n(FooBar.java:123123)\nblah"));
-        assertEquals("asdf\n(FooBar.java:0)\n(Xxx.java:0)blah", filterLineNo("asdf\n(FooBar.java:2)\n(Xxx.java:1)blah"));
-
-        assertEquals("asdf\n(FooBar.java:0)\nXxx.java:20)blah", filterLineNo("asdf\n(FooBar.java:2)\nXxx.java:20)blah"));
-    }
-}
diff --git a/src/test/java/org/mockitoutil/async/AsyncTesting.java b/src/test/java/org/mockitoutil/async/AsyncTesting.java
deleted file mode 100644
index a193eb689c..0000000000
--- a/src/test/java/org/mockitoutil/async/AsyncTesting.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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)
- *
- * //TODO convert to test rule
- */
-public class AsyncTesting {
-
-    //Sanity limit of threas. Increase it if justified.
-    private final static int MAX_THREADS = 4;
-
-    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
deleted file mode 100644
index 5db8147abb..0000000000
--- a/src/test/java/org/mockitoutil/async/AsyncTestingTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoutil.async;
-
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockitoutil.Stopwatch.createNotStarted;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.junit.After;
-import org.junit.Test;
-import org.mockitoutil.Stopwatch;
-
-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/android.gradle b/subprojects/android/android.gradle
deleted file mode 100644
index 8f86eabb98..0000000000
--- a/subprojects/android/android.gradle
+++ /dev/null
@@ -1,10 +0,0 @@
-description = "Mockito for Android"
-
-apply from: "$rootDir/gradle/java-library.gradle"
-
-dependencies {
-    compile project.rootProject
-    compile libraries.bytebuddyandroid
-}
-
-tasks.javadoc.enabled = false
diff --git a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java b/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java
deleted file mode 100644
index db77fb7b03..0000000000
--- a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.android.internal.creation;
-
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker;
-import org.mockito.internal.util.Platform;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.MockMaker;
-
-import static org.mockito.internal.util.StringUtil.join;
-
-public class AndroidByteBuddyMockMaker implements MockMaker {
-
-    private final MockMaker delegate;
-
-    public AndroidByteBuddyMockMaker() {
-        if (Platform.isAndroid() || Platform.isAndroidMockMakerRequired()) {
-            delegate = new SubclassByteBuddyMockMaker(new AndroidLoadingStrategy());
-        } else {
-            Plugins.getMockitoLogger().log(join(
-                    "IMPORTANT NOTE FROM MOCKITO:",
-                    "",
-                    "You included the 'mockito-android' dependency in a non-Android environment.",
-                    "The Android mock maker was disabled. You should only include the latter in your 'androidTestCompile' configuration",
-                    "If disabling was a mistake, you can set the 'org.mockito.mock.android' property to 'true' to override this detection.",
-                    "",
-                    "Visit https://javadoc.io/page/org.mockito/mockito-core/latest/org/mockito/Mockito.html#0.1 for more information"
-            ));
-            delegate = new SubclassByteBuddyMockMaker();
-        }
-    }
-
-    @Override
-    public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
-        return delegate.createMock(settings, handler);
-    }
-
-    @Override
-    public MockHandler getHandler(Object mock) {
-        return delegate.getHandler(mock);
-    }
-
-    @Override
-    public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
-        delegate.resetMock(mock, newHandler, settings);
-    }
-
-    @Override
-    public TypeMockability isTypeMockable(Class<?> type) {
-        return delegate.isTypeMockable(type);
-    }
-}
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
deleted file mode 100644
index 722943875f..0000000000
--- a/subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.android.internal.creation;
-
-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 boolean isDisrespectingOpenness() {
-        return false;
-    }
-
-    @Override
-    public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
-        File target = AndroidTempFileLocator.target;
-        if (target == null) {
-            throw new MockitoException(join(
-                    "Could not look up implicit location for storing generated classes",
-                    "",
-                    "You can configure an explicit location by setting the system property",
-                    "'org.mockito.android.target' to a folder for storing generated class files",
-                    "This location must be in private scope for most API versions, for example:",
-                    "",
-                    "MyActivity.this.getDir(\"target\", Context.MODE_PRIVATE)",
-                    "or",
-                    "getInstrumentation().getTargetContext().getCacheDir().getPath()"
-            ));
-        }
-        return new AndroidClassLoadingStrategy.Injecting(target);
-    }
-}
diff --git a/subprojects/deprecatedPluginsTest/deprecatedPluginsTest.gradle b/subprojects/deprecatedPluginsTest/deprecatedPluginsTest.gradle
deleted file mode 100644
index d685a4dc0e..0000000000
--- a/subprojects/deprecatedPluginsTest/deprecatedPluginsTest.gradle
+++ /dev/null
@@ -1,9 +0,0 @@
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-apply plugin: 'java'
-description = "End-to-end tests for deprecated Mockito plugins."
-
-dependencies {
-    testCompile project(":")
-    testCompile libraries.junit4
-}
diff --git a/subprojects/deprecatedPluginsTest/src/test/java/org/mockitousage/plugins/DeprecatedInstantiatorProviderTest.java b/subprojects/deprecatedPluginsTest/src/test/java/org/mockitousage/plugins/DeprecatedInstantiatorProviderTest.java
deleted file mode 100644
index 2ccd170362..0000000000
--- a/subprojects/deprecatedPluginsTest/src/test/java/org/mockitousage/plugins/DeprecatedInstantiatorProviderTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.plugins;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.creation.instance.InstantiationException;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.plugins.InstantiatorProvider;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.mock;
-
-public class DeprecatedInstantiatorProviderTest {
-
-    @Test
-    public void provides_default_instance_for_deprecated_plugin() {
-        InstantiatorProvider plugin = Mockito.framework().getPlugins().getDefaultPlugin(InstantiatorProvider.class);
-        assertNotNull(plugin);
-    }
-
-    @SuppressWarnings("CheckReturnValue")
-    @Test
-    public void uses_custom_instantiator_provider() {
-        MyDeprecatedInstantiatorProvider.invokedFor.remove();
-        mock(DeprecatedInstantiatorProviderTest.class);
-        assertEquals(MyDeprecatedInstantiatorProvider.invokedFor.get(), asList(DeprecatedInstantiatorProviderTest.class));
-    }
-
-    @SuppressWarnings("CheckReturnValue")
-    @Test(expected = InstantiationException.class)
-    public void exception_while_instantiating() throws Throwable {
-        MyDeprecatedInstantiatorProvider.shouldExcept.set(true);
-        try {
-            mock(DeprecatedInstantiatorProviderTest.class);
-        } catch (MockitoException e) {
-            throw e.getCause();
-        } finally {
-            MyDeprecatedInstantiatorProvider.shouldExcept.remove();
-        }
-    }
-}
diff --git a/subprojects/deprecatedPluginsTest/src/test/java/org/mockitousage/plugins/MyDeprecatedInstantiatorProvider.java b/subprojects/deprecatedPluginsTest/src/test/java/org/mockitousage/plugins/MyDeprecatedInstantiatorProvider.java
deleted file mode 100644
index a15dc41a77..0000000000
--- a/subprojects/deprecatedPluginsTest/src/test/java/org/mockitousage/plugins/MyDeprecatedInstantiatorProvider.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.plugins;
-
-import org.mockito.Mockito;
-import org.mockito.internal.creation.instance.InstantiationException;
-import org.mockito.internal.creation.instance.Instantiator;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InstantiatorProvider;
-
-import java.util.LinkedList;
-import java.util.List;
-
-@SuppressWarnings("deprecation")
-public class MyDeprecatedInstantiatorProvider implements InstantiatorProvider {
-    static ThreadLocal<Boolean> shouldExcept = new ThreadLocal<>();
-    static ThreadLocal<List<Class>> invokedFor = new ThreadLocal<>();
-
-    @Override
-    public Instantiator getInstantiator(MockCreationSettings<?> settings) {
-        if (shouldExcept.get() != null) {
-            throw new InstantiationException(null, null);
-        }
-
-        if (invokedFor.get() == null) {
-            invokedFor.set(new LinkedList<>());
-        }
-        invokedFor.get().add(settings.getTypeToMock());
-
-        return Mockito.framework().getPlugins().getDefaultPlugin(InstantiatorProvider.class).getInstantiator(settings);
-    }
-}
diff --git a/subprojects/deprecatedPluginsTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider b/subprojects/deprecatedPluginsTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider
deleted file mode 100644
index 2c038d27b6..0000000000
--- a/subprojects/deprecatedPluginsTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider
+++ /dev/null
@@ -1 +0,0 @@
-org.mockitousage.plugins.MyDeprecatedInstantiatorProvider
diff --git a/subprojects/errorprone/errorprone.gradle b/subprojects/errorprone/errorprone.gradle
deleted file mode 100644
index f547d2ee28..0000000000
--- a/subprojects/errorprone/errorprone.gradle
+++ /dev/null
@@ -1,23 +0,0 @@
-description = "ErrorProne plugins for Mockito"
-
-apply from: "$rootDir/gradle/java-library.gradle"
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-dependencies {
-    compileOnly libraries.autoservice
-    annotationProcessor libraries.autoservice
-
-    compile project.rootProject
-    compile libraries.errorprone
-
-    testCompile 'junit:junit:4.13-beta-1'
-    testCompile libraries.errorproneTestApi
-}
-
-test {
-    inputs.files(configurations.errorproneJavac).withNormalizer(ClasspathNormalizer)
-    jvmArgs += "-Xbootclasspath/p:${configurations.errorproneJavac.asPath}"
-
-    // ErrorProne can only run on JDK 8
-    it.enabled = !JavaVersion.current().isJava9Compatible()
-}
diff --git a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/AbstractMockitoAnyForPrimitiveType.java b/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/AbstractMockitoAnyForPrimitiveType.java
deleted file mode 100644
index 3d14b4eaad..0000000000
--- a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/AbstractMockitoAnyForPrimitiveType.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import static com.google.errorprone.matchers.Description.NO_MATCH;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MemberSelectTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.tree.Tree;
-import com.sun.source.util.TreePath;
-import com.sun.tools.javac.code.Symbol.MethodSymbol;
-import com.sun.tools.javac.code.Symbol.VarSymbol;
-import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.code.Type.ArrayType;
-import java.util.List;
-import javax.lang.model.type.TypeKind;
-
-/** Base for {@link BugChecker}s that detect issues with any() matchers and primitive types. */
-public abstract class AbstractMockitoAnyForPrimitiveType extends BugChecker
-    implements MethodInvocationTreeMatcher {
-
-  protected abstract Matcher<? super MethodInvocationTree> matcher();
-
-  protected abstract String formatMessage(
-      String expectedTypeAsString, Type matcherType, String replacementName);
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!matcher().matches(tree, state)) {
-      return NO_MATCH;
-    }
-
-    MethodSymbol method = ASTHelpers.getSymbol(tree);
-    Type matcherType = method.getReturnType();
-
-    // It is expected that the call to anyX() is itself the argument to another call which is
-    // the one being mocked, e.g. something like this:
-    //   when(mock.call(..., anyInt(), ...))...
-    TreePath path = state.getPath();
-    Tree parentTree = path.getParentPath().getLeaf();
-    if (!(parentTree instanceof MethodInvocationTree)) {
-      // Ignore calls that are not arguments to another method call.
-      // TODO: Report this as a problem because it makes little sense.
-      // TODO: Support casting.
-      return NO_MATCH;
-    }
-
-    MethodInvocationTree parentCall = (MethodInvocationTree) parentTree;
-    MethodSymbol parentMethod = ASTHelpers.getSymbol(parentCall);
-
-    // Find the index of the argument in the parent call.
-    int argumentIndex = -1;
-    List<? extends ExpressionTree> parentArguments = parentCall.getArguments();
-    for (int i = 0; i < parentArguments.size(); i++) {
-      ExpressionTree argumentTree = parentArguments.get(i);
-      if (argumentTree == tree) {
-        argumentIndex = i;
-        break;
-      }
-    }
-    if (argumentIndex == -1) {
-      throw new IllegalStateException(
-          "Cannot find argument " + tree + " in argument list from " + parentTree);
-    }
-
-    Type parameterType = getParameterType(parentMethod, argumentIndex);
-
-    TypeKind parameterTypeKind = parameterType.getKind();
-    if (parameterTypeKind.isPrimitive() && parameterTypeKind != matcherType.getKind()) {
-      String expectedTypeAsString = parameterType.toString();
-      String replacementName =
-          "any"
-              + Character.toUpperCase(expectedTypeAsString.charAt(0))
-              + expectedTypeAsString.substring(1);
-
-      String message = formatMessage(expectedTypeAsString, matcherType, replacementName);
-
-      SuggestedFix.Builder fixBuilder = SuggestedFix.builder();
-
-      ExpressionTree methodSelect = tree.getMethodSelect();
-      String replacement;
-      if (methodSelect instanceof MemberSelectTree) {
-        MemberSelectTree qualifier = (MemberSelectTree) methodSelect;
-        replacement = state.getSourceForNode(qualifier.getExpression()) + "." + replacementName;
-      } else {
-        replacement = replacementName;
-        String staticImport = method.owner + "." + replacementName;
-        fixBuilder.addStaticImport(staticImport);
-      }
-
-      SuggestedFix fix = fixBuilder.replace(tree, replacement + "()").build();
-
-      return buildDescription(tree).setMessage(message).addFix(fix).build();
-    }
-
-    return NO_MATCH;
-  }
-
-  /**
-   * Get the type of the parameter for a supplied argument.
-   *
-   * @param method the method symbol that is being called.
-   * @param argumentIndex the index of the argument, can be greater than the number of parameters
-   *     for a var arg method.
-   * @return the type of the associated parameter.
-   */
-  private Type getParameterType(MethodSymbol method, int argumentIndex) {
-    List<VarSymbol> parameters = method.getParameters();
-    Type parameterType;
-    int parameterCount = parameters.size();
-    if (argumentIndex >= parameterCount && method.isVarArgs()) {
-      VarSymbol varArgParameter = parameters.get(parameterCount - 1);
-      parameterType = ((ArrayType) varArgParameter.asType()).getComponentType();
-    } else {
-      parameterType = parameters.get(argumentIndex).asType();
-    }
-    return parameterType;
-  }
-}
diff --git a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveType.java b/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveType.java
deleted file mode 100644
index a076f2a0e7..0000000000
--- a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveType.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.matchers.Matchers;
-import com.google.errorprone.matchers.method.MethodMatchers.MethodNameMatcher;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
-
-/**
- * Matches on usage of {@code Mockito.argThat(Matcher)} with a matcher that does not extend
- * ArgumentMatcher.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    name = "MockitoAnyClassWithPrimitiveType",
-    summary = "Matcher inconsistency: use of any(Class) to match a primitive argument",
-    severity = WARNING,
-    linkType = CUSTOM,
-    link = "site.mockito.org/usage/bugpattern/MockitoAnyClassWithPrimitiveType",
-    explanation =
-        "Mockito relies on Java type checking to ensure that parameter matchers are"
-            + " type safe but there are some discrepancies between what the Java type checker"
-            + " allows and what Mockito expects. e.g. Java will allow anyInt() to be used as a"
-            + " matcher for a long parameter because an int can be widened to a long. This"
-            + " checker highlights those incorrect usages and suggests replacements. In Mockito"
-            + " 1.x this was not really an issue because the anyX() methods did not do runtime"
-            + " type checking of the arguments but in Mockito 2.x they do.")
-public class MockitoAnyClassWithPrimitiveType extends AbstractMockitoAnyForPrimitiveType {
-
-  private static final String[] CLASS_NAMES = {
-    "org.mockito.Mockito", "org.mockito.ArgumentMatchers", "org.mockito.Matchers"
-  };
-
-  // Match against the any() or any(Class) methods.
-  private static final MethodNameMatcher GENERIC_ANY =
-      Matchers.staticMethod().onClassAny(CLASS_NAMES).named("any");
-
-  @Override
-  protected Matcher<? super MethodInvocationTree> matcher() {
-    return GENERIC_ANY;
-  }
-
-  @Override
-  protected String formatMessage(
-      String expectedTypeAsString, Type matcherType, String replacementName) {
-    return String.format(
-        "Matcher mismatch: use %s() matcher to match primitive %s arguments",
-        replacementName, expectedTypeAsString);
-  }
-}
diff --git a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java b/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java
deleted file mode 100644
index 48b7ee11e1..0000000000
--- a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.CUSTOM;
-import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
-import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.matchers.Matcher;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
-import java.util.regex.Pattern;
-
-/**
- * Matches on usage of {@code Mockito.argThat(Matcher)} with a matcher that does not extend
- * ArgumentMatcher.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    name = "MockitoAnyIncorrectPrimitiveType",
-    summary = "Matcher mismatch: incorrect use of any() or anyX() to match a primitive argument",
-    severity = ERROR,
-    linkType = CUSTOM,
-    link = "site.mockito.org/usage/bugpattern/MockitoAnyIncorrectPrimitiveType",
-    explanation =
-        "Mockito relies on Java type checking to ensure that parameter matchers are"
-            + " type safe but there are some discrepancies between what the Java type checker"
-            + " allows and what Mockito expects. e.g. Java will allow anyInt() to be used as a"
-            + " matcher for a long parameter because an int can be widened to a long. This"
-            + " checker highlights those incorrect usages and suggests replacements. In Mockito"
-            + " 1.x this was not really an issue because the anyX() methods did not do runtime"
-            + " type checking of the arguments but in Mockito 2.x they do."
-            + " Java will also allow any() to be used within a primitive but any() returns null and"
-            + " the compiler wraps that call in unboxing which leads to a NPE.")
-public class MockitoAnyIncorrectPrimitiveType extends AbstractMockitoAnyForPrimitiveType {
-
-  // Match against any() or any of the any<x>() methods.
-  private static final Pattern METHOD_NAME_PATTERN =
-      Pattern.compile("any(Boolean|Byte|Char|Double|Float|Int|Long|Short)?");
-
-  private static final String[] CLASS_NAMES = {
-    "org.mockito.ArgumentMatchers", "org.mockito.Mockito", "org.mockito.Matchers"
-  };
-
-  private static final Matcher<ExpressionTree> METHOD_MATCHER =
-      staticMethod().onClassAny(CLASS_NAMES).withNameMatching(METHOD_NAME_PATTERN).withParameters();
-
-  @Override
-  protected Matcher<? super MethodInvocationTree> matcher() {
-    return METHOD_MATCHER;
-  }
-
-  @Override
-  protected String formatMessage(
-      String expectedTypeAsString, Type matcherType, String replacementName) {
-    return String.format(
-        "Matcher mismatch: expected matcher for parameter of type '%s',"
-            + " found matcher for parameter of type '%s'",
-        expectedTypeAsString, matcherType);
-  }
-}
diff --git a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsage.java b/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsage.java
deleted file mode 100644
index fbc9b381ec..0000000000
--- a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsage.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import static com.google.errorprone.matchers.Matchers.packageStartsWith;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.ProvidesFix;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MemberSelectTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.MemberSelectTree;
-import com.sun.source.tree.Tree;
-import com.sun.tools.javac.code.Symbol;
-
-/**
- * {@link com.google.errorprone.bugpatterns.BugChecker} that detects usages of
- * org.mockito.internal.*
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    name = "MockitoInternalUsage",
-    summary = "org.mockito.internal.* is a private API and should not be used by clients",
-    explanation =
-        "Classes under `org.mockito.internal.*` are internal implementation details and are"
-            + " not part of Mockito's public API. Mockito team does not support them, and they"
-            + " may change at any time. Depending on them may break your code when you upgrade"
-            + " to new versions of Mockito."
-            + "This checker ensures that your code will not break with future Mockito upgrades."
-            + "Mockito's public API is documented at"
-            + " https://www.javadoc.io/doc/org.mockito/mockito-core/. If you believe that there"
-            + " is no replacement available in the public API for your use-case, contact the"
-            + " Mockito team at https://github.com/mockito/mockito/issues.",
-    severity = SeverityLevel.WARNING,
-    providesFix = ProvidesFix.REQUIRES_HUMAN_ATTENTION)
-public class MockitoInternalUsage extends BugChecker implements MemberSelectTreeMatcher {
-
-  private static final Matcher<Tree> INSIDE_MOCKITO = packageStartsWith("org.mockito");
-
-  @Override
-  public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
-    if (INSIDE_MOCKITO.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-    Symbol symbol = ASTHelpers.getSymbol(tree);
-    if (symbol != null && symbol.getQualifiedName().toString().startsWith("org.mockito.internal")) {
-      return describeMatch(tree);
-    }
-    return Description.NO_MATCH;
-  }
-}
diff --git a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java b/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java
deleted file mode 100644
index daa49c240b..0000000000
--- a/subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import static com.google.errorprone.matchers.Description.NO_MATCH;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.SeverityLevel;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ClassTree;
-
-/** Finds subclasses of @NotExtensible interfaces. */
-@AutoService(BugChecker.class)
-@BugPattern(
-    name = "MockitoNotExtensible",
-    summary = "Some types that are a part of Mockito public API are not intended to be extended.",
-    explanation =
-        "Some types that are a part of Mockito public API are not intended to be extended."
-            + " It's because Mockito team needs to be able to add new methods to some types"
-            + " without breaking compatibility contract. Any type that is not intended"
-            + " to be extended is annotated with @NotExtensible.",
-    severity = SeverityLevel.ERROR)
-public class MockitoNotExtensible extends BugChecker implements ClassTreeMatcher {
-
-    @Override
-    public Description matchClass(ClassTree tree, VisitorState state) {
-        if (tree.getImplementsClause().stream()
-            .anyMatch(
-                implementing ->
-                    ASTHelpers.hasAnnotation(
-                        ASTHelpers.getSymbol(implementing), "org.mockito.NotExtensible", state))) {
-            return describeMatch(tree);
-        }
-
-        return NO_MATCH;
-    }
-}
diff --git a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveTypeTest.java b/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveTypeTest.java
deleted file mode 100644
index ded9722cbe..0000000000
--- a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyClassWithPrimitiveTypeTest.java
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Verify that there are no Mockito `any(Class)` matchers for arguments that are primitives.
- *
- * @author tvanderlippe@google.com (Tim van der Lippe)
- */
-@RunWith(JUnit4.class)
-public class MockitoAnyClassWithPrimitiveTypeTest {
-
-  private CompilationTestHelper compilationHelper;
-  private BugCheckerRefactoringTestHelper refactoringHelper;
-
-  @Before
-  public void setUp() {
-    compilationHelper = CompilationTestHelper.newInstance(MockitoAnyClassWithPrimitiveType.class, getClass());
-    refactoringHelper =
-        BugCheckerRefactoringTestHelper.newInstance(
-            new MockitoAnyClassWithPrimitiveType(), getClass());
-  }
-
-  @Test
-  public void testPositiveCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.run(any(Integer.class))).thenReturn(5);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.run(any())).thenReturn(5);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.runWithBoth(any(String.class), any())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(int arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, int arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testNegativeCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "import static org.mockito.ArgumentMatchers.anyInt;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    when(foo.run(any(String.class))).thenReturn(5);",
-            "    when(foo.runWithInt(anyInt())).thenReturn(5);",
-            "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(String arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithInt(int arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, int arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testPositivesSubclass() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "import static org.mockito.Mockito.any;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.run(any(Integer.class))).thenReturn(5);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.run(any())).thenReturn(5);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.runWithBoth(any(String.class), any())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(int arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, int arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testRefactoring() {
-    refactoringHelper
-        .addInputLines(
-            "Test.java",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    when(foo.run(any(Integer.class))).thenReturn(5);",
-            "    when(foo.run(any())).thenReturn(5);",
-            "    when(foo.runWithBoth(any(String.class), any())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(int arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, long arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .addOutputLines(
-            "Test.java",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "import static org.mockito.ArgumentMatchers.anyInt;",
-            "import static org.mockito.ArgumentMatchers.anyLong;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    when(foo.run(anyInt())).thenReturn(5);",
-            "    when(foo.run(anyInt())).thenReturn(5);",
-            "    when(foo.runWithBoth(any(String.class), anyLong())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(int arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, long arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-}
diff --git a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveTypeTest.java b/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveTypeTest.java
deleted file mode 100644
index 13bad9ecda..0000000000
--- a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveTypeTest.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Verify that there are no Mockito `any(Class)` matchers for arguments that are primitives.
- *
- * @author tvanderlippe@google.com (Tim van der Lippe)
- */
-@RunWith(JUnit4.class)
-public class MockitoAnyIncorrectPrimitiveTypeTest {
-
-  private CompilationTestHelper compilationHelper;
-  private BugCheckerRefactoringTestHelper refactoringHelper;
-
-  @Before
-  public void setUp() {
-    compilationHelper =
-        CompilationTestHelper.newInstance(MockitoAnyIncorrectPrimitiveType.class, getClass());
-    refactoringHelper =
-        BugCheckerRefactoringTestHelper.newInstance(
-            new MockitoAnyIncorrectPrimitiveType(), getClass());
-  }
-
-  @Test
-  public void testPositiveCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "import static org.mockito.ArgumentMatchers.anyInt;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.run(anyInt())).thenReturn(5);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(long arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, long arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testNegativeCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "import static org.mockito.ArgumentMatchers.anyFloat;",
-            "import static org.mockito.ArgumentMatchers.anyLong;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    when(foo.runWithInt(anyFloat())).thenReturn(5);",
-            "    when(foo.runWithBoth(any(String.class), anyLong())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(String arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithInt(float arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, long arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testPositivesSubclass() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "import static org.mockito.Mockito.any;",
-            "import static org.mockito.Mockito.anyInt;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.run(anyInt())).thenReturn(5);",
-            "    // BUG: Diagnostic contains:",
-            "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(long arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, float arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testRefactoring() {
-    refactoringHelper
-        .addInputLines(
-            "Test.java",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "import static org.mockito.ArgumentMatchers.anyInt;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    when(foo.run(anyInt())).thenReturn(5);",
-            "    when(foo.runWithBoth(any(String.class), anyInt())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(float arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, long arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .addOutputLines(
-            "Test.java",
-            "import static org.mockito.ArgumentMatchers.any;",
-            "import static org.mockito.ArgumentMatchers.anyFloat;",
-            "import static org.mockito.ArgumentMatchers.anyInt;",
-            "import static org.mockito.ArgumentMatchers.anyLong;",
-            "import static org.mockito.Mockito.mock;",
-            "import static org.mockito.Mockito.when;",
-            "class Test {",
-            "  public void test() {",
-            "    Foo foo = mock(Foo.class);",
-            "    when(foo.run(anyFloat())).thenReturn(5);",
-            "    when(foo.runWithBoth(any(String.class), anyLong())).thenReturn(5);",
-            "  }",
-            "  static class Foo {",
-            "    int run(float arg) {",
-            "      return 42;",
-            "    }",
-            "    int runWithBoth(String arg1, long arg2) {",
-            "      return 42;",
-            "    }",
-            "  }",
-            "}")
-        .doTest();
-  }
-}
diff --git a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsageTest.java b/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsageTest.java
deleted file mode 100644
index 2cba45228f..0000000000
--- a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoInternalUsageTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Verify that there are no usages of Mockito internal implementations.
- *
- * @author tvanderlippe@google.com (Tim van der Lippe)
- */
-@RunWith(JUnit4.class)
-public class MockitoInternalUsageTest {
-
-  private CompilationTestHelper compilationHelper;
-
-  @Before
-  public void setUp() {
-    compilationHelper = CompilationTestHelper.newInstance(MockitoInternalUsage.class, getClass());
-  }
-
-  @Test
-  public void testPositiveCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "import java.io.Serializable;",
-            "class MockitoInternalUsagePositiveCases {",
-            "  public void newObject() {",
-            "    // BUG: Diagnostic contains:",
-            "    new org.mockito.internal.MockitoCore();",
-            "    // BUG: Diagnostic contains:",
-            "    new InternalConsumer(new org.mockito.internal.MockitoCore());",
-            "  }",
-            "  public void staticMethodInvocation() {",
-            "    // BUG: Diagnostic contains:",
-            "    org.mockito.internal.configuration.GlobalConfiguration.validate();",
-            "  }",
-            "  public void variableTypeDeclaration() {",
-            "    // BUG: Diagnostic contains:",
-            "    org.mockito.internal.stubbing.InvocationContainerImpl container = null;",
-            "  }",
-            "  // BUG: Diagnostic contains:",
-            "  class ExtendsClause extends org.mockito.internal.MockitoCore {}",
-            "  // BUG: Diagnostic contains:",
-            "  abstract class ImplementsClause implements"
-                + " org.mockito.internal.junit.MockitoTestListener {}",
-            "  abstract class SecondImplementsClause",
-            "      // BUG: Diagnostic contains:",
-            "      implements Serializable, org.mockito.internal.junit.MockitoTestListener {}",
-            "  // BUG: Diagnostic contains:",
-            "  class ExtendsGeneric<T extends org.mockito.internal.stubbing.InvocationContainerImpl>"
-                + " {}",
-            "  // BUG: Diagnostic contains:",
-            "  class SecondExtendsGeneric<R, T extends"
-                + " org.mockito.internal.stubbing.InvocationContainerImpl> {}",
-            "  class FieldClause {",
-            "    // BUG: Diagnostic contains:",
-            "    org.mockito.internal.MockitoCore core;",
-            "  }",
-            "  class MethodArgumentClause {",
-            "    // BUG: Diagnostic contains:",
-            "    public void methodArgument(org.mockito.internal.MockitoCore core) {}",
-            "  }",
-            "  static class InternalConsumer {",
-            "    // BUG: Diagnostic contains:",
-            "    InternalConsumer(org.mockito.internal.MockitoCore core) {}",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  public void testPositiveImportsCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package foo;",
-            "// BUG: Diagnostic contains:",
-            "import org.mockito.internal.MockitoCore;",
-            "// BUG: Diagnostic contains:",
-            "import org.mockito.internal.stubbing.InvocationContainerImpl;",
-            "// BUG: Diagnostic contains:",
-            "import org.mockito.internal.*;",
-            "class Test {}")
-        .doTest();
-  }
-
-  @Test
-  public void testNegativeCases() {
-    compilationHelper
-        .addSourceLines(
-            "Test.java",
-            "package org.mockito;",
-            "import org.mockito.internal.MockitoCore;",
-            "class Mockito {}")
-        .doTest();
-  }
-}
diff --git a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java b/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java
deleted file mode 100644
index 4e0f3f7152..0000000000
--- a/subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.errorprone.bugpatterns;
-
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Verifies that there are no subclasses of {@link org.mockito.NotExtensible} Mockito types. */
-@RunWith(JUnit4.class)
-public class MockitoNotExtensibleTest {
-
-    private CompilationTestHelper compilationTestHelper;
-
-    @Before
-    public void setup() {
-        compilationTestHelper =
-            CompilationTestHelper.newInstance(MockitoNotExtensible.class, getClass());
-    }
-
-    @Test
-    public void notExtensibleSubclass_shouldWarn() {
-        compilationTestHelper
-            .addSourceLines(
-                "input.java",
-                "import org.mockito.invocation.InvocationOnMock;",
-                "// BUG: Diagnostic contains:",
-                "abstract class Invocation implements InvocationOnMock { }")
-            .doTest();
-    }
-
-    @Test
-    public void anonymousClassImplementingNotExtensible_shouldWarn() {
-        compilationTestHelper
-            .addSourceLines(
-                "input.java",
-                "import org.mockito.NotExtensible;",
-                "class Test {",
-                "  public void test() {",
-                "    // BUG: Diagnostic contains:",
-                "    new Anonymous() { };",
-                "  }",
-                "  @NotExtensible",
-                "  interface Anonymous {}",
-                "}")
-            .doTest();
-    }
-
-    @Test
-    public void anonymousClassImplementingOtherAnnotation_shouldNotWarn() {
-        compilationTestHelper
-            .addSourceLines(
-                "input.java",
-                "import org.mockito.NotExtensible;",
-                "class Test {",
-                "  public void test() {",
-                "    new Anonymous() { };",
-                "  }",
-                "  @OtherAnnotation",
-                "  interface Anonymous {}",
-                "  @interface OtherAnnotation {}",
-                "}")
-            .doTest();
-    }
-}
diff --git a/subprojects/extTest/extTest.gradle b/subprojects/extTest/extTest.gradle
deleted file mode 100644
index 35b9811af8..0000000000
--- a/subprojects/extTest/extTest.gradle
+++ /dev/null
@@ -1,23 +0,0 @@
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-apply plugin: 'java'
-description = "End-to-end tests for Mockito and its extensions."
-
-repositories {
-    mavenLocal() //we depend on locally published mockito
-}
-
-dependencies {
-    testCompile project.rootProject
-    testCompile project(":junit-jupiter")
-    testCompile project(path: ':', configuration: 'testUtil')
-    testCompile libraries.junit4
-    testCompile libraries.assertj
-    testCompile libraries.junitJupiterApi
-}
-
-configurations.all {
-    //TODO SF enable when #154 is implemented
-    //let's make those tests not use hamcrest
-    //exclude group: 'org.hamcrest', module: 'hamcrest-core'
-}
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider.java b/subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider.java
deleted file mode 100644
index 628c0fcc89..0000000000
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/instantiator/MyInstantiatorProvider.java
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.plugins.instantiator;
-
-import org.mockito.internal.creation.instance.Instantiator;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.InstantiatorProvider;
-
-@SuppressWarnings("deprecation")
-public class MyInstantiatorProvider implements InstantiatorProvider {
-    @Override
-    public Instantiator getInstantiator(MockCreationSettings<?> settings) {
-        throw new RuntimeException("Should never be called as there is InstantiatorProvider2 plugin");
-    }
-}
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/logger/MyMockitoLogger.java b/subprojects/extTest/src/test/java/org/mockitousage/plugins/logger/MyMockitoLogger.java
deleted file mode 100644
index 27b44da6f1..0000000000
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/logger/MyMockitoLogger.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.plugins.logger;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.mockito.internal.util.ConsoleMockitoLogger;
-import org.mockito.plugins.MockitoLogger;
-
-public class MyMockitoLogger implements MockitoLogger {
-    private static final ThreadLocal<Boolean> enabled = new ThreadLocal<Boolean>() {
-        @Override
-        protected Boolean initialValue() {
-            return false;
-        }
-    };
-    private static final ThreadLocal<List<Object>> loggedItems = new ThreadLocal<List<Object>>() {
-        @Override
-        protected List<Object> initialValue() {
-            return new ArrayList<Object>();
-        }
-    };
-
-    private final MockitoLogger defaultLogger = new ConsoleMockitoLogger();
-
-    @Override
-    public void log(Object what) {
-        if (enabled.get()) {
-            loggedItems.get().add(what);
-        } else {
-            defaultLogger.log(what);
-        }
-    }
-
-    static void enable() {
-        enabled.set(true);
-    }
-
-    static List<Object> getLoggedItems() {
-        return loggedItems.get();
-    }
-
-    static void clear() {
-        enabled.remove();
-        loggedItems.remove();
-    }
-}
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/PluginSwitchTest.java b/subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/PluginSwitchTest.java
deleted file mode 100644
index d61f150bae..0000000000
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/PluginSwitchTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage.plugins.switcher;
-
-import org.junit.Test;
-import org.mockitousage.plugins.instantiator.MyInstantiatorProvider2;
-import org.mockitousage.plugins.logger.MyMockitoLogger;
-import org.mockitousage.plugins.stacktrace.MyStackTraceCleanerProvider;
-
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-
-public class PluginSwitchTest {
-
-    @SuppressWarnings("CheckReturnValue")
-    @Test
-    public void plugin_switcher_is_used() {
-        mock(List.class);
-        assertEquals(MyPluginSwitch.invokedFor, asList(MyMockMaker.class.getName(),
-            MyStackTraceCleanerProvider.class.getName(),
-            MyMockitoLogger.class.getName(),
-            MyInstantiatorProvider2.class.getName()));
-    }
-
-    @Test
-    public void uses_custom_mock_maker() {
-        //when
-        MyMockMaker.explosive.set(new Object());
-
-        //when
-        try {
-            mock(List.class);
-            fail();
-        } catch (Exception e) {
-            assertEquals(MyMockMaker.class.getName(), e.getMessage());
-        } finally {
-            MyMockMaker.explosive.remove();
-        }
-    }
-}
diff --git a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider b/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider
deleted file mode 100644
index 68bb9b8365..0000000000
--- a/subprojects/extTest/src/test/resources/mockito-extensions/org.mockito.plugins.InstantiatorProvider
+++ /dev/null
@@ -1 +0,0 @@
-org.mockitousage.plugins.instantiator.MyInstantiatorProvider
diff --git a/subprojects/inline/inline.gradle b/subprojects/inline/inline.gradle
deleted file mode 100644
index 22db17b067..0000000000
--- a/subprojects/inline/inline.gradle
+++ /dev/null
@@ -1,14 +0,0 @@
-description = "Mockito preconfigured inline mock maker (intermediate and to be superseeded by automatic usage in a future version)"
-
-apply from: "$rootDir/gradle/java-library.gradle"
-
-dependencies {
-    compile project.rootProject
-    testCompile libraries.junit4
-}
-
-tasks.javadoc.enabled = false
-
-//required by the "StressTest.java" and "OneLinerStubStressTest.java"
-test.maxHeapSize = "256m"
-retryTest.maxHeapSize = "256m"
diff --git a/subprojects/inline/src/test/java/org/mockitoinline/PluginTest.java b/subprojects/inline/src/test/java/org/mockitoinline/PluginTest.java
deleted file mode 100644
index 19526db2a9..0000000000
--- a/subprojects/inline/src/test/java/org/mockitoinline/PluginTest.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitoinline;
-
-import org.junit.Test;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
-
-import static org.junit.Assert.*;
-
-public class PluginTest {
-
-    @Test
-    public void plugin_type_should_be_inline() throws Exception {
-        assertTrue(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker);
-    }
-
-}
diff --git a/subprojects/junit-jupiter/junit-jupiter.gradle b/subprojects/junit-jupiter/junit-jupiter.gradle
deleted file mode 100644
index 7cfc0b7de1..0000000000
--- a/subprojects/junit-jupiter/junit-jupiter.gradle
+++ /dev/null
@@ -1,15 +0,0 @@
-description = "Mockito JUnit 5 support"
-
-apply from: "$rootDir/gradle/java-library.gradle"
-
-dependencies {
-    compile project.rootProject
-    implementation libraries.junitJupiterApi
-    testCompile libraries.assertj
-    testCompile libraries.junitPlatformLauncher
-    testRuntime libraries.junitJupiterEngine
-}
-
-tasks.withType(Test) {
-    useJUnitPlatform()
-}
diff --git a/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java b/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java
deleted file mode 100644
index 6219506634..0000000000
--- a/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.junit.jupiter;
-
-
-import org.junit.jupiter.api.extension.AfterEachCallback;
-import org.junit.jupiter.api.extension.BeforeEachCallback;
-import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
-import org.junit.jupiter.api.extension.ParameterContext;
-import org.junit.jupiter.api.extension.ParameterResolutionException;
-import org.junit.jupiter.api.extension.ParameterResolver;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoSession;
-import org.mockito.internal.configuration.MockAnnotationProcessor;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.session.MockitoSessionLoggerAdapter;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.quality.Strictness;
-
-import java.lang.reflect.Parameter;
-import java.util.List;
-import java.util.Optional;
-
-import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.create;
-import static org.junit.platform.commons.support.AnnotationSupport.findAnnotation;
-
-/**
- * Extension that initializes mocks and handles strict stubbings. This extension is the JUnit Jupiter equivalent
- * of our JUnit4 {@link MockitoJUnitRunner}.
- *
- * Example usage:
- *
- * <pre class="code"><code class="java">
- * <b>&#064;ExtendWith(MockitoExtension.class)</b>
- * public class ExampleTest {
- *
- *     &#064;Mock
- *     private List&lt;Integer&gt; list;
- *
- *     &#064;Test
- *     public void shouldDoSomething() {
- *         list.add(100);
- *     }
- * }
- * </code></pre>
- *
- * If you would like to configure the used strictness for the test class, use {@link MockitoSettings}.
- *
- * <pre class="code"><code class="java">
- * <b>&#064;MockitoSettings(strictness = Strictness.STRICT_STUBS)</b>
- * public class ExampleTest {
- *
- *     &#064;Mock
- *     private List&lt;Integer&gt; list;
- *
- *     &#064;Test
- *     public void shouldDoSomething() {
- *         list.add(100);
- *     }
- * }
- * </code></pre>
- *
- * This extension also supports JUnit Jupiter's method parameters.
- * Use parameters for initialization of mocks that you use only in that specific test method.
- * In other words, where you would initialize local mocks in JUnit 4 by calling {@link Mockito#mock(Class)},
- * use the method parameter. This is especially beneficial when initializing a mock with generics, as you no
- * longer get a warning about "Unchecked assignment".
- * Please refer to JUnit Jupiter's documentation to learn when method parameters are useful.
- *
- * <pre class="code"><code class="java">
- * <b>&#064;ExtendWith(MockitoExtension.class)</b>
- * public class ExampleTest {
- *
- *     &#064;Mock
- *     private List&lt;Integer&gt; sharedList;
- *
- *     &#064;Test
- *     public void shouldDoSomething() {
- *         sharedList.add(100);
- *     }
- *
- *     &#064;Test
- *     public void hasLocalMockInThisTest(@Mock List&lt;Integer&gt; localList) {
- *         localList.add(100);
- *         sharedList.add(100);
- *     }
- * }
- * </code></pre>
- *
- * Lastly, the extension supports JUnit Jupiter's constructor parameters.
- * This allows you to do setup work in the constructor and set
- * your fields to <code>final</code>.
- * Please refer to JUnit Jupiter's documentation to learn when constructor parameters are useful.
- *
- * <pre class="code"><code class="java">
- * <b>&#064;ExtendWith(MockitoExtension.class)</b>
- * public class ExampleTest {
- *
- *      private final List&lt;Integer&gt; sharedList;
- *
- *      ExampleTest(&#064;Mock sharedList) {
- *          this.sharedList = sharedList;
- *      }
- *
- *      &#064;Test
- *      public void shouldDoSomething() {
- *          sharedList.add(100);
- *      }
- * }
- * </code></pre>
- */
-public class MockitoExtension implements BeforeEachCallback, AfterEachCallback, ParameterResolver {
-
-    private final static Namespace MOCKITO = create("org.mockito");
-
-    private final static String SESSION = "session";
-
-    private final Strictness strictness;
-
-    // This constructor is invoked by JUnit Jupiter via reflection or ServiceLoader
-    @SuppressWarnings("unused")
-    public MockitoExtension() {
-        this(Strictness.STRICT_STUBS);
-    }
-
-    private MockitoExtension(Strictness strictness) {
-        this.strictness = strictness;
-    }
-
-    /**
-     * Callback that is invoked <em>before</em> each test is invoked.
-     *
-     * @param context the current extension context; never {@code null}
-     */
-    @Override
-    public void beforeEach(final ExtensionContext context) {
-        List<Object> testInstances = context.getRequiredTestInstances().getAllInstances();
-
-        Strictness actualStrictness = this.retrieveAnnotationFromTestClasses(context)
-            .map(MockitoSettings::strictness)
-            .orElse(strictness);
-
-        MockitoSession session = Mockito.mockitoSession()
-            .initMocks(testInstances.toArray())
-            .strictness(actualStrictness)
-            .logger(new MockitoSessionLoggerAdapter(Plugins.getMockitoLogger()))
-            .startMocking();
-
-        context.getStore(MOCKITO).put(SESSION, session);
-    }
-
-    private Optional<MockitoSettings> retrieveAnnotationFromTestClasses(final ExtensionContext context) {
-        ExtensionContext currentContext = context;
-        Optional<MockitoSettings> annotation;
-
-        do {
-            annotation = findAnnotation(currentContext.getElement(), MockitoSettings.class);
-
-            if (!currentContext.getParent().isPresent()) {
-                break;
-            }
-
-            currentContext = currentContext.getParent().get();
-        } while (!annotation.isPresent() && currentContext != context.getRoot());
-
-        return annotation;
-    }
-
-    /**
-     * Callback that is invoked <em>after</em> each test has been invoked.
-     *
-     * @param context the current extension context; never {@code null}
-     */
-    @Override
-    public void afterEach(ExtensionContext context) {
-        context.getStore(MOCKITO).remove(SESSION, MockitoSession.class)
-                .finishMocking();
-    }
-
-    @Override
-    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
-        return parameterContext.isAnnotated(Mock.class);
-    }
-
-    @SuppressWarnings("ConstantConditions")
-    @Override
-    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
-        final Parameter parameter = parameterContext.getParameter();
-        return MockAnnotationProcessor.processAnnotationForMock(parameterContext.findAnnotation(Mock.class).get(), parameter.getType(), parameter.getName());
-    }
-}
diff --git a/subprojects/junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java b/subprojects/junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java
deleted file mode 100644
index df9fce5e88..0000000000
--- a/subprojects/junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-import java.util.function.Function;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@ExtendWith(MockitoExtension.class)
-class JunitJupiterTest {
-
-    @Mock
-    private Function<Integer, String> rootMock;
-
-    @InjectMocks
-    private ClassWithDependency classWithDependency;
-
-    @Test
-    void ensureMockCreationWorks() {
-        assertThat(rootMock).isNotNull();
-    }
-
-    @Test
-    void can_set_stubs_on_initialized_mock() {
-        Mockito.when(rootMock.apply(10)).thenReturn("Return");
-        assertThat(rootMock.apply(10)).isEqualTo("Return");
-    }
-
-    @Test
-    void initializes_parameters(@Mock Function<String, String> localMock) {
-        Mockito.when(localMock.apply("Para")).thenReturn("Meter");
-        assertThat(localMock.apply("Para")).isEqualTo("Meter");
-    }
-
-    @Test
-    void initializes_parameters_with_custom_configuration(@Mock(name = "overriddenName") Function<String, String> localMock) {
-        assertThat(MockUtil.getMockName(localMock).toString()).isEqualTo("overriddenName");
-    }
-
-    @Nested
-    class NestedTestWithConstructorParameter {
-        private final Function<Integer, String> constructorMock;
-
-        NestedTestWithConstructorParameter(@Mock Function<Integer, String> constructorMock) {
-            this.constructorMock = constructorMock;
-        }
-
-        @Test
-        void can_inject_into_constructor_parameter() {
-            Mockito.when(constructorMock.apply(42)).thenReturn("42");
-            assertThat(constructorMock.apply(42)).isEqualTo("42");
-        }
-    }
-
-    @Nested
-    class NestedTestWithExtraMock {
-        @Mock Runnable nestedMock;
-
-        @Test
-        void nestedMockCreated() {
-            assertThat(nestedMock).isNotNull();
-        }
-
-        @Test
-        void rootMockCreated() {
-            assertThat(rootMock).isNotNull();
-        }
-    }
-
-    @Nested
-    @ExtendWith(MockitoExtension.class)
-        // ^^ duplicate registration should be ignored by JUnit
-        // see http://junit.org/junit5/docs/current/user-guide/#extensions-registration-inherita
-    class DuplicateExtensionOnNestedTest {
-
-        @Mock
-        Object nestedMock;
-
-        @Test
-        void ensureMocksAreCreatedForNestedTests() {
-            assertThat(nestedMock).isNotNull();
-        }
-    }
-
-    @Nested
-    class NestedWithoutExtraMock {
-        @Test
-        // mock is initialized by mockito session
-        void shouldWeCreateMocksInTheParentContext() {
-            assertThat(rootMock).isNotNull();
-        }
-    }
-
-    @Test
-    void should_be_injected_correct_instance_of_mock() {
-        assertThat(classWithDependency.dependency).isSameAs(rootMock);
-    }
-
-    private static class ClassWithDependency {
-        private final Function<Integer, String> dependency;
-
-        private ClassWithDependency(Function<Integer, String> dependency) {
-            this.dependency = dependency;
-        }
-    }
-}
diff --git a/subprojects/junit-jupiter/src/test/java/org/mockitousage/StrictnessTest.java b/subprojects/junit-jupiter/src/test/java/org/mockitousage/StrictnessTest.java
deleted file mode 100644
index 560b2f1c73..0000000000
--- a/subprojects/junit-jupiter/src/test/java/org/mockitousage/StrictnessTest.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.platform.engine.TestExecutionResult;
-import org.junit.platform.launcher.Launcher;
-import org.junit.platform.launcher.LauncherDiscoveryRequest;
-import org.junit.platform.launcher.TestExecutionListener;
-import org.junit.platform.launcher.TestIdentifier;
-import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
-import org.junit.platform.launcher.core.LauncherFactory;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
-import org.mockito.junit.jupiter.MockitoSettings;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.mockito.quality.Strictness;
-
-import java.util.function.Function;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;
-
-/**
- * Test that runs the inner test using a launcher {@see #invokeTestClassAndRetrieveMethodResult}.
- * We then assert on the actual test run output, to see if test actually failed as a result
- * of our extension.
- */
-@SuppressWarnings("ConstantConditions")
-class StrictnessTest {
-
-    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
-    static class StrictStubs {
-        @Mock
-        private Function<Integer, String> rootMock;
-
-        @Test
-        void should_throw_an_exception_on_strict_stubs() {
-            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
-        }
-    }
-
-    @Test
-    void session_checks_for_strict_stubs() {
-        TestExecutionResult result = invokeTestClassAndRetrieveMethodResult(StrictStubs.class);
-
-        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
-        assertThat(result.getThrowable().get()).isInstanceOf(UnnecessaryStubbingException.class);
-    }
-
-    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
-    static class ConfiguredStrictStubs {
-        @Nested
-        class NestedStrictStubs {
-            @Mock
-            private Function<Integer, String> rootMock;
-
-            @Test
-            void should_throw_an_exception_on_strict_stubs_in_a_nested_class() {
-                Mockito.when(rootMock.apply(10)).thenReturn("Foo");
-            }
-        }
-    }
-
-    @Test
-    void session_can_retrieve_strictness_from_parent_class() {
-        TestExecutionResult result = invokeTestClassAndRetrieveMethodResult(ConfiguredStrictStubs.class);
-
-        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
-        assertThat(result.getThrowable().get()).isInstanceOf(UnnecessaryStubbingException.class);
-    }
-
-    @MockitoSettings(strictness = Strictness.STRICT_STUBS)
-    static class ParentConfiguredStrictStubs {
-        @Nested
-        @MockitoSettings(strictness = Strictness.WARN)
-        class ChildConfiguredWarnStubs {
-            @Mock
-            private Function<Integer, String> rootMock;
-
-            @Test
-            void should_throw_an_exception_on_strict_stubs_in_a_nested_class() {
-                Mockito.when(rootMock.apply(10)).thenReturn("Foo");
-            }
-        }
-    }
-
-    @Test
-    void session_retrieves_closest_strictness_configuration() {
-        TestExecutionResult result = invokeTestClassAndRetrieveMethodResult(ParentConfiguredStrictStubs.class);
-
-        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.SUCCESSFUL);
-    }
-
-    @ExtendWith(MockitoExtension.class)
-    static class ByDefaultUsesStrictStubs {
-
-        @Mock
-        private Function<Integer, String> rootMock;
-
-        @Test
-        void should_throw_an_exception_on_strict_stubs_configured_by_default() {
-            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
-        }
-
-    }
-
-    @Test
-    void by_default_configures_strict_stubs_in_runner() {
-        TestExecutionResult result = invokeTestClassAndRetrieveMethodResult(ByDefaultUsesStrictStubs.class);
-
-        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.FAILED);
-        assertThat(result.getThrowable().get()).isInstanceOf(UnnecessaryStubbingException.class);
-    }
-
-    @MockitoSettings(strictness = Strictness.WARN)
-    static class BaseWarnStubs {}
-
-    static class InheritedWarnStubs extends BaseWarnStubs {
-        @Mock
-        private Function<Integer, String> rootMock;
-
-        @Test
-        void should_execute_successfully_on_warn_stubs_inherited_from_base_class() {
-            Mockito.when(rootMock.apply(10)).thenReturn("Foo");
-        }
-    }
-
-    @Test
-    void inherits_strictness_from_base_class() {
-        TestExecutionResult result = invokeTestClassAndRetrieveMethodResult(InheritedWarnStubs.class);
-
-        assertThat(result.getStatus()).isEqualTo(TestExecutionResult.Status.SUCCESSFUL);
-    }
-
-    private TestExecutionResult invokeTestClassAndRetrieveMethodResult(Class<?> clazz) {
-        LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
-            .selectors(
-                selectClass(clazz)
-            )
-            .build();
-
-        Launcher launcher = LauncherFactory.create();
-
-        final TestExecutionResult[] result = new TestExecutionResult[1];
-
-        launcher.registerTestExecutionListeners(new TestExecutionListener() {
-            @Override
-            public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
-                if (testIdentifier.getDisplayName().endsWith("()")) {
-                    result[0] = testExecutionResult;
-                }
-            }
-
-        });
-
-        launcher.execute(request);
-
-        return result[0];
-    }
-}
diff --git a/subprojects/junit-jupiter/src/test/java/org/mockitousage/UninstantiableThrowableTest.java b/subprojects/junit-jupiter/src/test/java/org/mockitousage/UninstantiableThrowableTest.java
deleted file mode 100644
index 2ef3128016..0000000000
--- a/subprojects/junit-jupiter/src/test/java/org/mockitousage/UninstantiableThrowableTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-import org.assertj.core.api.Assertions;
-import org.junit.jupiter.api.RepeatedTest;
-import org.junit.jupiter.api.RepetitionInfo;
-import org.mockito.Mockito;
-
-import java.util.List;
-
-//issue 1514
-class UninstantiableThrowableTest {
-
-    @RepeatedTest(2)
-    void should_behave_consistently(RepetitionInfo i) {
-        List mock = Mockito.mock(List.class);
-        if (i.getCurrentRepetition() == 1) {
-            Assertions.assertThatThrownBy(
-                () -> Mockito.doThrow(UninstantiableException.class).when(mock).clear())
-                .isInstanceOf(InstantiationError.class);
-        }
-
-        // The following operation results in "UnfinishedStubbing"
-        Mockito.doThrow(RuntimeException.class).when(mock).clear();
-    }
-
-    abstract static class UninstantiableException extends RuntimeException { }
-}
diff --git a/subprojects/junitJupiterExtensionTest/junitJupiterExtensionTest.gradle.kts b/subprojects/junitJupiterExtensionTest/junitJupiterExtensionTest.gradle.kts
deleted file mode 100644
index ad78a43b1f..0000000000
--- a/subprojects/junitJupiterExtensionTest/junitJupiterExtensionTest.gradle.kts
+++ /dev/null
@@ -1,25 +0,0 @@
-apply(from = "$rootDir/gradle/dependencies.gradle")
-
-plugins {
-    java
-}
-
-description = "End-to-end tests for automatic registration of MockitoExtension."
-
-dependencies {
-    testCompile(project(":junit-jupiter"))
-    testCompile(library("assertj"))
-    testCompile(library("junitPlatformLauncher"))
-    testCompile(library("junitJupiterApi"))
-    testRuntime(library("junitJupiterEngine"))
-}
-
-tasks.named<Test>("test") {
-    useJUnitPlatform()
-}
-
-val Project.libraries
-    get() = rootProject.extra["libraries"] as Map<String, Any>
-
-fun Project.library(name: String) =
-    libraries[name]!!
diff --git a/subprojects/junitJupiterExtensionTest/src/test/java/org/mockitousage/NoExtendsTest.java b/subprojects/junitJupiterExtensionTest/src/test/java/org/mockitousage/NoExtendsTest.java
deleted file mode 100644
index a0d545c6b1..0000000000
--- a/subprojects/junitJupiterExtensionTest/src/test/java/org/mockitousage/NoExtendsTest.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockitousage;
-
-
-import java.util.List;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
-
-class NoExtendsTest {
-
-    @Mock
-    private List<String> mock;
-
-    @Test
-    void runs() {
-        when(mock.get(0)).thenReturn("foo");
-        assertThat(mock.get(0)).isEqualTo("foo");
-    }
-}
diff --git a/subprojects/junitJupiterParallelTest/junitJupiterParallelTest.gradle b/subprojects/junitJupiterParallelTest/junitJupiterParallelTest.gradle
deleted file mode 100644
index 6da4f3b4d7..0000000000
--- a/subprojects/junitJupiterParallelTest/junitJupiterParallelTest.gradle
+++ /dev/null
@@ -1,15 +0,0 @@
-description = "Tests that require fine tuned parallel settings for JUnit Jupiter (bug #1630)"
-
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-apply plugin: "java"
-
-dependencies {
-    testImplementation libraries.junitJupiterApi
-    testImplementation project(":junit-jupiter")
-    testRuntime libraries.junitJupiterEngine
-}
-
-test {
-    useJUnitPlatform()
-}
diff --git a/subprojects/kotlinReleaseCoroutinesTest/kotlinReleaseCoroutinesTest.gradle b/subprojects/kotlinReleaseCoroutinesTest/kotlinReleaseCoroutinesTest.gradle
deleted file mode 100644
index 0812f26b35..0000000000
--- a/subprojects/kotlinReleaseCoroutinesTest/kotlinReleaseCoroutinesTest.gradle
+++ /dev/null
@@ -1,26 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
-    }
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${libraries.kotlin.version_1_3}"
-    }
-}
-
-apply plugin: "org.jetbrains.kotlin.jvm"
-
-description = "Kotlin tests for Mockito."
-
-repositories {
-    mavenCentral()
-    maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
-}
-
-dependencies {
-    testCompile project(":")
-    testCompile libraries.junit4
-
-    testCompile libraries.kotlin.stdlib_1_3
-    testCompile libraries.kotlin.releaseCoroutines
-}
diff --git a/subprojects/kotlinReleaseCoroutinesTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt b/subprojects/kotlinReleaseCoroutinesTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
deleted file mode 100644
index 85131ac6f8..0000000000
--- a/subprojects/kotlinReleaseCoroutinesTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
+++ /dev/null
@@ -1,128 +0,0 @@
-/**
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.kotlin
-
-import kotlinx.coroutines.runBlocking
-import org.hamcrest.core.IsEqual
-import org.junit.Assert.assertThat
-import org.junit.Test
-import org.mockito.Mockito.*
-
-/**
- * Test for mocking and verifying Kotlin suspending functions.
- */
-class SuspendTest {
-    interface SuspendableInterface {
-        suspend fun suspendFunction(x: Int): Int
-        suspend fun suspendFunctionWithDefault(x: Int = 1): Int
-    }
-
-    open class SuspendableClass : SuspendableInterface {
-        suspend override fun suspendFunction(x: Int): Int = error("not implemented")
-        suspend override fun suspendFunctionWithDefault(x: Int): Int = error("not implemented")
-        suspend open fun suspendClassFunctionWithDefault(x: Int = 1): Int = error("not implemented")
-    }
-
-    class FinalSuspendableClass {
-        suspend fun fetch(): Int {
-            fetchConcrete()
-            return 2
-        }
-
-        suspend fun fetchConcrete() = 1
-    }
-
-    open class CallsSuspendable(private val suspendable: SuspendableInterface) {
-        fun callSuspendable(x: Int) = runBlocking {
-            suspendable.suspendFunction(x)
-        }
-
-        fun suspendFunctionWithDefault() = runBlocking {
-            suspendable.suspendFunctionWithDefault()
-        }
-
-        fun suspendFunctionWithDefault(x: Int) = runBlocking {
-            suspendable.suspendFunctionWithDefault(x)
-        }
-    }
-
-    class CallsSuspendableClass(private val suspendable: SuspendableClass) : CallsSuspendable(suspendable) {
-        fun suspendClassFunctionWithDefault() = runBlocking {
-            suspendable.suspendClassFunctionWithDefault()
-        }
-
-        fun suspendClassFunctionWithDefault(x: Int) = runBlocking {
-            suspendable.suspendClassFunctionWithDefault(x)
-        }
-    }
-
-    @Test
-    fun shouldMockSuspendInterfaceFunction() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
-        val callsSuspendable = CallsSuspendable(mockSuspendable)
-
-        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
-        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
-        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendFunction(1)
-        verify(mockSuspendable).suspendFunction(2)
-    }
-
-    @Test
-    fun shouldMockSuspendInterfaceFunctionWithDefault() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
-        val callsSuspendable = CallsSuspendable(mockSuspendable)
-
-        `when`(mockSuspendable.suspendFunctionWithDefault()).thenReturn(2)
-        `when`(mockSuspendable.suspendFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.suspendFunctionWithDefault(), IsEqual(2))
-        assertThat(callsSuspendable.suspendFunctionWithDefault(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendFunctionWithDefault()
-        verify(mockSuspendable).suspendFunctionWithDefault(2)
-    }
-
-    @Test
-    fun shouldMockSuspendClassFunction() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
-        val callsSuspendable = CallsSuspendable(mockSuspendable)
-
-        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
-        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
-        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendFunction(1)
-        verify(mockSuspendable).suspendFunction(2)
-    }
-
-    @Test
-    fun shouldMockSuspendClassFunctionWithDefault() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
-        val callsSuspendable = CallsSuspendableClass(mockSuspendable)
-
-        `when`(mockSuspendable.suspendClassFunctionWithDefault()).thenReturn(2)
-        `when`(mockSuspendable.suspendClassFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.suspendClassFunctionWithDefault(), IsEqual(2))
-        assertThat(callsSuspendable.suspendClassFunctionWithDefault(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendClassFunctionWithDefault()
-        verify(mockSuspendable).suspendClassFunctionWithDefault(2)
-    }
-
-    @Test
-    fun shouldMockFinalSuspendableClass() = runBlocking<Unit> {
-        val mockClass = mock(FinalSuspendableClass::class.java)
-        `when`(mockClass.fetch()).thenReturn(10)
-        assertThat(mockClass.fetch(), IsEqual(10))
-        verify(mockClass).fetch()
-    }
-}
diff --git a/subprojects/kotlinTest/kotlinTest.gradle b/subprojects/kotlinTest/kotlinTest.gradle
deleted file mode 100644
index 38eb74b166..0000000000
--- a/subprojects/kotlinTest/kotlinTest.gradle
+++ /dev/null
@@ -1,23 +0,0 @@
-plugins {
-    // Can not use libraries.kotlin.version here per https://stackoverflow.com/questions/37555196/in-gradle-how-to-use-a-variable-for-a-plugin-version
-    id 'org.jetbrains.kotlin.jvm' version '1.2.31'
-    id 'java'
-}
-
-description = "Kotlin tests for Mockito."
-
-kotlin {
-    experimental {
-        coroutines "enable"
-    }
-}
-
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-dependencies {
-    testCompile project(":")
-    testCompile libraries.junit4
-
-    testCompile libraries.kotlin.stdlib
-    testCompile libraries.kotlin.coroutines
-}
diff --git a/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/CircularityTest.kt b/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/CircularityTest.kt
deleted file mode 100644
index 82fccea672..0000000000
--- a/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/CircularityTest.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package org.mockito.kotlin
-
-import org.junit.Before
-import org.junit.Test
-import org.mockito.Mockito
-
-class MyClass
-
-class MyTest {
-
-    private lateinit var myClassMock: MyClass
-
-    @Before
-    fun `before each`() {
-        myClassMock = Mockito.mock(MyClass::class.java)
-    }
-
-    @Test
-    fun `some test`() { }
-}
diff --git a/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt b/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
deleted file mode 100644
index bfef4071e4..0000000000
--- a/subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt
+++ /dev/null
@@ -1,128 +0,0 @@
-/**
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.kotlin
-
-import kotlinx.coroutines.experimental.runBlocking
-import org.hamcrest.core.IsEqual
-import org.junit.Assert.assertThat
-import org.junit.Test
-import org.mockito.Mockito.*
-
-/**
- * Test for mocking and verifying Kotlin suspending functions.
- */
-class SuspendTest {
-    interface SuspendableInterface {
-        suspend fun suspendFunction(x: Int): Int
-        suspend fun suspendFunctionWithDefault(x: Int = 1): Int
-    }
-
-    open class SuspendableClass : SuspendableInterface {
-        suspend override fun suspendFunction(x: Int): Int = error("not implemented")
-        suspend override fun suspendFunctionWithDefault(x: Int): Int = error("not implemented")
-        suspend open fun suspendClassFunctionWithDefault(x: Int = 1): Int = error("not implemented")
-    }
-
-    class FinalSuspendableClass {
-        suspend fun fetch(): Int {
-            fetchConcrete()
-            return 2
-        }
-
-        suspend fun fetchConcrete() = 1
-    }
-
-    open class CallsSuspendable(private val suspendable: SuspendableInterface) {
-        fun callSuspendable(x: Int) = runBlocking {
-            suspendable.suspendFunction(x)
-        }
-
-        fun suspendFunctionWithDefault() = runBlocking {
-            suspendable.suspendFunctionWithDefault()
-        }
-
-        fun suspendFunctionWithDefault(x: Int) = runBlocking {
-            suspendable.suspendFunctionWithDefault(x)
-        }
-    }
-
-    class CallsSuspendableClass(private val suspendable: SuspendableClass) : CallsSuspendable(suspendable) {
-        fun suspendClassFunctionWithDefault() = runBlocking {
-            suspendable.suspendClassFunctionWithDefault()
-        }
-
-        fun suspendClassFunctionWithDefault(x: Int) = runBlocking {
-            suspendable.suspendClassFunctionWithDefault(x)
-        }
-    }
-
-    @Test
-    fun shouldMockSuspendInterfaceFunction() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
-        val callsSuspendable = CallsSuspendable(mockSuspendable)
-
-        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
-        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
-        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendFunction(1)
-        verify(mockSuspendable).suspendFunction(2)
-    }
-
-    @Test
-    fun shouldMockSuspendInterfaceFunctionWithDefault() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableInterface = mock(SuspendableInterface::class.java)
-        val callsSuspendable = CallsSuspendable(mockSuspendable)
-
-        `when`(mockSuspendable.suspendFunctionWithDefault()).thenReturn(2)
-        `when`(mockSuspendable.suspendFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.suspendFunctionWithDefault(), IsEqual(2))
-        assertThat(callsSuspendable.suspendFunctionWithDefault(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendFunctionWithDefault()
-        verify(mockSuspendable).suspendFunctionWithDefault(2)
-    }
-
-    @Test
-    fun shouldMockSuspendClassFunction() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
-        val callsSuspendable = CallsSuspendable(mockSuspendable)
-
-        `when`(mockSuspendable.suspendFunction(1)).thenReturn(2)
-        `when`(mockSuspendable.suspendFunction(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.callSuspendable(1), IsEqual(2))
-        assertThat(callsSuspendable.callSuspendable(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendFunction(1)
-        verify(mockSuspendable).suspendFunction(2)
-    }
-
-    @Test
-    fun shouldMockSuspendClassFunctionWithDefault() = runBlocking<Unit> {
-        val mockSuspendable: SuspendableClass = mock(SuspendableClass::class.java)
-        val callsSuspendable = CallsSuspendableClass(mockSuspendable)
-
-        `when`(mockSuspendable.suspendClassFunctionWithDefault()).thenReturn(2)
-        `when`(mockSuspendable.suspendClassFunctionWithDefault(intThat { it >= 2 })).thenReturn(4)
-
-        assertThat(callsSuspendable.suspendClassFunctionWithDefault(), IsEqual(2))
-        assertThat(callsSuspendable.suspendClassFunctionWithDefault(2), IsEqual(4))
-
-        verify(mockSuspendable).suspendClassFunctionWithDefault()
-        verify(mockSuspendable).suspendClassFunctionWithDefault(2)
-    }
-
-    @Test
-    fun shouldMockFinalSuspendableClass() = runBlocking<Unit> {
-        val mockClass = mock(FinalSuspendableClass::class.java)
-        `when`(mockClass.fetch()).thenReturn(10)
-        assertThat(mockClass.fetch(), IsEqual(10))
-        verify(mockClass).fetch()
-    }
-}
diff --git a/subprojects/kotlinTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/subprojects/kotlinTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
deleted file mode 100644
index ca6ee9cea8..0000000000
--- a/subprojects/kotlinTest/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
+++ /dev/null
@@ -1 +0,0 @@
-mock-maker-inline
\ No newline at end of file
diff --git a/subprojects/memory-test/memory-test.gradle b/subprojects/memory-test/memory-test.gradle
deleted file mode 100644
index a53d479a0c..0000000000
--- a/subprojects/memory-test/memory-test.gradle
+++ /dev/null
@@ -1,19 +0,0 @@
-plugins {
-    id 'java'
-}
-description = "Test suite memory usage of Mockito"
-
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-dependencies {
-    compile project.rootProject
-    testCompile libraries.junit4
-    testCompile libraries.assertj
-}
-
-tasks.javadoc.enabled = false
-
-test {
-    maxHeapSize = "128m"
-    jvmArgs = ["-XX:MaxPermSize=128m"]
-}
diff --git a/subprojects/module-test/module-test.gradle b/subprojects/module-test/module-test.gradle
deleted file mode 100644
index 2373407c34..0000000000
--- a/subprojects/module-test/module-test.gradle
+++ /dev/null
@@ -1,22 +0,0 @@
-plugins {
-    id 'java'
-}
-
-if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
-    project.tasks.all { task -> task.enabled = false }
-}
-
-description = "Test suite for Java 9 modules with Mockito"
-
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-dependencies {
-    compile project.rootProject
-    testCompile libraries.junit4
-    testCompile libraries.assertj
-}
-
-tasks.javadoc.enabled = false
-
-sourceCompatibility = 1.9
-targetCompatibility = 1.9
diff --git a/subprojects/module-test/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java b/subprojects/module-test/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java
deleted file mode 100644
index ed732c8089..0000000000
--- a/subprojects/module-test/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java
+++ /dev/null
@@ -1,417 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.moduletest;
-
-import java.util.concurrent.locks.Lock;
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.description.modifier.Visibility;
-import net.bytebuddy.dynamic.loading.ClassInjector;
-import net.bytebuddy.implementation.FixedValue;
-import net.bytebuddy.jar.asm.ClassWriter;
-import net.bytebuddy.jar.asm.ModuleVisitor;
-import net.bytebuddy.jar.asm.Opcodes;
-import net.bytebuddy.utility.OpenedClassReader;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.mockito.Mockito;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
-import org.mockito.stubbing.OngoingStubbing;
-
-import java.io.IOException;
-import java.lang.module.Configuration;
-import java.lang.module.ModuleDescriptor;
-import java.lang.module.ModuleFinder;
-import java.lang.module.ModuleReader;
-import java.lang.module.ModuleReference;
-import java.lang.reflect.InvocationTargetException;
-import java.net.MalformedURLException;
-import java.net.URI;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.Callable;
-import java.util.jar.JarEntry;
-import java.util.jar.JarOutputStream;
-import java.util.stream.Stream;
-
-import static net.bytebuddy.matcher.ElementMatchers.named;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assume.assumeThat;
-
-@RunWith(Parameterized.class)
-public class ModuleHandlingTest {
-
-    @Parameterized.Parameters
-    public static Collection<Object[]> data() {
-        return Arrays.asList(new Object[][]{
-            {true}, {false}
-        });
-    }
-
-    private final boolean namedModules;
-
-    public ModuleHandlingTest(boolean namedModules) {
-        this.namedModules = namedModules;
-    }
-
-    @Test
-    public void can_define_class_in_open_reading_module() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-
-        Path jar = modularJar(true, true, true);
-        ModuleLayer layer = layer(jar, true);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
-            assertThat(mock.call()).isEqualTo("foo");
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void can_define_class_in_open_java_util_module() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-
-        Path jar = modularJar(true, true, true);
-        ModuleLayer layer = layer(jar, true);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("java.util.concurrent.locks.Lock");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Lock mock = (Lock) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.tryLock());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenReturn", Object.class).invoke(stubbing, true);
-
-            boolean relocated = !Boolean.getBoolean("org.mockito.internal.noUnsafeInjection") && ClassInjector.UsingReflection.isAvailable();
-            String prefix = relocated ? "org.mockito.codegen.Lock$MockitoMock$" : "java.util.concurrent.locks.Lock$MockitoMock$";
-            assertThat(mock.getClass().getName()).startsWith(prefix);
-            assertThat(mock.tryLock()).isEqualTo(true);
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void inline_mock_maker_can_mock_closed_modules() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(true));
-
-        Path jar = modularJar(false, false, false);
-        ModuleLayer layer = layer(jar, false);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        Class<?> mockito = loader.loadClass(Mockito.class.getName());
-        @SuppressWarnings("unchecked")
-        Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-        Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-        loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-        assertThat(mock.getClass().getName()).isEqualTo("sample.MyCallable");
-        assertThat(mock.call()).isEqualTo("foo");
-    }
-
-    @Test
-    public void can_define_class_in_open_reading_private_module() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-
-        Path jar = modularJar(false, true, true);
-        ModuleLayer layer = layer(jar, true);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
-            assertThat(mock.call()).isEqualTo("foo");
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void can_define_class_in_open_non_reading_module() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-
-        Path jar = modularJar(true, true, true);
-        ModuleLayer layer = layer(jar, false);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
-            assertThat(mock.call()).isEqualTo("foo");
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void can_define_class_in_open_non_reading_non_exporting_module() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-
-        Path jar = modularJar(true, false, true);
-        ModuleLayer layer = layer(jar, false);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
-            assertThat(mock.call()).isEqualTo("foo");
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void can_define_class_in_closed_module() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-
-        Path jar = modularJar(true, true, false);
-        ModuleLayer layer = layer(jar, false);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-            boolean relocated = !Boolean.getBoolean("org.mockito.internal.noUnsafeInjection") && ClassInjector.UsingReflection.isAvailable();
-            String prefix = relocated ? "sample.MyCallable$MockitoMock$" : "org.mockito.codegen.MyCallable$MockitoMock$";
-            assertThat(mock.getClass().getName()).startsWith(prefix);
-            assertThat(mock.call()).isEqualTo("foo");
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void cannot_define_class_in_non_opened_non_exported_module_if_lookup_injection() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-        assumeThat(!Boolean.getBoolean("org.mockito.internal.noUnsafeInjection") && ClassInjector.UsingReflection.isAvailable(), is(true));
-
-        Path jar = modularJar(false, false, false);
-        ModuleLayer layer = layer(jar, false);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            @SuppressWarnings("unchecked")
-            Callable<String> mock = (Callable<String>) mockito.getMethod("mock", Class.class).invoke(null, type);
-            Object stubbing = mockito.getMethod("when", Object.class).invoke(null, mock.call());
-            loader.loadClass(OngoingStubbing.class.getName()).getMethod("thenCallRealMethod").invoke(stubbing);
-
-            assertThat(mock.getClass().getName()).startsWith("sample.MyCallable$MockitoMock$");
-            assertThat(mock.call()).isEqualTo("foo");
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    @Test
-    public void can_define_class_in_non_opened_non_exported_module_if_unsafe_injection() throws Exception {
-        assumeThat(Plugins.getMockMaker() instanceof InlineByteBuddyMockMaker, is(false));
-        assumeThat(!Boolean.getBoolean("org.mockito.internal.noUnsafeInjection") && ClassInjector.UsingReflection.isAvailable(), is(false));
-
-        Path jar = modularJar(false, false, false);
-        ModuleLayer layer = layer(jar, false);
-
-        ClassLoader loader = layer.findLoader("mockito.test");
-        Class<?> type = loader.loadClass("sample.MyCallable");
-
-        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
-        Thread.currentThread().setContextClassLoader(loader);
-        try {
-            Class<?> mockito = loader.loadClass(Mockito.class.getName());
-            try {
-                mockito.getMethod("mock", Class.class).invoke(null, type);
-                fail("Expected mocking to fail");
-            } catch (InvocationTargetException e) {
-                assertThat(e.getTargetException()).isInstanceOf(loader.loadClass(MockitoException.class.getName()));
-            }
-        } finally {
-            Thread.currentThread().setContextClassLoader(contextLoader);
-        }
-    }
-
-    private static Path modularJar(boolean isPublic, boolean isExported, boolean isOpened) throws IOException {
-        Path jar = Files.createTempFile("sample-module", ".jar");
-        try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(jar))) {
-            out.putNextEntry(new JarEntry("module-info.class"));
-            out.write(moduleInfo(isExported, isOpened));
-            out.closeEntry();
-            out.putNextEntry(new JarEntry("sample/MyCallable.class"));
-            out.write(type(isPublic));
-            out.closeEntry();
-        }
-        return jar;
-    }
-
-    private static byte[] type(boolean isPublic) {
-        return new ByteBuddy()
-            .subclass(Callable.class)
-            .name("sample.MyCallable")
-            .merge(isPublic ? Visibility.PUBLIC : Visibility.PACKAGE_PRIVATE)
-            .method(named("call"))
-            .intercept(FixedValue.value("foo"))
-            .make()
-            .getBytes();
-    }
-
-    private static byte[] moduleInfo(boolean isExported, boolean isOpened) {
-        ClassWriter classWriter = new ClassWriter(OpenedClassReader.ASM_API);
-        classWriter.visit(Opcodes.V9, Opcodes.ACC_MODULE, "module-info", null, null, null);
-        ModuleVisitor mv = classWriter.visitModule("mockito.test", 0, null);
-        mv.visitRequire("java.base", Opcodes.ACC_MANDATED, null);
-        mv.visitPackage("sample");
-        if (isExported) {
-            mv.visitExport("sample", 0);
-        }
-        if (isOpened) {
-            mv.visitOpen("sample", 0);
-        }
-        mv.visitEnd();
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    private ModuleLayer layer(Path jar, boolean canRead) throws MalformedURLException {
-        Set<String> modules = new HashSet<>();
-        modules.add("mockito.test");
-        ModuleFinder moduleFinder = ModuleFinder.of(jar);
-        if (namedModules) {
-            modules.add("org.mockito");
-            modules.add("net.bytebuddy");
-            modules.add("net.bytebuddy.agent");
-            // We do not list all packages but only roots and packages that interact with the mock where
-            // we attempt to validate an interaction of two modules. This is of course a bit hacky as those
-            // libraries would normally be entirely encapsulated in an automatic module with all their classes
-            // but it is sufficient for the test and saves us a significant amount of code.
-            moduleFinder = ModuleFinder.compose(moduleFinder,
-                automaticModule("org.mockito", "org.mockito", "org.mockito.internal.creation.bytebuddy"),
-                automaticModule("net.bytebuddy", "net.bytebuddy"),
-                automaticModule("net.bytebuddy.agent", "net.bytebuddy.agent"));
-        }
-        Configuration configuration = Configuration.resolve(
-            moduleFinder,
-            Collections.singletonList(ModuleLayer.boot().configuration()),
-            ModuleFinder.of(),
-            modules
-        );
-        ClassLoader classLoader = new ReplicatingClassLoader(jar);
-        ModuleLayer.Controller controller = ModuleLayer.defineModules(
-            configuration,
-            Collections.singletonList(ModuleLayer.boot()),
-            module -> classLoader
-        );
-        if (canRead) {
-            controller.addReads(
-                controller.layer().findModule("mockito.test").orElseThrow(IllegalStateException::new),
-                Mockito.class.getModule()
-            );
-        }
-        return controller.layer();
-    }
-
-    private static ModuleFinder automaticModule(String moduleName, String... packages) {
-        ModuleDescriptor descriptor = ModuleDescriptor.newAutomaticModule(moduleName)
-            .packages(new HashSet<>(Arrays.asList(packages)))
-            .build();
-        ModuleReference reference = new ModuleReference(descriptor, null) {
-            @Override
-            public ModuleReader open() {
-                return new ModuleReader() {
-                    @Override
-                    public Optional<URI> find(String name) {
-                        return Optional.empty();
-                    }
-
-                    @Override
-                    public Stream<String> list() {
-                        return Stream.empty();
-                    }
-
-                    @Override
-                    public void close() {
-                    }
-                };
-            }
-        };
-        return new ModuleFinder() {
-            @Override
-            public Optional<ModuleReference> find(String name) {
-                return name.equals(moduleName) ? Optional.of(reference) : Optional.empty();
-            }
-
-            @Override
-            public Set<ModuleReference> findAll() {
-                return Collections.singleton(reference);
-            }
-        };
-    }
-}
diff --git a/subprojects/module-test/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java b/subprojects/module-test/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java
deleted file mode 100644
index 9ee006c880..0000000000
--- a/subprojects/module-test/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2018 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.moduletest;
-
-import org.mockito.Mockito;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.nio.file.Path;
-
-public class ReplicatingClassLoader extends URLClassLoader {
-
-    public ReplicatingClassLoader(Path path) throws MalformedURLException {
-        super(new URL[]{path.toUri().toURL()}, null);
-    }
-
-    @Override
-    public Class<?> loadClass(String name) throws ClassNotFoundException {
-        try {
-            return super.loadClass(name);
-        } catch (ClassNotFoundException e) {
-            InputStream in = Mockito.class.getClassLoader().getResourceAsStream(name.replace('.', '/') + ".class");
-            if (in == null) {
-                throw e;
-            } else {
-                try {
-                    try {
-                        ByteArrayOutputStream out = new ByteArrayOutputStream();
-                        byte[] buffer = new byte[1024];
-                        int length;
-                        while ((length = (in.read(buffer))) != -1) {
-                            out.write(buffer, 0, length);
-                        }
-                        byte[] b = out.toByteArray();
-                        return defineClass(name, b, 0, b.length);
-                    } finally {
-                        in.close();
-                    }
-                } catch (IOException e1) {
-                    throw new RuntimeException(e1);
-                }
-            }
-        }
-    }
-}
diff --git a/subprojects/osgi-test/osgi-test-bundles.gradle b/subprojects/osgi-test/osgi-test-bundles.gradle
deleted file mode 100644
index a2b9feac89..0000000000
--- a/subprojects/osgi-test/osgi-test-bundles.gradle
+++ /dev/null
@@ -1,41 +0,0 @@
-buildscript {
-    repositories {
-        jcenter()
-    }
-    dependencies {
-        classpath libraries.bndGradle
-    }
-}
-
-apply from: "$rootDir/gradle/dependencies.gradle"
-
-description = "Test bundles for OSGi tests"
-
-sourceSets {
-    testBundle
-    otherBundle
-}
-
-dependencies {
-    testBundleCompile project.rootProject
-    testBundleCompile libraries.junit4
-    testBundleCompile sourceSets.otherBundle.output
-}
-
-import aQute.bnd.gradle.Bundle
-
-task testBundle(type: Bundle) {
-    from sourceSets.testBundle.output
-}
-
-task otherBundle(type: Bundle) {
-    from sourceSets.otherBundle.output
-}
-
-tasks.withType(Bundle) {
-    archiveAppendix = name
-    bnd = """
-Bundle-SymbolicName: $name
--exportcontents: *
-"""
-}
diff --git a/subprojects/osgi-test/osgi-test.gradle b/subprojects/osgi-test/osgi-test.gradle
deleted file mode 100644
index 8ebcc042f3..0000000000
--- a/subprojects/osgi-test/osgi-test.gradle
+++ /dev/null
@@ -1,38 +0,0 @@
-plugins {
-    id 'java'
-}
-
-apply from: "$rootDir/gradle/dependencies.gradle"
-apply from: "osgi-test-bundles.gradle"
-
-description = "Test suite for OSGi framework with Mockito"
-
-dependencies {
-    testCompile libraries.junit4
-    testCompile libraries.osgi
-
-    testRuntime libraries.equinox
-}
-
-tasks.javadoc.enabled = false
-
-configurations {
-    testRuntimeBundles
-}
-
-dependencies {
-    testRuntimeBundles project.rootProject
-    testRuntimeBundles libraries.bytebuddy
-    testRuntimeBundles libraries.objenesis
-    testRuntimeBundles tasks.testBundle.outputs.files
-    testRuntimeBundles tasks.otherBundle.outputs.files
-}
-
-test {
-    dependsOn configurations.testRuntimeBundles
-    inputs.files(sourceSets.testBundle.allSource)
-    inputs.files(sourceSets.otherBundle.allSource)
-    systemProperty 'testRuntimeBundles', configurations.testRuntimeBundles.asPath
-    useJUnit()
-}
-
diff --git a/subprojects/osgi-test/src/test/java/org/mockito/osgitest/OsgiTest.java b/subprojects/osgi-test/src/test/java/org/mockito/osgitest/OsgiTest.java
deleted file mode 100644
index 296e6cfd7f..0000000000
--- a/subprojects/osgi-test/src/test/java/org/mockito/osgitest/OsgiTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.osgitest;
-
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.model.RunnerBuilder;
-import org.osgi.framework.Bundle;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.BundleException;
-import org.osgi.framework.Constants;
-import org.osgi.framework.launch.Framework;
-import org.osgi.framework.launch.FrameworkFactory;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.*;
-import java.nio.file.attribute.BasicFileAttributes;
-import java.util.*;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.junit.AfterClass;
-
-import static org.junit.Assert.fail;
-
-@RunWith(OsgiTest.class)
-public class OsgiTest extends Suite {
-
-    private static final FrameworkFactory frameworkFactory = ServiceLoader.load(FrameworkFactory.class).iterator().next();
-    private static final String STORAGE_TEMPDIR_NAME = "osgi-test-storage";
-    private static final List<String> EXTRA_SYSTEMPACKAGES = Arrays.asList("org.junit", "sun.misc", "sun.reflect");
-
-    private static final List<Path> TEST_RUNTIME_BUNDLES = splitPaths(System.getProperty("testRuntimeBundles"));
-    private static final String TEST_BUNDLE_SYMBOLIC_NAME = "testBundle";
-
-    private static final long STOP_TIMEOUT_MS = 10000;
-
-    private static Path frameworkStorage;
-    private static Framework framework;
-    private static Bundle testBundle;
-
-    public OsgiTest(Class<?> osgiTestClass, RunnerBuilder builder) throws Exception {
-        super(builder, osgiTestClass, setUpClasses());
-    }
-
-    private static Class<?>[] setUpClasses() throws Exception {
-        frameworkStorage = Files.createTempDirectory(STORAGE_TEMPDIR_NAME);
-        Map<String, String> configuration = new HashMap<>();
-        configuration.put(Constants.FRAMEWORK_STORAGE, frameworkStorage.toString());
-        configuration.put(Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, String.join(",", EXTRA_SYSTEMPACKAGES));
-        framework = frameworkFactory.newFramework(configuration);
-        framework.init();
-        BundleContext bundleContext = framework.getBundleContext();
-        for (Path dependencyPath : TEST_RUNTIME_BUNDLES) {
-            Bundle installedBundle;
-            try {
-                installedBundle = bundleContext.installBundle(dependencyPath.toUri().toString());
-            } catch (BundleException e) {
-                throw new IllegalStateException("Failed to install bundle: " + dependencyPath.getFileName(), e);
-            }
-            if (TEST_BUNDLE_SYMBOLIC_NAME.equals(installedBundle.getSymbolicName())) {
-                testBundle = installedBundle;
-            }
-        }
-        if (testBundle == null) {
-            fail("Test bundle not found.");
-        }
-        framework.start();
-        try {
-            // Manual start to get a better exception if the bundle cannot be resolved
-            testBundle.start();
-        } catch (BundleException e) {
-            throw new IllegalStateException("Failed to start test bundle.", e);
-        }
-        return getTestClasses();
-    }
-
-    private static Class<?>[] getTestClasses() throws Exception {
-        return new Class<?>[] {
-            loadTestClass("SimpleMockTest"),
-            loadTestClass("MockNonPublicClassFailsTest"),
-            loadTestClass("MockClassInOtherBundleTest")
-        };
-    }
-
-    @AfterClass
-    public static void tearDown() throws Exception {
-        try {
-            if (framework != null) {
-                framework.stop();
-                framework.waitForStop(STOP_TIMEOUT_MS);
-            }
-        } finally {
-            if (frameworkStorage != null) {
-                deleteRecursively(frameworkStorage);
-            }
-        }
-    }
-
-    private static Class<?> loadTestClass(String className) throws Exception {
-        return testBundle.loadClass("org.mockito.osgitest.testbundle." + className);
-    }
-
-    private static List<Path> splitPaths(String paths) {
-        return Stream.of(paths.split(Pattern.quote(File.pathSeparator)))
-            .map(p -> Paths.get(p))
-            .collect(Collectors.toList());
-    }
-
-    private static void deleteRecursively(Path pathToDelete) throws IOException {
-        Files.walkFileTree(pathToDelete,
-            new SimpleFileVisitor<Path>() {
-                @Override
-                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
-                    Files.delete(dir);
-                    return FileVisitResult.CONTINUE;
-                }
-
-                @Override
-                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
-                    Files.delete(file);
-                    return FileVisitResult.CONTINUE;
-                }
-            });
-    }
-}
diff --git a/subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassFailsTest.java b/subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassFailsTest.java
deleted file mode 100644
index c618060606..0000000000
--- a/subprojects/osgi-test/src/testBundle/java/org/mockito/osgitest/testbundle/MockNonPublicClassFailsTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (c) 2019 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.osgitest.testbundle;
-
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-
-import static org.mockito.Mockito.mock;
-
-public class MockNonPublicClassFailsTest {
-
-    static class NonPublicClass {}
-
-    @Test(expected = MockitoException.class)
-    public void test() {
-            // Expected: The type is not public and its mock class is loaded by a different class loader.
-            NonPublicClass nonPublicClass = mock(NonPublicClass.class);
-    }
-}
diff --git a/version.properties b/version.properties
deleted file mode 100644
index c056235733..0000000000
--- a/version.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-#Currently building Mockito version
-version=3.3.1
-
-#Previous version used to generate release notes delta
-previousVersion=3.3.0