In Java, method overloading allows a class to have multiple methods with the same name but different parameter lists. However, this feature can sometimes lead to ambiguous method call errors, where the compiler cannot determine the exact method to invoke based on the provided arguments. This issue can be particularly problematic when using Mockito, a mocking framework for unit testing in Java.
This article explains how to avoid ambiguous method calls in the context of the Mockito framework.
1. Understanding the Problem
Consider the following example where a class has overloaded methods:
public class MyService {
public String doSomething(String arg) {
return "javacodegeeks";
}
public Object doSomething(NewService newService) {
return "do something";
}
}
class NewService {
}
In this scenario, if you try to use Mockito to mock the doSomething method, the compiler might get confused about which method to invoke, resulting in an ambiguous method call error.
2. Example of Ambiguous Method Call in Mockito
Here’s an example of how the ambiguity can occur:
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
public class MyServiceTest {
@Test
public void testDoSomething() {
MyService myService = mock(MyService.class);
// This will cause an ambiguous method call error
when(myService.doSomething(any())).thenReturn(null);
}
}
In the above example, the when(myService.doSomething(any())).thenReturn(null); line is ambiguous because any() can be matched to both doSomething(String) and doSomething(Object). In most cases, your IDE can identify the problem before running the test as shown when using Netbeans.
3. Resolving Ambiguous Method Calls
To resolve this ambiguity, we can use Mockito.any() to be more specific about which method we want to mock.
3.1 Using Mockito.any()
The most straightforward solution is to explicitly state the argument types within the any() matchers. This provides the compiler with the necessary clarity to identify the correct method:
public class MyServiceTest {
/**
* Test of doSomething method, of class MyService.
*/
@Test
public void testDoSomething() {
MyService myService = mock(MyService.class);
when(myService.doSomething(any(String.class))).thenReturn("javacodegeeks");
}
}
In this example, any(String.class) unequivocally specifies that the doSomething method taking a String argument is being mocked. This helps the compiler understand which overloaded method to use.
Similarly, if we need to mock the version of the doSomething() method that accepts an argument of our custom NewService object type, we will need to use the overloaded version of the any() ArgumentMatcher that specifies the object’s type as an argument:
@Test
public void testDoSomething_object() {
MyService myService = mock(MyService.class);
when(myService.doSomething(any(NewService.class))).thenReturn("do something");
}
3.2 Ambiguity with isNull()
To handle cases where you need to match null arguments specifically, you can use isNull(). Let’s consider the following example when we use isNull() without specifying the type. Note that isNull() is a generic method and can match any reference type.
@Test
public void testDoSomething() {
MyService myService = mock(MyService.class);
when(myService.doSomething(isNull())).thenReturn("Mocked response");
}
In this example, the line when(myService.doSomething(isNull())).thenReturn("Mocked response"); does not specify the type of the isNull() matcher. As a result, the compiler sees two possible matches:
doSomething(String arg)doSomething(NewService newService)
Since String is a subtype of Object, and both methods can potentially match the isNull() argument, the compiler cannot determine which method to use, leading to an ambiguous method call error.
3.2.1 Resolving the Ambiguity
To resolve this ambiguity, you need to explicitly specify the type parameter for isNull(). This tells the compiler exactly which method you intend to mock:
@Test
public void testDoSomethingWithNull() {
MyService myService = mock(MyService.class);
// Specify the exact method by using isNull(String.class)
when(myService.doSomething(isNull(String.class))).thenReturn("javacodegeeks");
}
Similarly, we can adjust our test and mock the version of the doSomething() method that accepts an argument of our NewService object as follows:
@Test
public void testDoSomething_objectWithNull() {
MyService myService = mock(MyService.class);
// Specify the exact method by using isNull(NewService.class)
when(myService.doSomething(isNull(NewService.class))).thenReturn("do something");
}
4. Conclusion
In this article, we explored how to address ambiguous method call errors in Mockito. Ambiguous method calls in Mockito can be a tricky issue due to method overloading. By using explicit casts with any() and isNull(), we can precisely help the compiler to resolve the method we intend to mock, even in the presence of overloaded methods. This ensures our tests run correctly without compilation errors.
5. Download the Source Code
This was an article explaining how to fix an ambiguous method call error in mockito.
You can download the full source code of this example here: mockito fix ambiguous method call error
