Argument captors in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit test using ArgumentCaptor?

Consider the following JUnit test snippet using Mockito's ArgumentCaptor. What will be the value of captor.getValue() after the test runs?

JUnit

import static org.mockito.Mockito.*;
import org.mockito.ArgumentCaptor;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

interface Service {
    void process(String input);
}

public class TestClass {
    @Test
    void testArgumentCaptor() {
        Service mockService = mock(Service.class);
        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);

        mockService.process("hello");
        mockService.process("world");

        verify(mockService, times(2)).process(captor.capture());

        String captured = captor.getValue();
        assertEquals("world", captured);
    }
}

A "hello"

B "world"

C null

D Throws an exception

💡 Hint

Remember that getValue() returns the last captured argument.

The ArgumentCaptor captures all arguments passed to the mocked method. The getValue() method returns the last captured argument, which is "world" in this case.

❓ assertion

intermediate

Which assertion correctly verifies all captured arguments?

You have captured multiple arguments with an ArgumentCaptor. Which assertion correctly checks that the captured arguments are exactly ["one", "two", "three"] in order?

JUnit

ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
// assume mock.method called 3 times with "one", "two", "three"
verify(mock, times(3)).method(captor.capture());
List<String> capturedArgs = captor.getAllValues();

A assertEquals("three", captor.getValue());

B assertTrue(capturedArgs.containsAll(List.of("one", "two", "three")));

C assertEquals(3, capturedArgs.size());

D assertEquals(List.of("one", "two", "three"), capturedArgs);

💡 Hint

Check both order and content of the list.

assertEquals with List.of(...) checks both order and exact elements. containsAll only checks presence, not order. Size check alone is insufficient. getValue() returns only the last argument.

🔧 Debug

advanced

Why does this ArgumentCaptor test fail with "Wanted but not invoked" error?

Examine the test code below. Why does the verify statement fail with a "Wanted but not invoked" error?

JUnit

import static org.mockito.Mockito.*;
import org.mockito.ArgumentCaptor;
import org.junit.jupiter.api.Test;

interface Service {
    void execute(int value);
}

public class TestClass {
    @Test
    void testCaptorFail() {
        Service mockService = mock(Service.class);
        ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(Integer.class);

        // No call to mockService.execute here

        verify(mockService).execute(captor.capture());
    }
}

A Because verify requires times(0) when no calls are made.

B Because ArgumentCaptor cannot capture primitive types like int.

C Because the method execute was never called on the mock, so verify fails.

D Because captor.capture() must be called before verify.

💡 Hint

Check if the mocked method was called before verification.

The verify statement expects the method execute to have been called at least once. Since there is no call to execute on the mock, verify fails with "Wanted but not invoked".

🧠 Conceptual

advanced

What is the main advantage of using ArgumentCaptor in tests?

Why do testers use ArgumentCaptor in unit tests with mocks?

A To capture and assert the arguments passed to mocked methods for detailed verification.

B To replace the need for mocking dependencies entirely.

C To automatically generate test data for parameterized tests.

D To speed up test execution by caching method calls.

💡 Hint

Think about what information ArgumentCaptor provides beyond simple call verification.

ArgumentCaptor allows testers to capture the actual arguments passed to mocked methods so they can assert on their values, enabling more detailed and precise testing.

❓ framework

expert

Which Mockito code snippet correctly captures and asserts multiple arguments in order?

Given a mock List<String> and calls mockList.add("a"), mockList.add("b"), mockList.add("c"), which code snippet correctly captures all arguments and asserts their order?

JUnit

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

List<String> mockList = mock(List.class);

mockList.add("a");
mockList.add("b");
mockList.add("c");

A

ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(mockList, times(3)).add(captor.capture());
assertEquals(List.of("a", "b", "c"), captor.getAllValues());

B

ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(mockList).add(captor.capture());
assertEquals(List.of("a", "b", "c"), captor.getAllValues());

C

ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(mockList, times(3)).add(anyString());
assertEquals(List.of("a", "b", "c"), captor.getAllValues());

D

ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(mockList, times(3)).add(captor.capture());
assertEquals("c", captor.getValue());

💡 Hint

Check the verify call and how many times add() is expected to be called.

Option A correctly verifies that add() was called 3 times and captures all arguments. Then it asserts the exact order of captured arguments. Option A verifies only once, so it misses calls. Option A uses anyString() in verify, which doesn't capture arguments. Option A asserts only the last captured argument, not all.