.editorconfig

+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4

.gitattributes

+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Allow gradle.bat to retain CRLF
+gradlew.bat text eol=crlf

.gitignore

@@ -3,6 +3,8 @@
 *.ipr
 *.iws
 .idea
+*.eml
+.shelf
 
 # Eclipse
 .classpath
@@ -17,3 +19,4 @@ out
 .gradle
 classes
 .gradletasknamecache
+*.log

.travis.yml

+# 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
-jdk:
-- oraclejdk7
-env:
+
 matrix:
-  - TERM=dumb
-  global:
-  - secure: ZjU6SpkLzTAJr9qmxKDSI0uA8eJ/r5n58/equD6ifDlCBUasxPxOwaIARuNjhH45UCFOQDO9HMmvD7IWufyYl0OpACMM6MZ/0JX5Qsd+vhmBGirl6H3rRbVpvyoSI1J2xqJXy9/yTU54IYMDv3R7suinvmKXYHCqJ3h7ke+m4Ik=
-  - secure: SDwSEK8W+GU78fVLi+P0k+v5eYK1fevz1Z0Htsjta2PRr0DicL6CMTNLxi48c3vXT+GHL6W8uojmfRwnHd8yyRZu2nW4Hda5rWB3de6Nz64lOZFYUbvoZfj9TdCgDYn+u2jUkm6+C76ZlPtfQhS97uZCb9iCDSdm1JErpng5e6g=
-  - secure: aRk3elhhgDvXc2RyKAOcn9UF4w5U2zgFqUEEwdZ/r5DLrlKlA0aDE3pBZhST479nHIVEjF3w/SjePmfc9K/JPp2cLE12qHBT5mp4F2MZhNkBDay4vsXLwkhWsyQLz85VrvR/QkeCbLXSQBCZsy/KI8PwwMIrcEH6rAoo+1MYTos=
+  include:
+  - jdk: oraclejdk8
+  - jdk: oraclejdk8
+    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline
+  - jdk: oraclejdk9
+    env: SKIP_RELEASE=true
+  - jdk: oraclejdk9
+    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline
+  - jdk: oraclejdk9
+    env: SKIP_RELEASE=true SIMULATE_JAVA11=true
+  - install: . ./install-jdk.sh -F 10 -L GPL
+    env: SKIP_RELEASE=true JDK='Oracle JDK 10'
+  - install: . ./install-jdk.sh -F 10 -L GPL
+    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline JDK='Oracle JDK 10'
+  - install: . ./install-jdk.sh -F 11 -L BCL
+    env: SKIP_RELEASE=true JDK='Oracle JDK 11'
+  - install: . ./install-jdk.sh -F 11 -L BCL
+    env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline JDK='Oracle JDK 11'
+  allow_failures:
+    - env: SKIP_RELEASE=true JDK='Oracle JDK 11'
+    - env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline JDK='Oracle JDK 11'
+
 branches:
+  #Don't build tags
   except:
   - /^v\d/
+
+before_install:
+  - wget https://raw.githubusercontent.com/sormuras/bach/master/install-jdk.sh
+
+#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:
-- ./gradlew ciBuild
+  # 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 build idea -s -PcheckJavaCompatibility && ./gradlew ciPerformRelease
+
 after_success:
-- ./gradlew release
-- ./gradlew cobertura coveralls
+  #Generates coverage report:
+  - ./gradlew --stacktrace coverageReport && 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"

HOWTO.BUILD.TXT

-> gradlew build
\ No newline at end of file

NOTICE

-Mockito license - MIT.
-
-Libraries used:
-
-Cglib - Apache License 2.0
-ASM - BSD license
-
-Mockito all distribution:
-
-Objenesis - MIT license
-Hamcrest - BSD license
\ No newline at end of file

README.md

-![Mockito](http://docs.mockito.googlecode.com/hg/latest/org/mockito/logo.jpg)
+<a href="http://site.mockito.org">
+<img src="https://raw.githubusercontent.com/mockito/mockito/master/src/javadoc/org/mockito/logo.png"
+     srcset="https://raw.githubusercontent.com/mockito/mockito/master/src/javadoc/org/mockito/logo@2x.png 2x"
+     alt="Mockito" />
+</a>
 
-simplier & better mocking
+Most popular mocking framework for Java
 
-[![Build Status](https://travis-ci.org/mockito/mockito.svg?branch=master)](https://travis-ci.org/mockito/mockito) [![Coverage Status](http://img.shields.io/coveralls/mockito/mockito/master.svg)](https://coveralls.io/r/mockito/mockito) [ ![Current release](https://api.bintray.com/packages/szczepiq/maven/mockito/images/download.svg) ](https://bintray.com/szczepiq/maven/mockito/_latestVersion) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.mockito/mockito-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.mockito/mockito-core)
+[![Build Status](https://travis-ci.org/mockito/mockito.svg?branch=release/2.x)](https://travis-ci.org/mockito/mockito) [![Coverage Status](https://img.shields.io/codecov/c/github/mockito/mockito.svg)](https://codecov.io/github/mockito/mockito) [![MIT License](http://img.shields.io/badge/license-MIT-green.svg) ](https://github.com/mockito/mockito/blob/master/LICENSE)
 
-## Current release
-See the [release notes page](https://github.com/mockito/mockito/blob/master/doc/release-notes/official.md) and [latest documentation](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html).
+[![latest release](https://img.shields.io/badge/release%20notes-2.x-yellow.svg)](https://github.com/mockito/mockito/blob/release/2.x/doc/release-notes/official.md)
+[![Bintray](https://api.bintray.com/packages/mockito/maven/mockito-development/images/download.svg)](https://bintray.com/mockito/maven)
+[![Maven Central](https://img.shields.io/maven-central/v/org.mockito/mockito-core.svg)](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.mockito%22%20AND%20a%3A%22mockito-core%22)
+[![Javadocs](http://www.javadoc.io/badge/org.mockito/mockito-core.svg?color=red)](http://www.javadoc.io/doc/org.mockito/mockito-core)
 
-## JDK8 status
 
-Mockito should work fine with JDK8 if you stay away from _default methods_ (aka _defender methods_). Lambda usage may work just as good for `Answer`s. We're unsure about every JDK8 features at the moment, like serializing a mock that uses a lambda. Error report and pull request are welcome though ([contributing guide](https://github.com/mockito/mockito/wiki/How%20To%20Contribute)).
+## Current version is 2.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!
 
-## Moving to github
-We are currently moving a few stuff from [Google Code](https://code.google.com/p/mockito/) to [Github](https://github.com/mockito/mockito).
+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/2.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).
 
-For now only the code repository is moved, other stuff will follow like the wiki pages. Documentation may or may not follow. But discussion group, issue tracker will stay at google (unfortunatley GH PR counters incremented before we had the chance to move our issues).
+Older 1.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/page/org.mockito/mockito-core/1.10.19/org/mockito/Mockito.html) (documentation).
 
-## Why drink it?
-Mockito is a mocking framework that tastes really good. It lets you write beautiful tests with clean & simple API. Mockito doesn't give you hangover because the tests are very readable and they produce clean verification errors. Read more about [features & motivations](https://code.google.com/p/mockito/wiki/FeaturesAndMotivations).
+## More information
 
-> *"We decided during the main conference that we should use JUnit 4 and Mockito because we think they are the future of TDD and mocking in Java"* - Dan North, the originator of BDD
+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.
 
-[More quotes](https://code.google.com/p/mockito/wiki/Quotes)
+Want to contribute? Take a look at the [Contributing Guide](https://github.com/mockito/mockito/blob/release/2.x/.github/CONTRIBUTING.md).
 
-> Over 15000 downloads of 1.9.0 version ('12), excluding maven/Gradle users. For latest figures see the downloads.
+Enjoy Mockito!
 
-[More about the user base](https://code.google.com/p/mockito/wiki/UserBase)
+## Need help?
 
-## How do I drink it?
+* Search / Ask question on [stackoverflow](http://stackoverflow.com/questions/tagged/mockito)
+* Go to the [mockito mailing-list](http://groups.google.com/group/mockito) (moderated)
+* Open a ticket in GitHub [issue tracker](https://github.com/mockito/mockito/issues)
 
-Recommended way of getting Mockito is declaring a dependency on "mockito-core" library (not "mockito-all"!) using your favorite build system. My favorite build system happens to be [Gradle](http://gradle.org) and so I do:
+## How to develop Mockito?
 
-```groovy
-repositories {
-  jcenter()
-}
+To build locally:
 
-dependencies {
-  testCompile "org.mockito:mockito-core:1.+"
-}
-```
+     ./gradlew build
 
-For legacy builds with manual dependency management it might be useful to use mockito-all package that can be downloaded from [Mockito's Bintray repository](https://bintray.com/szczepiq/maven/mockito/_latestVersion) or [Bintray's jcenter](http://jcenter.bintray.com/org/mockito/mockito-all).
+To develop in IntelliJ IDEA you can use built-in Gradle import wizard in IDEA.
+Alternatively generate the importable IDEA metadata files using:
 
-For more information please refer to the [wiki page](https://code.google.com/p/mockito/wiki/DeclaringMockitoDependency).
+     ./gradlew idea
 
-### Then you can verify interactions
+Then, _open_ the generated *.ipr file in IDEA.
 
-```java
-import static org.mockito.Mockito.*;
+## How to release new version?
 
-// mock creation
-List mockedList = mock(List.class);
+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)).
 
-// using mock object ; observe that it didn't throw any "unexpected interaction exception" exception
-mockedList.add("one");
-mockedList.clear();
+* Q: What's new in Mockito release model?
 
-// selective & explicit verification
-verify(mockedList).add("one");
-verify(mockedList).clear();
-```
+  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.
 
-### Or stub method calls
+* Q: How to publish to Maven Central?
 
-```java
-// you can mock concrete classes, not only interfaces
-LinkedList mockedList = mock(LinkedList.class);
+  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".
 
-// stubbing; before the actual execution
-when(mockedList.get(0)).thenReturn("first");
+* Q: How to promote already released version to a notable version?
 
-// the following prints "first"
-System.out.println(mockedList.get(0));
-
-// the following prints "null" because get(999) was not subbed
-System.out.println(mockedList.get(999));
-```
-
-### You can go further
-
-[Main reference documentation](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html) features:
-
-* [`mock()`](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html#mock(java.lang.Class))/[`@Mock`](http://mockito.github.io/mockito/docs/current/org/mockito/Mock.html): Create a mock (specify how it should behave via [`Answer`](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html#field_summary)/[`ReturnValue`](http://mockito.github.io/mockito/docs/current/org/mockito/ReturnValues.html)/[`MockSettings`](http://mockito.github.io/mockito/docs/current/org/mockito/MockSettings.html))
-     * [`when()`](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html#when(T))/[`given()`](https://mockito.github.io/mockito/docs/current/org/mockito/BDDMockito.html#given(T)) to specify how a mock should behave.
-     * If the provided answers doesn't fit your needs, write one yourself extending the [`Answer`](http://mockito.github.io/mockito/docs/current/org/mockito/stubbing/Answer.html) interface
-* [`spy()`](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html#spy(T))/[`@Spy`](http://mockito.github.io/mockito/docs/current/org/mockito/Spy.html): Calls a real object but records what has been called,
-* [`@InjectMocks`](http://mockito.github.io/mockito/docs/current/org/mockito/InjectMocks.html): Used as a kind of simple automatic dependency injection of fields created using the `@Spy` or `@Mock` annotation.
-* [`verify()`](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html#verify(T)) to check methods were called with given arguments; can match any expression via the [`any()`](https://mockito.github.io/mockito/docs/current/org/mockito/Matchers.html#any()), or capture what arguments where called using [`@Captor`](http://mockito.github.io/mockito/docs/current/org/mockito/Captor.html) instead.
-* Try BDD syntax with [BDDMockito](http://mockito.github.io/mockito/docs/current/org/mockito/BDDMockito.html)
-* Try the Mockito on Android, thanks to the Google guys working on dexmaker (more on that later)
-
-### Remember
-
-* Do not mock types you don't own
-* Don't mock value objects
-* Don't mock everything
-* Show some love with your tests
-
-Click [here](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html) for more documentation and examples. Remember all documentation lives in javadocs so you don’t need to visit that page too often. You can grab the RefCard [here](http://refcardz.dzone.com/refcardz/mockito).
-
-If you have any suggestions, find documentation unclear or you found a bug, write to our [mailing list](http://groups.google.com/group/mockito). You can report bugs [here](http://code.google.com/p/mockito/issues/list).
-
-## Who is your bartender?
-Mockito is served to you by **Szczepan Faber and friends**. First people who tried Mockito were developers of the [Guardian](http://guardian.co.uk/) project in London in early 2008. Here is how Szczepan explained [why we need another mocking framework](http://monkeyisland.pl/2008/01/14/mockito)?
-
-Firstly, hats down before **[EasyMock](http://easymock.org/) folks** for their ideas on beautiful and refactorable mocking syntax. First hacks on Mockito were done on top of the EasyMock code.
-
-Here are just some of my friends who contributed ideas to Mockito (apologize if I missed somebody): **Igor Czechowski**, **Patric Fornasier**, **Jim Barritt**, **Felix Leipold**, **Liz Keogh**, **Bartosz Bańkowski**.
-
-Now some other people joined the gang : **Brice Dutheil** then **David Wallace**.
-
-Special thanks to **Erik Ramfelt**, and **Steve Christou** for putting Mockito on there Jenkins server (continuous integration) for a few years. Now Travis and Coveralls took over.
-
-Thanks to **Karol Poźniak** for the logo :)
-
-Finally, thanks to **Erik Brakkee** who helps us getting jars to maven central
-
-## links wrap-up
-
-### Wiki
-* [FAQ](https://github.com/mockito/mockito/wiki/FAQ)
-* [How to contribute](https://github.com/mockito/mockito/wiki/How%20To%20Contribute)
-* [Mockito for python](https://code.google.com/p/mockito/wiki/MockitoForPython)
-* [Mockito VS EasyMock](https://code.google.com/p/mockito/wiki/MockitoVSEasyMock)
-* [Related projects](https://code.google.com/p/mockito/wiki/RelatedProjects)
-* [Release notes](https://github.com/mockito/mockito/blob/master/doc/release-notes/official.md)
-* [More wiki pages](https://github.com/mockito/mockito/wiki)
-* [Old wiki pages on google code](https://code.google.com/p/mockito/w/list)
-
-### Blogs
-* [Szczepan's new blog](http://szczepiq.blogspot.com/)
-* [Brice's French coffee workshop](http://blog.arkey.fr/)
-
-### Other project links
-* [Latest documentation](http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html)
-* [Dzone Reference Card](http://refcardz.dzone.com/refcardz/mockito)
-* [Continuous integration server](http://travis-ci.org/mockito/mockito)
-
-### Groups
-* [Mockito mailing list](http://groups.google.com/group/mockito)
+  A: It isn't automated at the moment. [What's the use case?](https://github.com/mockito/mockito/issues/911)

build-ant.xml

-<!--
- Copyright (c) 2007 Mockito contributors 
- This program is made available under the terms of the MIT License.
--->
-<project name="mockito" basedir=".">
-
-    <loadproperties srcfile="version.properties" />
-
-    <path id="ant.classpath">
-        <fileset dir="lib/build" includes="*bnd*" />
-    </path>
-
-    <property name="jar.core.path" value="build/libs/mockito-core-${version}.jar"/>
-    <property name="jar.all.path"  value="build/libs/mockito-all-${version}.jar"/>
-
-    <taskdef resource="aQute/bnd/ant/taskdef.properties" classpathref="ant.classpath"/>
-    <target name="bndCore">
-        <delete file="${jar.core.path}.bnd"/>
-        <bnd
-                classpath="${jar.core.path}"
-                eclipse="false"
-                failok="false"
-                exceptions="true"
-                sourcepath="src"
-                destfile="${jar.core.path}.bnd"
-                files="conf/mockito-core.bnd"/>
-    </target>
-
-    <target name="bndAll">
-        <delete file="${jar.all.path}.bnd"/>
-        <bnd
-                classpath="${jar.all.path}"
-                eclipse="false"
-                failok="false"
-                exceptions="true"
-                sourcepath="src"
-                destfile="${jar.all.path}.bnd"
-                files="conf/mockito-all.bnd"/>
-    </target>
-
-    <target name="osgify.mockito-core" depends="bndCore">
-        <zip update="true" destfile="${jar.core.path}" >
-            <zipfileset src="${jar.core.path}.bnd" >
-                <include name="META-INF/MANIFEST.MF"/>
-            </zipfileset>
-        </zip>
-    </target>
-
-    <target name="osgify.mockito-all" depends="bndAll">
-        <zip update="true" destfile="${jar.all.path}">
-            <zipfileset src="${jar.all.path}.bnd" >
-                <include name="META-INF/MANIFEST.MF"/>
-            </zipfileset>
-        </zip>
-    </target>
-
-</project>

build.gradle

 buildscript {
     repositories {
+        mavenLocal() //for local testing of mockito-release-tools
         jcenter()
+        maven { url "https://plugins.gradle.org/m2/" }
     }
 
     dependencies {
-        classpath 'net.saliman:gradle-cobertura-plugin:2.0.0' // coveralls plugin depends on cobertura plugin
-        classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:0.6.1'
-        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.0' //publishing to bintray
-        classpath 'org.codehaus.groovy.modules.http-builder:http-builder:0.5.2' //rest calls to bintray api
+        classpath 'gradle.plugin.nl.javadude.gradle.plugins:license-gradle-plugin:0.14.0'
+        classpath 'ru.vyarus:gradle-animalsniffer-plugin:1.4.4' //for 'java-compatibility-check.gradle'
+        classpath 'net.ltgt.gradle:gradle-errorprone-plugin:0.0.15'
+
+        //Using buildscript.classpath so that we can resolve shipkit from maven local, during local testing
+        classpath 'org.shipkit:shipkit:2.0.28'
     }
 }
 
-apply plugin: 'maven-publish'
-
-apply from: 'gradle/version.gradle'
-apply from: "gradle/ide.gradle"
-apply from: 'gradle/coverage.gradle'
-
-allprojects {
-    repositories {
-        jcenter()
-    }
+plugins {
+    id 'com.gradle.build-scan' version '1.15.1'
 }
 
-group = 'org.mockito'
-description = 'Core API and implementation.'
-sourceCompatibility = 1.5
-targetCompatibility = 1.5
+description = 'Mockito mock objects library core API and implementation'
 
-configurations {
-    provided
-    testUtil //TODO move to separate project
-}
+apply plugin: 'base'
+archivesBaseName = "mockito-core"
 
-sourceSets {
-    main {
-        java.srcDir 'src'
-        compileClasspath = compileClasspath + configurations.provided
-    }
-    test {
-        java.srcDir 'test'
-        compileClasspath = compileClasspath + configurations.provided
+apply plugin: "org.shipkit.java"
+allprojects {
+    plugins.withId("java") {
+        //Only upload specific modules we select
+        bintrayUpload.enabled = false
     }
 }
 
-test.include "**/*Test.class"
-
-tasks.withType(JavaCompile) {
-    options.warnings = false
-}
+apply from: 'gradle/root/ide.gradle'
+apply from: 'gradle/root/gradle-fix.gradle'
+apply from: 'gradle/root/java-compatibility-check.gradle'
+apply from: 'gradle/java-library.gradle'
+apply from: 'gradle/license.gradle'
+apply from: 'gradle/root/coverage.gradle'
 
-//TODO we should remove all dependencies to checked-in jars and move the 'mockito-all' project out
-//we should consider getting rid of mockito-all completely (or moving out into a completely separate project.
-dependencies {
-    provided "junit:junit:4.10"
-    compile "org.hamcrest:hamcrest-core:1.1", "org.objenesis:objenesis:2.1"
-    compile fileTree('lib/repackaged') { exclude '*.txt'}
+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'
 
-    testCompile fileTree("lib/test")
-    testRuntime configurations.provided
+apply from: 'gradle/dependencies.gradle'
 
-    testUtil sourceSets.test.output
+allprojects { proj ->
+    repositories {
+        jcenter()
     }
-
-def licenseFiles = copySpec {
-    //mockito license
-    from(".") { include 'LICENSE', 'NOTICE' }
-    //repackaged license
-    from("lib/repackaged") { include '*.txt' }
+    plugins.withId('java') {
+        proj.apply plugin: 'net.ltgt.errorprone'
+        proj.dependencies {
+            errorprone libraries.errorprone
         }
-
-def repackagedClasses = copySpec {
-    from(zipTree("lib/repackaged/cglib-and-asm-1.0.jar")) {
-        exclude 'META-INF/MANIFEST.MF'
     }
+    tasks.withType(JavaCompile) {
+        //I don't believe those warnings add value given modern IDEs
+        options.warnings = false
+        options.encoding = 'UTF-8'
     }
-
-jar {
-    baseName = 'mockito-core'
-    from(sourceSets.main.allSource)
-    with repackagedClasses
-    with licenseFiles
+    apply plugin: 'checkstyle'
+    checkstyle {
+       configFile = rootProject.file('config/checkstyle/checkstyle.xml')
     }
-
-task sourcesJar(type: Jar) {
-    baseName = 'mockito-core'
-    from(sourceSets.main.allSource)
-    classifier = "sources"
-    from(zipTree("lib/sources/cglib-and-asm-1.0-sources.jar"))
-    with licenseFiles
 }
 
-apply from: 'gradle/javadoc.gradle'
-
-task javadocJar(type: Jar) {
-    baseName = 'mockito-core'
-    classifier = "javadoc"
-    with licenseFiles
-    from mockitoJavadoc
+configurations {
+    testUtil //TODO move to separate project
 }
 
-//TODO SF mockito-all jar should automatically appear as downloadable in bintray and in Mockito 2.0, replaced with zip distro
-task allJar(type: Jar) {
-    baseName = 'mockito-all'
-
-    with repackagedClasses
-    with licenseFiles
+dependencies {
+    compile libraries.bytebuddy, libraries.bytebuddyagent
 
-    //source files
-    from(sourceSets.main.allSource)
+    compileOnly libraries.junit4, libraries.hamcrest
+    compile libraries.objenesis
 
-    //classes
-    from(sourceSets.main.output)
+    testCompile libraries.asm
 
-    //3rd party library classes
-    from(zipTree("lib/run/objenesis-2.1.jar")) { exclude "META-INF/maven/**" }
-    from(zipTree("lib/run/com.springsource.org.hamcrest.core-1.1.0.jar")) { exclude "LICENSE.txt" }
+    testCompile libraries.assertj
 
-    //3rd party license files
-    from("lib/run") { exclude '**/*.jar' }
-}
+    //putting 'provided' dependencies on test compile and runtime classpath
+    testCompileOnly configurations.compileOnly
+    testRuntime configurations.compileOnly
 
-def antCommand = "ant"
-
-if (System.getProperty("os.name").startsWith("Windows")) {
-    antCommand += ".bat"
+    testUtil sourceSets.test.output
 }
 
-configure([jar, allJar]) { task ->
-    task.rootSpec.exclude "MANIFEST.MF" //hack to avoid problems with bnd
-    doLast {
-        project.exec {
-            commandLine antCommand, '-f', 'build-ant.xml', "osgify.$task.baseName", "-Dversion=$project.version"
-        }
-    }
+wrapper {
+    gradleVersion = '4.9'
+    distributionSha256Sum = 'e66e69dce8173dd2004b39ba93586a184628bc6c28461bc771d6835f7f9b0d28'
 }
 
-artifacts {
-    archives allJar, sourcesJar, javadocJar
+//Posting Build scans to https://scans.gradle.com
+buildScan {
+    licenseAgreementUrl = 'https://gradle.com/terms-of-service'
+    licenseAgree = 'yes'
 }
 
-publishing {
-    publications {
-        mockitoCore(MavenPublication) {
-            from components.java
-            artifactId 'mockito-core'
-            artifact sourcesJar
-            artifact javadocJar
-        }
-        mockitoAll(MavenPublication) {
-            artifactId 'mockito-all'
-            artifact allJar
-            artifact sourcesJar
-            artifact javadocJar
+//workaround for #1444, delete when Shipkit bug is fixed
+subprojects {
+    afterEvaluate {
+        def lib = publishing.publications.javaLibrary
+        if(lib && !lib.artifactId.startsWith("mockito-")) {
+            lib.artifactId = "mockito-" + lib.artifactId
         }
     }
 }
-
-apply from: 'gradle/release.gradle'
-apply from: "gradle/pom.gradle"
-
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.0'
-}
-
-task ciBuild {
-    //validate the state of the project
-    dependsOn build, publishToMavenLocal, tasks.idea, tasks.eclipse
-}
\ No newline at end of file
+//end workaround

buildSrc/build.gradle

-apply plugin: 'idea'
-apply plugin: 'groovy'
-
-repositories { jcenter() }
-
-dependencies {
-    compile gradleApi()
-    //TODO SF use jcabi to edit issues after the release so that they have the milestone attached
-    //compile "com.jcabi:jcabi-github:0.17"
-    compile "com.googlecode.json-simple:json-simple:1.1.1@jar"
-    testCompile("org.spockframework:spock-core:0.7-groovy-2.0") {
-        exclude module: "groovy-all"
-    }
-    testCompile "cglib:cglib-nodep:2.2.2"
-}
-
-if (gradle.parent && gradle.parent.startParameter.taskNames.any { it in ["ideaModule", "idea"] }) {
-    build.dependsOn ideaModule
-}
\ No newline at end of file

buildSrc/src/main/groovy/org/mockito/release/comparison/PomComparator.java

-package org.mockito.release.comparison;
-
-import groovy.lang.Closure;
-
-import static org.mockito.release.util.ArgumentValidation.notNull;
-
-class PomComparator {
-
-    private Closure<String> left;
-    private Closure<String> right;
-
-    PomComparator setPair(Closure<String> left, Closure<String> right) {
-        notNull(left, "pom content to compare", right, "pom content to compare");
-        this.left = left;
-        this.right = right;
-        return this;
-    }
-
-    boolean areEqual() {
-        String left = this.left.call();
-        String right = this.right.call();
-
-        notNull(left, "pom content to compare", right, "pom content to compare");
-
-        return replaceVersion(left).equals(replaceVersion(right));
-    }
-
-    private String replaceVersion(String pom) {
-        return pom.replaceFirst("<version>(.*)</version>", "<version>foobar</version>");
-    }
-}

buildSrc/src/main/groovy/org/mockito/release/comparison/PublicationsComparator.java

-package org.mockito.release.comparison;
-
-import groovy.lang.Closure;
-
-import java.io.File;
-
-/**
- * Compares publications
- */
-public interface PublicationsComparator {
-
-    /**
-     * Sets files for comparison
-     */
-    void compareBinaries(Closure<File> left, Closure<File> right);
-
-    /**
-     * Sets poms for comparison
-     */
-    void comparePoms(Closure<String> left, Closure<String> right);
-
-    /**
-     * Gives information if publications are equal
-     */
-    boolean isPublicationsEqual();
-}

buildSrc/src/main/groovy/org/mockito/release/comparison/PublicationsComparatorTask.java

-package org.mockito.release.comparison;
-
-import groovy.lang.Closure;
-import org.gradle.api.DefaultTask;
-import org.gradle.api.tasks.TaskAction;
-
-import java.io.File;
-
-public class PublicationsComparatorTask extends DefaultTask implements PublicationsComparator {
-
-    private ZipComparator zipComparator = new ZipComparator(new ZipCompare());
-    private PomComparator pomComparator = new PomComparator();
-    private Boolean publicationsEqual;
-
-    public void compareBinaries(Closure<File> left, Closure<File> right) {
-        zipComparator.setPair(left, right);
-    }
-
-    public void comparePoms(Closure<String> left, Closure<String> right) {
-        pomComparator.setPair(left, right);
-    }
-
-    public boolean isPublicationsEqual() {
-        assert publicationsEqual != null : "Comparison task was not executed yet, the 'publicationsEqual' information not available.";
-        return publicationsEqual;
-    }
-
-    @TaskAction public void comparePublications() {
-        getLogger().lifecycle("{} - about to compare publications", getPath());
-
-        boolean poms = pomComparator.areEqual();
-        getLogger().lifecycle("{} - pom files equal: {}", getPath(), poms);
-
-        ZipComparator.Result result = zipComparator.compareFiles();
-        getLogger().info("{} - compared binaries: '{}' and '{}'", getPath(), result.getFile1(), result.getFile2());
-        boolean jars = result.areEqual();
-        getLogger().lifecycle("{} - source jars equal: {}", getPath(), jars);
-
-
-        this.publicationsEqual = jars && poms;
-    }
-}
\ No newline at end of file

buildSrc/src/main/groovy/org/mockito/release/comparison/ZipComparator.java

-package org.mockito.release.comparison;
-
-import groovy.lang.Closure;
-
-import java.io.File;
-
-import static org.mockito.release.util.ArgumentValidation.notNull;
-
-class ZipComparator {
-
-    private Closure<File> file1;
-    private Closure<File> file2;
-
-    private final ZipCompare zipCompare;
-
-    ZipComparator(ZipCompare zipCompare) {
-        this.zipCompare = zipCompare;
-    }
-
-    ZipComparator setPair(Closure<File> file1, Closure<File> file2) {
-        notNull(file1, "zip/jar file to compare", file2, "zip/jar file to compare");
-        this.file1 = file1;
-        this.file2 = file2;
-        return this;
-    }
-
-    Result compareFiles() {
-        final File file1 = this.file1.call();
-        final File file2 = this.file2.call();
-        notNull(file1, "zip/jar file to compare", file2, "zip/jar file to compare");
-
-        final boolean equals = zipCompare.compareZips(file1.getAbsolutePath(), file2.getAbsolutePath());
-
-        return new Result() {
-            public boolean areEqual() { return equals; }
-            public File getFile1() { return file1; }
-            public File getFile2() { return file2; }
-        };
-    }
-
-    static interface Result {
-        boolean areEqual();
-        File getFile1();
-        File getFile2();
-    }
-}

buildSrc/src/main/groovy/org/mockito/release/comparison/ZipCompare.java

-package org.mockito.release.comparison;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Enumeration;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.Set;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-
-import static java.lang.String.format;
-
-/**
- * Borrowed from the web so it does not look great.
- * I've removed System.out.println, fixed exception handling and added coverage.
- * For now it might be good enough.
- */
-class ZipCompare {
-
-    private final static Logger LOG = LoggerFactory.getLogger(ZipCompare.class);
-
-    boolean compareZips(String filePath1, String filePath2) {
-        ZipFile file1;
-        try {
-            file1 = new ZipFile(filePath1);
-        } catch (IOException e) {
-            throw new ZipCompareException("Could not open zip file " + filePath1, e);
-        }
-
-        ZipFile file2;
-        try {
-            file2 = new ZipFile(filePath2);
-        } catch (IOException e) {
-            throw new ZipCompareException("Could not open zip file " + filePath1, e);
-        }
-
-        LOG.info("Comparing " + filePath1 + " with " + filePath2);
-
-        Set set1 = new LinkedHashSet();
-        for (Enumeration e = file1.entries(); e.hasMoreElements(); )
-            set1.add(((ZipEntry) e.nextElement()).getName());
-
-        Set set2 = new LinkedHashSet();
-        for (Enumeration e = file2.entries(); e.hasMoreElements(); )
-            set2.add(((ZipEntry) e.nextElement()).getName());
-
-        int errcount = 0;
-        int filecount = 0;
-        for (Iterator i = set1.iterator(); i.hasNext(); ) {
-            String name = (String) i.next();
-            if (!set2.contains(name)) {
-                LOG.info(name + " not found in " + filePath2);
-                errcount += 1;
-                continue;
-            }
-            try {
-                set2.remove(name);
-                if (!streamsEqual(file1.getInputStream(file1.getEntry(name)), file2.getInputStream(file2
-                        .getEntry(name)))) {
-                    LOG.info(name + " does not match");
-                    errcount += 1;
-                    continue;
-                }
-            } catch (Exception e) {
-                throw new ZipCompareException(format("Unable to compare zip entry '%s' found in '%s' with '%s'", name, filePath1, filePath2), e);
-            }
-            filecount += 1;
-        }
-        for (Iterator i = set2.iterator(); i.hasNext(); ) {
-            String name = (String) i.next();
-            LOG.info(name + " not found in " + filePath1);
-            errcount += 1;
-        }
-        LOG.info(filecount + " entries matched");
-        if (errcount > 0) {
-            LOG.info(errcount + " entries did not match");
-            return false;
-        }
-        return true;
-    }
-
-    static boolean streamsEqual(InputStream stream1, InputStream stream2) throws IOException {
-        byte[] buf1 = new byte[4096];
-        byte[] buf2 = new byte[4096];
-        boolean done1 = false;
-        boolean done2 = false;
-
-        try {
-            while (!done1) {
-                int off1 = 0;
-                int off2 = 0;
-
-                while (off1 < buf1.length) {
-                    int count = stream1.read(buf1, off1, buf1.length - off1);
-                    if (count < 0) {
-                        done1 = true;
-                        break;
-                    }
-                    off1 += count;
-                }
-                while (off2 < buf2.length) {
-                    int count = stream2.read(buf2, off2, buf2.length - off2);
-                    if (count < 0) {
-                        done2 = true;
-                        break;
-                    }
-                    off2 += count;
-                }
-                if (off1 != off2 || done1 != done2)
-                    return false;
-                for (int i = 0; i < off1; i++) {
-                    if (buf1[i] != buf2[i])
-                        return false;
-                }
-            }
-            return true;
-        } finally {
-            stream1.close();
-            stream2.close();
-        }
-    }
-
-    static class ZipCompareException extends RuntimeException {
-        public ZipCompareException(String message, Throwable cause) {
-            super(message, cause);
-        }
-    }
-}
\ No newline at end of file

buildSrc/src/main/groovy/org/mockito/release/exec/DefaultProcessRunner.java

-package org.mockito.release.exec;
-
-import org.mockito.release.notes.util.ReleaseNotesException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.*;
-import java.util.Arrays;
-
-class DefaultProcessRunner implements ProcessRunner {
-
-    private static Logger LOG = LoggerFactory.getLogger(DefaultProcessRunner.class);
-    private final File workDir;
-
-    DefaultProcessRunner(File workDir) {
-        this.workDir = workDir;
-    }
-
-    public String run(String... commandLine) {
-        LOG.info("Executing command: {}", (Object) commandLine);
-
-        try {
-            Process process = new ProcessBuilder(commandLine).directory(workDir).redirectErrorStream(true).start();
-            return readFully(new BufferedReader(new InputStreamReader(process.getInputStream())));
-        } catch (Exception e) {
-            throw new ReleaseNotesException("Problems executing command: " + Arrays.toString(commandLine), e);
-        }
-    }
-
-    private static String readFully(BufferedReader reader) throws IOException {
-        try {
-            StringBuilder sb = new StringBuilder();
-            String line;
-            while((line = reader.readLine()) != null) {
-                sb.append(line).append("\n");
-            }
-            return sb.toString();
-        } finally {
-            reader.close();
-        }
-    }
-}

buildSrc/src/main/groovy/org/mockito/release/exec/Exec.java

-package org.mockito.release.exec;
-
-import java.io.File;
-
-/**
- * Process execution services
- */
-public class Exec {
-
-    /**
-     * Provides process runner for given working dir
-     */
-    public static ProcessRunner getProcessRunner(File workDir) {
-        return new DefaultProcessRunner(workDir);
-    }
-}

buildSrc/src/main/groovy/org/mockito/release/exec/ProcessRunner.java

-package org.mockito.release.exec;
-
-/**
- * Provides ways to execute external processes
- */
-public interface ProcessRunner {
-
-    /**
-     * Executes given command line and returns the output.
-     *
-     * @param commandLine to execute
-     * @return combined error and standard output.
-     */
-    String run(String ... commandLine);
-}