Update mockito to 2.12.0

Change-Id: I96a0d42128ceba1c7c5e096e3d982721a474a40c
Fixes: 69848252
Test: m -j checkbuild

10 files changed, 85 insertions, 71 deletions

diff --git a/src/main/java/org/mockito/internal/util/Checks.java b/src/main/java/org/mockito/internal/util/Checks.java
index 9731dbe..b672f6a 100644
--- a/src/main/java/org/mockito/internal/util/Checks.java
+++ b/src/main/java/org/mockito/internal/util/Checks.java
@@ -11,8 +11,16 @@ package org.mockito.internal.util;
 public 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) {
-            throw new IllegalArgumentException(checkedValue + " should not be null");
+            String message = checkedValue + " should not be null";
+            if (additionalMessage != null) {
+                message += ". " + additionalMessage;
+            }
+            throw new IllegalArgumentException(message);
         }
         return value;
     }
diff --git a/src/main/java/org/mockito/internal/util/Decamelizer.java b/src/main/java/org/mockito/internal/util/Decamelizer.java
deleted file mode 100644
index 8875389..0000000
--- a/src/main/java/org/mockito/internal/util/Decamelizer.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;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-//TODO SF move to matchers.text
-public class Decamelizer {
-
-private static final Pattern CAPS = Pattern.compile("([A-Z\\d][^A-Z\\d]*)");
-
-    public static String decamelizeMatcher(String className) {
-        if (className.length() == 0) {
-            return "<custom argument matcher>";
-        }
-
-        String decamelized = decamelizeClassName(className);
-
-        if (decamelized.length() == 0) {
-            return "<" + className + ">";
-        }
-
-        return "<" + decamelized + ">";
-    }
-
-    private static String decamelizeClassName(String className) {
-        Matcher match = CAPS.matcher(className);
-        StringBuilder deCameled = new StringBuilder();
-        while(match.find()) {
-            if (deCameled.length() == 0) {
-                deCameled.append(match.group());
-            } else {
-                deCameled.append(" ");
-                deCameled.append(match.group().toLowerCase());
-            }
-        }
-        return deCameled.toString();
-    }
-}
diff --git a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
index 7114a46..0c3669c 100644
--- a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
+++ b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
@@ -6,19 +6,18 @@ package org.mockito.internal.util;
 
 import org.mockito.MockingDetails;
 import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.internal.InternalMockHandler;
 import org.mockito.internal.debugging.InvocationsPrinter;
-import org.mockito.stubbing.Stubbing;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
 import org.mockito.internal.stubbing.StubbingComparator;
 import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Stubbing;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.TreeSet;
 
-import static org.mockito.internal.util.MockUtil.getMockHandler;
-
 /**
  * Class to inspect any object, and identify whether a particular object is either a mock or a spy.  This is
  * a wrapper for {@link org.mockito.internal.util.MockUtil}.
@@ -43,7 +42,12 @@ public class DefaultMockingDetails implements MockingDetails {
 
     @Override
     public Collection<Invocation> getInvocations() {
-        return mockHandler().getInvocationContainer().getInvocations();
+        return getInvocationContainer().getInvocations();
+    }
+
+    private InvocationContainerImpl getInvocationContainer() {
+        assertGoodMock();
+        return MockUtil.getInvocationContainer(toInspect);
     }
 
     @Override
@@ -53,7 +57,7 @@ public class DefaultMockingDetails implements MockingDetails {
 
     @Override
     public Collection<Stubbing> getStubbings() {
-        List<? extends Stubbing> stubbings = mockHandler().getInvocationContainer().getStubbedInvocations();
+        List<? extends Stubbing> stubbings = getInvocationContainer().getStubbedInvocations();
         TreeSet<Stubbing> out = new TreeSet<Stubbing>(new StubbingComparator());
         out.addAll(stubbings);
         return out;
@@ -65,9 +69,19 @@ public class DefaultMockingDetails implements MockingDetails {
         return new InvocationsPrinter().printInvocations(toInspect);
     }
 
-    private InternalMockHandler<Object> mockHandler() {
+    @Override
+    public MockHandler getMockHandler() {
+        return mockHandler();
+    }
+
+    @Override
+    public Object getMock() {
+        return toInspect;
+    }
+
+    private MockHandler<Object> mockHandler() {
         assertGoodMock();
-        return getMockHandler(toInspect);
+        return MockUtil.getMockHandler(toInspect);
     }
 
     private void assertGoodMock() {
diff --git a/src/main/java/org/mockito/internal/util/MockUtil.java b/src/main/java/org/mockito/internal/util/MockUtil.java
index 31d3b8f..df0deb1 100644
--- a/src/main/java/org/mockito/internal/util/MockUtil.java
+++ b/src/main/java/org/mockito/internal/util/MockUtil.java
@@ -4,13 +4,11 @@
  */
 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.InternalMockHandler;
 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;
@@ -18,6 +16,8 @@ import org.mockito.mock.MockName;
 import org.mockito.plugins.MockMaker;
 import org.mockito.plugins.MockMaker.TypeMockability;
 
+import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
+
 @SuppressWarnings("unchecked")
 public class MockUtil {
 
@@ -43,31 +43,41 @@ public class MockUtil {
     }
 
     public static <T> void resetMock(T mock) {
-        InternalMockHandler oldHandler = (InternalMockHandler) getMockHandler(mock);
+        MockHandler oldHandler = getMockHandler(mock);
         MockCreationSettings settings = oldHandler.getMockSettings();
         MockHandler newHandler = createMockHandler(settings);
 
         mockMaker.resetMock(mock, newHandler, settings);
     }
 
-    public static <T> InternalMockHandler<T> getMockHandler(T mock) {
+    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)) {
-            MockHandler handler = mockMaker.getHandler(mock);
-            return (InternalMockHandler) handler;
+            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;
     }
 
diff --git a/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java b/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
index 2fc9bce..d2a1690 100644
--- a/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
+++ b/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
@@ -17,12 +17,12 @@ public class ObjectMethodsGuru{
         MockitoMethod m = new DelegatingMethod(method);
         return m.getReturnType() == String.class &&
                m.getParameterTypes().length == 0 &&
-               m.getName().equals("toString");
+               "toString".equals(m.getName());
     }
 
     public static boolean isCompareToMethod(Method method) {
         return Comparable.class.isAssignableFrom(method.getDeclaringClass())
-                && method.getName().equals("compareTo")
+                && "compareTo".equals(method.getName())
                 && method.getParameterTypes().length == 1
                 && method.getParameterTypes()[0] == method.getDeclaringClass();
     }
diff --git a/src/main/java/org/mockito/internal/util/StringUtil.java b/src/main/java/org/mockito/internal/util/StringUtil.java
index e1d09ab..3070fe6 100644
--- a/src/main/java/org/mockito/internal/util/StringUtil.java
+++ b/src/main/java/org/mockito/internal/util/StringUtil.java
@@ -1,7 +1,12 @@
+/*
+ * Copyright (c) 2017 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 java.util.Collection;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -29,14 +34,30 @@ public class StringUtil {
 
     /**
      * Joins Strings with EOL character
+     *
+     * @param start the starting String
+     * @param lines collection to join
      */
-    public static String join(String start, Iterable<?> lines) {
+    public static String join(String start, Collection<?> lines) {
+        return join(start, "", lines);
+    }
+
+    /**
+     * Joins Strings with EOL character
+     *
+     * @param start the starting String
+     * @param linePrefix the prefix for each line to be joined
+     * @param lines collection to join
+     */
+    public static String join(String start, String linePrefix, Collection<?> lines) {
+        if (lines.isEmpty()) {
+            return "";
+        }
         StringBuilder out = new StringBuilder(start);
         for (Object line : lines) {
-            out.append(line.toString()).append("\n");
+            out.append(linePrefix).append(line).append("\n");
         }
-        int lastBreak = out.lastIndexOf("\n");
-        return out.replace(lastBreak, lastBreak+1, "").toString();
+        return out.substring(0, out.length() - 1); //lose last EOL
     }
 
     public static String decamelizeMatcher(String className) {
diff --git a/src/main/java/org/mockito/internal/util/Supplier.java b/src/main/java/org/mockito/internal/util/Supplier.java
index 8a99b8b..1b62bbc 100644
--- a/src/main/java/org/mockito/internal/util/Supplier.java
+++ b/src/main/java/org/mockito/internal/util/Supplier.java
@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
 package org.mockito.internal.util;
 
 /**
diff --git a/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java b/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
index 0794178..3768a03 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
+++ b/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
@@ -84,7 +84,7 @@ public class DetachedThreadLocal<T> implements Runnable {
 
     /**
      * @param thread The thread for which to set a thread-local value.
-     * @return The value accociated with this thread.
+     * @return The value associated with this thread.
      */
     public T get(Thread thread) {
         return map.get(thread);
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java b/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
index 9a0b778..8d04765 100644
--- a/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
+++ b/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
@@ -29,7 +29,7 @@ public class FieldInitializationReport {
     }
 
     /**
-     * Indicate wether the field was created during the process or not.
+     * Indicate whether the field was created during the process or not.
      *
      * @return <code>true</code> if created, <code>false</code> if the field did already hold an instance.
      */
@@ -38,7 +38,7 @@ public class FieldInitializationReport {
     }
 
     /**
-     * Indicate wether the field was created using constructor args.
+     * Indicate whether the field was created using constructor args.
      *
      * @return <code>true</code> if field was created using constructor parameters.
      */
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java b/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
index cad1715..6d3bd70 100644
--- a/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
+++ b/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
@@ -43,7 +43,7 @@ public class GenericTypeExtractor {
                 return extractGeneric(match.getGenericSuperclass());
             }
             //check the interfaces (recursively)
-            Type genericInterface = findGenericInteface(match, targetBaseInterface);
+            Type genericInterface = findGenericInterface(match, targetBaseInterface);
             if (genericInterface != null) {
                 return extractGeneric(genericInterface);
             }
@@ -57,13 +57,13 @@ public class GenericTypeExtractor {
      * Finds generic interface implementation based on the source class and the target interface.
      * Returns null if not found. Recurses the interface hierarchy.
      */
-    private static Type findGenericInteface(Class<?> sourceClass, Class<?> targetBaseInterface) {
+    private static Type findGenericInterface(Class<?> sourceClass, Class<?> targetBaseInterface) {
         for (int i = 0; i < sourceClass.getInterfaces().length; i++) {
             Class<?> inter = sourceClass.getInterfaces()[i];
             if (inter == targetBaseInterface) {
                 return sourceClass.getGenericInterfaces()[0];
             } else {
-                Type deeper = findGenericInteface(inter, targetBaseInterface);
+                Type deeper = findGenericInterface(inter, targetBaseInterface);
                 if (deeper != null) {
                     return deeper;
                 }