Update dexmaker

This fixes the back traces shown by verifyNoMoreInteractions.

Test: atest CtsInlineMockingTestCases CtsMockingTestCases
Change-Id: I2bc215e4d78a20ade761f8f3ba4b327f81f59ea0

2 files changed, 108 insertions, 23 deletions

diff --git a/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/CleanStackTrace.java b/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/CleanStackTrace.java
new file mode 100644
index 0000000..81a3b95
--- /dev/null
+++ b/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/CleanStackTrace.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.dx.mockito.tests;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class CleanStackTrace {
+    public abstract static class TestAbstractClass {
+        public abstract String returnA();
+    }
+
+    public static class TestClass {
+        public String returnA() {
+            return "A";
+        }
+    }
+
+    public interface TestInterface {
+        String returnA();
+    }
+
+    @Test
+    public void cleanStackTraceAbstractClass() {
+        TestAbstractClass t = mock(TestAbstractClass.class);
+
+        try {
+            verify(t).returnA();
+        } catch (Throwable verifyLocation) {
+            try {
+                throw new Exception();
+            } catch (Exception here) {
+                assertEquals(here.getStackTrace()[0].getMethodName(), verifyLocation
+                        .getStackTrace()[0].getMethodName());
+            }
+        }
+    }
+
+    @Test
+    public void cleanStackTraceRegularClass() {
+        TestClass t = mock(TestClass.class);
+
+        try {
+            verify(t).returnA();
+        } catch (Throwable verifyLocation) {
+            try {
+                throw new Exception();
+            } catch (Exception here) {
+                // Depending on the mock maker TestClass.returnA might be in the stack trace or not
+                for (int i = 0; i < 2; i++) {
+                    if (verifyLocation.getStackTrace()[i].getMethodName().equals(here
+                            .getStackTrace()[0].getMethodName())) {
+                        return;
+                    }
+                }
+
+                fail();
+            }
+        }
+    }
+
+    @Test
+    public void cleanStackTraceInterface() {
+        TestInterface t = mock(TestInterface.class);
+
+        try {
+            verify(t).returnA();
+        } catch (Throwable verifyLocation) {
+            try {
+                throw new Exception();
+            } catch (Exception here) {
+                assertEquals(here.getStackTrace()[0].getMethodName(), verifyLocation
+                        .getStackTrace()[0].getMethodName());
+            }
+        }
+    }
+}
diff --git a/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/MockTests.java b/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/GeneralMocking.java
index 1102b71..6f824f2 100644
--- a/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/MockTests.java
+++ b/dexmaker-mockito-tests/src/androidTest/java/com/android/dx/mockito/tests/GeneralMocking.java
@@ -20,17 +20,18 @@ import android.support.test.runner.AndroidJUnit4;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 @RunWith(AndroidJUnit4.class)
-public class MockTests {
+public class GeneralMocking {
     public static class TestClass {
         public String returnA() {
             return "A";
@@ -86,34 +87,23 @@ public class MockTests {
     }
 
     @Test
-    public void cleanStackTraceProxy() {
+    public void verifyAdditionalInvocations() {
         TestClass t = mock(TestClass.class);
 
-        try {
-            verify(t).returnA();
-        } catch (Throwable verifyLocation) {
-            try {
-                throw new Exception();
-            } catch (Exception here) {
-                assertEquals(here.getStackTrace()[0].getMethodName(), verifyLocation
-                        .getStackTrace()[0].getMethodName());
-            }
-        }
-    }
-
-    @Test
-    public void cleanStackTraceInterface() {
-        TestInterface t = mock(TestInterface.class);
+        t.returnA();
+        t.returnA();
 
         try {
-            verify(t).returnA();
-        } catch (Throwable verifyLocation) {
+            verifyNoMoreInteractions(t);
+        } catch (NoInteractionsWanted e) {
             try {
                 throw new Exception();
             } catch (Exception here) {
-                assertEquals(here.getStackTrace()[0].getMethodName(), verifyLocation
-                        .getStackTrace()[0].getMethodName());
+                // The error message should indicate where the additional invocations have been made
+                assertTrue(e.getMessage(),
+                        e.getMessage().contains(here.getStackTrace()[0].getMethodName()));
             }
+
         }
     }
 }