Remove VarargMatcher

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/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)

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/bugs/varargs/VarargsNotPlayingWithAnyTest.java

@@ -30,23 +30,23 @@ public void shouldMatchAny() {
         mock.run("a", "b");
 
         verify(mock).run(anyString(), anyString());
-        verify(mock).run((String) any(), (String) any());
+        verify(mock).run(any(), any());
 
-        verify(mock).run((String[]) any());
+        verify(mock).run(any(String[].class));
 
         verify(mock, never()).run();
         verify(mock, never()).run(anyString(), eq("f"));
     }
 
     @Test
-    public void shouldAllowUsinganyForVarArgs() {
+    public void shouldAllowUsingAnyForVarArgs() {
         mock.run("a", "b");
-        verify(mock).run((String[]) any());
+        verify(mock).run(any(String[].class));
     }
 
     @Test
     public void shouldStubUsingAny() {
-        when(mock.run((String[]) any())).thenReturn("foo");
+        when(mock.run(any(String[].class))).thenReturn("foo");
 
         assertEquals("foo", mock.run("a", "b"));
     }

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

@@ -82,18 +82,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 +111,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 +141,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");
     }
@@ -363,20 +363,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");