When a method on a mock with vararg arguments is called, Mockito checks if the last matcher that was passed in to the when method is an ArgumentMatcher that implements the VarargMatcher interface. This is correct in your case.
Mockito then internally expands the list of matchers for the call by repeating this last matcher for every vararg argument so that in the end the internal list of arguments and the list of matchers have the same size. In your example this means that during the matching there are three arguments - "a", "b", "c" - and three matchers - three times the instance of the ArrayContainsMatcher.
Then Mockito tries to match each argument against the matcher. And here your code fails, because the argument is a String and the matcher needs a String[]. So the match fails and the mock returns the default value of 0.
So the important thing is that a VarargMatcher is not called with the array of vararg arguments, but repeatedly with every single argument.
To get the behaviour as you want it, you must implement a matcher that has internal state, and instead of using then to return a fixed value you need thenAnswer with code that evaluates the state.
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.VarargMatcher;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
public class TestVarArgMatcher {
@Test
public void testAnyVarArg() {
Collaborator c = mock(Collaborator.class);
when(c.f(any())).thenReturn(6);
assertEquals(6, c.f("a", "b", "c")); // passes
}
@Test
public void testVarArg() {
Collaborator c = mock(Collaborator.class);
ArrayElementMatcher<String> matcher = new ArrayElementMatcher<>("b");
when(c.f(argThat(matcher))).thenAnswer(invocationOnMock -> matcher.isElementFound() ? 7 : 0);
assertEquals(7, c.f("a", "b", "c"));
}
interface Collaborator {
int f(String... args);
}
private static class ArrayElementMatcher<T> implements ArgumentMatcher<T>, VarargMatcher {
private final T element;
private boolean elementFound = false;
public ArrayElementMatcher(T element) {
this.element = element;
}
public boolean isElementFound() {
return elementFound;
}
@Override
public boolean matches(T t) {
elementFound |= element.equals(t);
return true;
}
}
}
The ArrayElementMatcher always returns true for a single match, otherwise Mockito would abort the evaluation, but internally the information is stored if the desired element was encountered. When Mockito has finished matching the arguments - and this match will be true - then the lambda passed into thenAnswer is called and this returns 7 if the given element was found, or 0 otherwise.
Two things to keep in mind:
you always need a new ArrayElementMatcher for every tested call - or add a reset method to the class.
you cannot have more than one when(c.f((argThat(matcher))) defintions in one test method with different matchers, because only one of them would be evaluated.
Edit/Addition:
Just played around a little more and came up with this variation - just showing the Matcher class and the test method:
@Test
public void testVarAnyArg() {
Collaborator c = mock(Collaborator.class);
VarargAnyMatcher<String, Integer> matcher =
new VarargAnyMatcher<>("b"::equals, 7, 0);
when(c.f(argThat(matcher))).thenAnswer(matcher);
assertEquals(7, c.f("a", "b", "c"));
}
private static class VarargAnyMatcher<T, R> implements ArgumentMatcher<T>, VarargMatcher, Answer<R> {
private final Function<T, Boolean> match;
private final R success;
private final R failure;
private boolean anyMatched = false;
public VarargAnyMatcher(Function<T, Boolean> match, R success, R failure) {
this.match = match;
this.success = success;
this.failure = failure;
}
@Override
public boolean matches(T t) {
anyMatched |= match.apply(t);
return true;
}
@Override
public R answer(InvocationOnMock invocationOnMock) {
return anyMatched ? success : failure;
}
}
It's basically the same, but I moved the implementation of the Answer interface into the matcher and extracted the logic to compare the vararg elements into a lambda that is passed in to the matcher ("b"::equals").
That makes the Matcher a little more complex, but the usage of it is much simpler.
