将哪些对象传递给Mockito中的自定义ArgumentMatcher

Question

I am creating a custom argument matcher in mockito. Using this example:

class IsListOfTwoElements extends ArgumentMatcher<List> {
    public boolean matches(Object list) {
        return ((List) list).size() == 2;
    }
}

This made me wonder why the type of the parameter list is Object instead of List . Can the argument passed to the match function be something else? And if so shouldn't the example check the type of the parameter and return false if it isn't a List ?

To rephrase the question a little: Does mockito promise to only pas the correct type to the matches function? If so, why doesn't it use the generic type. And if not why doesn't the example return false if the wrong type is passed to it?

Answer 1

• If you extend ArgumentMatcher , you will receive an object, and it's your responsibility to cast it. Mockito will describe it based on the class name.
• If you extend BaseMatcher , you will receive an object, and it's your responsibility to cast it. The description will only say what the matcher was passed, not what it was expecting.
• If you use TypeSafeMatcher , you will receive an object of your chosen type, and it's your responsibility to describe it. It will check non-nullity and class type for you, and provide a sane error message if the class doesn't match.

Don't worry about making a bad cast in your matcher. Mockito wraps calls to its verification within a very generous try/catch block in both verification and invocation matching so a ClassCastException will return false (or fail to match) anyway.

---

Why, then, would interface Matcher accept more than its type parameter lets on?

This method matches against Object, instead of the generic type T. This is because the caller of the Matcher does not know at runtime what the type is (because of type erasure with Java generics). It is down to the implementations to check the correct type.

So, in other words, even if Matcher were to be parameterized it wouldn't provide a very strong type safety check at runtime. However, in Mockito, it's very useful-- argThat(Matcher<T>) returns a value of type T instead of Object , so you don't have to cast every single use of argThat(...) in your tests.

Answer 2

Because the mockito matchers use Hamcrest matchers, in the javadoc link you provided, you'll see that it inherits the signature of matches in interface org.hamcrest.Matcher which appear to not be generic in the actual interface.

If the compiler has made his job correctly you can assume you'll get the correct type though.

Note that the ArgumentCaptor approach is now recommanded for complex assertions, where you can use AssertJ (maintained clone of FEST-Assert) for example.