Mocking void methods in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of mocking a void method with doNothing()

What will be the output of the following JUnit test using Mockito when the void method is mocked with doNothing()?

JUnit

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

class Service {
    void performAction() {
        System.out.println("Action performed");
    }
}

public class ServiceTest {
    @Test
    void testPerformAction() {
        Service mockService = mock(Service.class);
        doNothing().when(mockService).performAction();
        mockService.performAction();
        System.out.println("Test completed");
    }
}

A Action performed\nTest completed

B No output

C NullPointerException

D Test completed

💡 Hint

Think about what doNothing() does when mocking void methods.

The doNothing() stub tells Mockito to do nothing when the void method is called, so the original method body is not executed. Therefore, "Action performed" is not printed, only "Test completed" is printed.

❓ assertion

intermediate

Correct assertion to verify a void method call

Which assertion correctly verifies that a void method performAction() was called exactly once on a mock object in JUnit with Mockito?

JUnit

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

class Service {
    void performAction() {}
}

public class ServiceTest {
    @Test
    void testVerifyCall() {
        Service mockService = mock(Service.class);
        mockService.performAction();
        // Which assertion is correct here?
    }
}

A verify(mockService).performAction(1);

B assertTrue(mockService.performAction());

C verify(mockService, times(1)).performAction();

D assertEquals(1, mockService.performAction());

💡 Hint

Mockito uses verify() to check method calls on mocks.

The verify() method with times(1) checks that performAction() was called exactly once. The other options are invalid because performAction() returns void and cannot be used in assertions like assertEquals or assertTrue, and verify() does not take arguments like performAction(1).

🔧 Debug

advanced

Debugging a test with doThrow on a void method

Given the following test, what error will be thrown when mockService.performAction() is called?

JUnit

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

class Service {
    void performAction() {}
}

public class ServiceTest {
    @Test
    void testException() {
        Service mockService = mock(Service.class);
        doThrow(new RuntimeException("Error occurred")).when(mockService).performAction();
        mockService.performAction();
    }
}

A NullPointerException

B RuntimeException with message "Error occurred"

C MockitoException

D No exception, method does nothing

💡 Hint

doThrow() makes the mocked void method throw an exception when called.

The doThrow() stub causes the mocked void method to throw the specified RuntimeException when called. So the test will throw RuntimeException with the message "Error occurred".

🧠 Conceptual

advanced

Why use doAnswer() with void methods in Mockito?

Why would a tester use doAnswer() when mocking a void method instead of doNothing() or doThrow()?

A To execute custom code or logic when the void method is called

B To automatically call the real method implementation

C To ignore the method call silently without any effect

D To verify the method was never called

💡 Hint

doAnswer() lets you define what happens when the method is called.

doAnswer() allows the tester to run custom code or logic when the void method is called, such as modifying arguments or triggering side effects. doNothing() just skips the method, and doThrow() throws an exception. doAnswer() is useful for complex behaviors.

❓ framework

expert

Correct Mockito syntax to mock a void method throwing checked exception

Which option correctly mocks a void method performAction() to throw a checked exception IOException when called, using Mockito in JUnit?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import java.io.IOException;

class Service {
    void performAction() throws IOException {}
}

public class ServiceTest {
    @Test
    void testCheckedException() throws IOException {
        Service mockService = mock(Service.class);
        // Which option correctly mocks performAction() to throw IOException?
    }
}

A doThrow(new IOException("IO error")).when(mockService).performAction();

B when(mockService.performAction()).thenThrow(new IOException("IO error"));

C doThrow(IOException.class).when(mockService).performAction();

D when(mockService.performAction()).thenReturn(new IOException("IO error"));

💡 Hint

Use doThrow() for void methods throwing checked exceptions.

For void methods that throw checked exceptions, Mockito requires doThrow().when(mock).method() syntax. Option A causes a compile error because performAction() returns void and cannot be used in when(). Option A is invalid syntax. Option A tries to return an exception object which is invalid for void methods.

Practice

1. What is the main purpose of mocking void methods in JUnit tests?

easy

A. To convert void methods into methods that return values

B. To control their behavior and verify interactions without executing actual code

C. To automatically generate return values for void methods

D. To disable all tests that call void methods

Solution

1. Step 1: Understand void methods in tests

   Void methods do not return values, so mocking helps control their side effects during tests.

2. Step 2: Purpose of mocking void methods

   Mocking allows skipping actual execution and verifying if the method was called, without running real code.

3. Final Answer:

   To control their behavior and verify interactions without executing actual code -> Option B

4. Quick Check:

   Mock void methods = control behavior + verify calls [OK]

Hint: Mock void methods to control calls without running code [OK]

Common Mistakes:

• Thinking void methods return values
• Assuming mocking changes method return type
• Believing mocking disables all tests

2. Which Mockito syntax correctly mocks a void method sendEmail() to do nothing when called?

easy

A. doNothing().when(mock).sendEmail();

B. verify(mock).doNothing().sendEmail();

C. mock.sendEmail().doNothing();

D. when(mock.sendEmail()).thenReturn(null);

Solution

1. Step 1: Recall Mockito syntax for void methods

   Mockito uses doNothing().when(mock).method() to mock void methods doing nothing.

2. Step 2: Analyze options

   doNothing().when(mock).sendEmail(); matches correct syntax; others misuse when() or verify().

3. Final Answer:

   doNothing().when(mock).sendEmail(); -> Option A

4. Quick Check:

   Mock void method to do nothing = doNothing().when() [OK]

Hint: Use doNothing().when(mock).voidMethod() to mock void methods [OK]

Common Mistakes:

• Using when() with void methods incorrectly
• Trying to chain doNothing() after method call
• Confusing verify() with mocking syntax

3. Given the code snippet:

doThrow(new RuntimeException()).when(mock).deleteFile();
mock.deleteFile();

What happens when mock.deleteFile() is called?

medium

A. The test fails to compile

B. The method executes normally without exception

C. The method returns null

D. A RuntimeException is thrown

Solution

1. Step 1: Understand doThrow() usage

   doThrow() tells Mockito to throw the specified exception when the void method is called.

2. Step 2: Analyze method call effect

   Calling mock.deleteFile() triggers the RuntimeException as mocked.

3. Final Answer:

   A RuntimeException is thrown -> Option D

4. Quick Check:

   doThrow() causes exception on void method call [OK]

Hint: doThrow() makes void method throw exception when called [OK]

Common Mistakes:

• Expecting method to run normally
• Thinking void methods return null
• Confusing doThrow() with doNothing()

4. Identify the error in this Mockito code snippet:

doNothing().when(mock.deleteFile());

medium

A. Incorrect use of when() with method call inside

B. Missing exception type in doNothing()

C. doNothing() cannot be used with void methods

D. No error, code is correct

Solution

1. Step 1: Check Mockito syntax for mocking void methods

   Correct syntax is doNothing().when(mock).method(), not passing method call inside when().

2. Step 2: Identify error in code

   Code incorrectly calls method inside when(), causing syntax error.

3. Final Answer:

   Incorrect use of when() with method call inside -> Option A

4. Quick Check:

   when() expects mock object, not method call [OK]

Hint: Use when(mock).method(), not when(method()) [OK]

Common Mistakes:

• Calling method inside when() instead of after when(mock)
• Thinking doNothing() needs exception type
• Believing doNothing() can't mock void methods

5. You want to verify that a void method logAction() was called exactly twice during a test. Which Mockito code correctly does this?

hard

A. verify(mock).logAction(times(2));

B. doNothing().when(mock).logAction(); verify(mock).logAction();

C. verify(mock, times(2)).logAction();

D. when(mock.logAction()).thenReturn(2);

Solution

1. Step 1: Recall Mockito verify syntax for call count

   Use verify(mock, times(n)).method() to check method called n times.

2. Step 2: Analyze options

   verify(mock, times(2)).logAction(); uses correct syntax; others misuse verify or when with void methods.

3. Final Answer:

   verify(mock, times(2)).logAction(); -> Option C

4. Quick Check:

   Verify call count = verify(mock, times(n)) [OK]

Hint: Use verify(mock, times(n)) to check void method call count [OK]

Common Mistakes:

• Using when() with void methods to check calls
• Misplacing times() inside method call
• Not specifying times() for multiple calls