Argument matchers (any, eq) in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Mockito argument matcher usage

What will be the output of the following JUnit test using Mockito argument matchers?

JUnit

import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import java.util.List;

class MyTest {
    @Test
    void testArgumentMatchers() {
        List<String> mockedList = mock(List.class);
        when(mockedList.get(anyInt())).thenReturn("element");

        String result = mockedList.get(5);
        assertEquals("element", result);
        System.out.println(result);
    }
}

A null

B element

C IndexOutOfBoundsException

D MockitoException

💡 Hint

Think about what anyInt() matcher does in Mockito stubbing.

The anyInt() matcher matches any integer argument, so mockedList.get(5) returns the stubbed value "element".

❓ assertion

intermediate

Correct assertion with eq matcher

Which assertion correctly verifies that a mocked method was called with the exact string "test" using Mockito argument matchers?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import java.util.List;

class MyTest {
    @Test
    void verifyExactArgument() {
        List<String> mockedList = mock(List.class);
        mockedList.add("test");

        // Which verify statement is correct?
    }
}

A verify(mockedList).add(anyString());

B verify(mockedList).add(any());

C verify(mockedList).add("test");

D verify(mockedList).add(eq("test"));

💡 Hint

eq() matches the exact argument value.

Using eq("test") ensures the method was called with exactly "test". Other options either match any argument or do not use matchers properly.

🔧 Debug

advanced

Identify the error in argument matcher usage

What is the error in the following Mockito test code snippet?

JUnit

import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;
import org.junit.jupiter.api.Test;
import java.util.List;

class MyTest {
    @Test
    void testIncorrectMatcher() {
        List<String> mockedList = mock(List.class);
        when(mockedList.get(eq(0))).thenReturn("zero");
        when(mockedList.get(anyInt())).thenReturn("any");

        String result = mockedList.get(0);
        System.out.println(result);
    }
}

A The code runs fine and prints "any".

B The code runs fine and prints "zero".

C Mixing eq() and anyInt() in stubbing causes InvalidUseOfMatchersException.

D The code throws NullPointerException at runtime.

💡 Hint

Mockito uses the last matching stubbing for the same method signature.

The last stubbing with anyInt() overrides the previous one with eq(0), so mockedList.get(0) returns "any".

🧠 Conceptual

advanced

Understanding argument matcher limitations

Which statement about Mockito argument matchers is TRUE?

A You can mix raw values and argument matchers freely in the same method call.

B Argument matchers only work with primitive types, not objects.

C All arguments in a method call must be provided by matchers if any matcher is used.

D Argument matchers can be used only in verify(), not in when() stubbing.

💡 Hint

Mockito requires consistency in argument matching.

If you use any argument matcher in a method call, all arguments must be provided by matchers to avoid errors.

❓ framework

expert

Best practice for custom argument matcher implementation

You want to verify a method call with a complex object argument using a custom condition in Mockito. Which approach is best to implement this?

A Implement ArgumentMatcher<T> and use argThat() with your custom matcher.

B Use any() matcher to accept any object of that type.

C Use raw object comparison without any matcher.

D Use eq() matcher with the exact object instance.

💡 Hint

Custom logic requires custom matcher implementation.

Implementing ArgumentMatcher and using argThat() allows you to define complex matching logic for arguments.