Remove VarargMatcher

src/main/java/org/mockito/ArgumentMatchers.java

@@ -174,7 +174,7 @@ public static <T> T any() {
      * @see #isNull()
      */
     public static <T> T any(Class<T> type) {
-        reportMatcher(new InstanceOf.VarArgAware(type, "<any " + type.getCanonicalName() + ">"));
+        reportMatcher(new InstanceOf(type, "<any " + type.getCanonicalName() + ">"));
         return defaultValue(type);
     }
 

src/main/java/org/mockito/internal/matchers/Any.java

@@ -8,7 +8,7 @@
 
 import org.mockito.ArgumentMatcher;
 
-public class Any implements ArgumentMatcher<Object>, VarargMatcher, Serializable {
+public class Any implements ArgumentMatcher<Object>, Serializable {
 
     public static final Any ANY = new Any();
 

src/main/java/org/mockito/internal/matchers/CapturingMatcher.java

@@ -17,8 +17,7 @@
 import org.mockito.ArgumentMatcher;
 
 @SuppressWarnings("unchecked")
-public class CapturingMatcher<T>
-        implements ArgumentMatcher<T>, CapturesArguments, VarargMatcher, Serializable {
+public class CapturingMatcher<T> implements ArgumentMatcher<T>, CapturesArguments, Serializable {
 
     private final Class<? extends T> clazz;
     private final List<Object> arguments = new ArrayList<>();

src/main/java/org/mockito/internal/matchers/InstanceOf.java

@@ -39,20 +39,4 @@ public Class<?> type() {
     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);
-        }
-
-        @Override
-        public Class<?> type() {
-            return clazz;
-        }
-    }
 }

src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java

@@ -153,7 +153,7 @@ 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));
+        InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, asList(ANY, ANY));
 
         // when
         boolean match = invocationMatcher.matches(invocation);

src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java

@@ -124,7 +124,7 @@ public void shouldKnowWhenVarargsMatch() {
     public void shouldAllowAnyMatchEntireVararg() {
         // given
         invocation = varargs("1", "2");
-        matchers = asList(ANY);
+        matchers = asList(ANY, ANY);
 
         // when
         boolean match =
@@ -151,10 +151,10 @@ public void shouldNotAllowAnyWithMixedVarargs() {
     }
 
     @Test
-    public void shouldAllowanyWithMixedVarargs() {
+    public void shouldAllowAnyWithMixedVarargs() {
         // given
         invocation = mixedVarargs(1, "1", "2");
-        matchers = asList(new Equals(1), ANY);
+        matchers = asList(new Equals(1), ANY, ANY);
 
         // when
         boolean match =
@@ -186,7 +186,7 @@ public void shouldAnyDealWithDifferentSizeOfArgs() {
     public void shouldMatchAnyEvenIfOneOfTheArgsIsNull() {
         // given
         invocation = mixedVarargs(null, null, "2");
-        matchers = asList(new Equals(null), ANY);
+        matchers = asList(new Equals(null), ANY, ANY);
 
         // when
         getMatcherApplicationStrategyFor(invocation, matchers)
@@ -200,7 +200,7 @@ public void shouldMatchAnyEvenIfOneOfTheArgsIsNull() {
     public void shouldMatchAnyEvenIfMatcherIsDecorated() {
         // given
         invocation = varargs("1", "2");
-        matchers = asList(ANY);
+        matchers = asList(ANY, ANY);
 
         // when
         getMatcherApplicationStrategyFor(invocation, matchers)
@@ -230,7 +230,7 @@ public void shouldMatchAnyEvenIfMatcherIsWrappedInHamcrestMatcher() {
     public void shouldMatchAnyThatMatchesRawVarArgType() {
         // given
         invocation = varargs("1", "2");
-        InstanceOf.VarArgAware any = new InstanceOf.VarArgAware(String[].class, "<any String[]>");
+        InstanceOf any = new InstanceOf(String[].class, "<any String[]>");
         matchers = asList(any);
 
         // when

src/test/java/org/mockito/internal/matchers/InstanceOfTest.java

@@ -59,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();
     }
 }

src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java

@@ -73,7 +73,7 @@ public void should_be_created_with_an_argument_resolver() throws Exception {
     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.<Class<?>[]>any()))
+        given(resolver.resolveTypeInstances(ArgumentMatchers.any(Class[].class)))
                 .willReturn(new Object[] {observer, map});
 
         new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver)
@@ -120,7 +120,7 @@ this, field("withThrowingConstructor"), resolver)
     @Test
     public void should_instantiate_type_with_vararg_constructor() throws Exception {
         Observer[] vararg = new Observer[] {};
-        given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>any()))
+        given(resolver.resolveTypeInstances(ArgumentMatchers.any(Class[].class)))
                 .willReturn(new Object[] {"", vararg});
 
         new ParameterizedConstructorInstantiator(this, field("withVarargConstructor"), resolver)

src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java

@@ -173,9 +173,9 @@ public void shouldStubCorrectlyWhenDoubleStringAndMixedVarargsUsed() {
 
     @Test
     // See bug #157
-    public void shouldMatchEasilyEmptyVararg() throws Exception {
+    public void shouldMatchEasilyEmptyVararg() {
         // when
-        when(mock.foo(any())).thenReturn(-1);
+        when(mock.foo(any(Object[].class))).thenReturn(-1);
 
         // then
         assertEquals(-1, mock.foo());

src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyPicksUpExtraInvocationsTest.java

@@ -26,7 +26,7 @@ public void shouldVerifyCorrectlyWithAny() {
         table.newRow("abc", "def");
 
         // then
-        verify(table, times(2)).newRow(anyString(), (String[]) any());
+        verify(table, times(2)).newRow(anyString(), any(String[].class));
     }
 
     @Test
@@ -36,7 +36,7 @@ public void shouldVerifyCorrectlyNumberOfInvocationsUsingAnyAndEqualArgument() {
         table.newRow("x", "def");
 
         // then
-        verify(table, times(2)).newRow(eq("x"), (String[]) any());
+        verify(table, times(2)).newRow(eq("x"), any(String[].class));
     }
 
     @Test

src/test/java/org/mockitousage/matchers/VarargsTest.java

@@ -40,6 +40,7 @@ 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 =
@@ -82,18 +83,18 @@ public void shouldMatchVarArgs_oneNullArg_eqNull() {
 
     @Test
     public void shouldMatchVarArgs_oneNullArg_isNull() {
-        Object arg = null;
-        mock.varargs(arg);
+        mock.varargs((Object) null);
 
-        verify(mock).varargs(ArgumentMatchers.<Object[]>isNull());
+        verify(mock).varargs(ArgumentMatchers.<Object>isNull());
+        verify(mock, never()).varargs(isNull(Object[].class));
     }
 
     @Test
     public void shouldMatchVarArgs_nullArrayArg() {
-        Object[] argArray = null;
-        mock.varargs(argArray);
+        mock.varargs((Object[]) null);
 
-        verify(mock).varargs(ArgumentMatchers.<Object[]>isNull());
+        verify(mock).varargs(isNull(Object[].class));
+        verify(mock).varargs(ArgumentMatchers.<Object>isNull());
     }
 
     @Test
@@ -111,21 +112,21 @@ public void shouldnotMatchVarArgs_twoArgsOneMatcher() {
     public void shouldMatchVarArgs_emptyVarArgsOneAnyMatcher() {
         mock.varargs();
 
-        verify(mock).varargs((String[]) any()); // any() -> VarargMatcher
+        verify(mock).varargs(any(String[].class));
     }
 
     @Test
     public void shouldMatchVarArgs_oneArgsOneAnyMatcher() {
         mock.varargs(1);
 
-        verify(mock).varargs(ArgumentMatchers.<Object[]>any()); // any() -> VarargMatcher
+        verify(mock).varargs(any(Object[].class));
     }
 
     @Test
     public void shouldMatchVarArgs_twoArgsOneAnyMatcher() {
         mock.varargs(1, 2);
 
-        verify(mock).varargs(ArgumentMatchers.<Object[]>any()); // any() -> VarargMatcher
+        verify(mock).varargs(any(Object[].class));
     }
 
     @Test
@@ -141,7 +142,7 @@ public void shouldMatchVarArgs_twoArgsThreeAnyMatcher() {
 
         assertThatThrownBy(
                         () -> {
-                            verify(mock).varargs(any(), any(), any()); // any() -> VarargMatcher
+                            verify(mock).varargs(any(), any(), any());
                         })
                 .hasMessageContaining("Argument(s) are different");
     }
@@ -192,9 +193,16 @@ public void shouldMatchVarArgs_oneArgIsNotNull() {
     public void shouldCaptureVarArgs_noArgs() {
         mock.varargs();
 
-        verify(mock).varargs(captor.capture());
+        verify(mock).varargs(arrayCaptor.capture());
 
-        assertThatCaptor(captor).isEmpty();
+        assertThatCaptor(arrayCaptor).contains(new String[] {});
+    }
+
+    @Test
+    public void shouldNotCaptureVarArgs_noArgs() {
+        mock.varargs();
+
+        verify(mock, never()).varargs(captor.capture());
     }
 
     @Test
@@ -224,9 +232,16 @@ public void shouldCaptureVarArgs_nullArrayArg() {
     public void shouldCaptureVarArgs_twoArgsOneCapture() {
         mock.varargs("1", "2");
 
-        verify(mock).varargs(captor.capture());
+        verify(mock).varargs(arrayCaptor.capture());
 
-        assertThatCaptor(captor).contains("1", "2");
+        assertThatCaptor(arrayCaptor).contains(new String[] {"1", "2"});
+    }
+
+    @Test
+    public void shouldNotCaptureVarArgs_twoArgsOneCapture() {
+        mock.varargs("1", "2");
+
+        verify(mock, never()).varargs(captor.capture());
     }
 
     @Test
@@ -242,9 +257,16 @@ public void shouldCaptureVarArgs_twoArgsTwoCaptures() {
     public void shouldCaptureVarArgs_oneNullArgument() {
         mock.varargs("1", null);
 
-        verify(mock).varargs(captor.capture());
+        verify(mock).varargs(arrayCaptor.capture());
 
-        assertThatCaptor(captor).contains("1", (String) null);
+        assertThatCaptor(arrayCaptor).contains(new String[] {"1", null});
+    }
+
+    @Test
+    public void shouldNotCaptureVarArgs_oneNullArgument() {
+        mock.varargs("1", null);
+
+        verify(mock, never()).varargs(captor.capture());
     }
 
     @Test
@@ -363,20 +385,6 @@ public void shouldMockVarargsInvocation_multiple_vararg_matcher() {
         assertThat(mock.methodWithVarargAndNonVarargVariants("a", "b", "c")).isNull();
     }
 
-    @Test
-    public void shouldMockVarargsInvocationUsingCasts() {
-        given(mock.methodWithVarargAndNonVarargVariants((String) any()))
-                .willReturn("single arg method");
-        given(mock.methodWithVarargAndNonVarargVariants((String[]) any()))
-                .willReturn("var arg method");
-
-        assertThat(mock.methodWithVarargAndNonVarargVariants("a")).isEqualTo("single arg method");
-        assertThat(mock.methodWithVarargAndNonVarargVariants()).isEqualTo("var arg method");
-        assertThat(mock.methodWithVarargAndNonVarargVariants(new String[] {"a"}))
-                .isEqualTo("var arg method");
-        assertThat(mock.methodWithVarargAndNonVarargVariants("a", "b")).isEqualTo("var arg method");
-    }
-
     @Test
     public void shouldMockVarargsInvocationForSuperType() {
         given(mock.varargsReturningString(any(Object[].class))).willReturn("a");