when().thenThrow() for exceptions in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of when().thenThrow() with checked exception

What will be the output when the following JUnit test runs?

JUnit

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

class Service {
    void perform() throws IOException {
        // does something
    }
}

public class ServiceTest {
    @Test
    void testPerformThrows() throws IOException {
        Service mockService = mock(Service.class);
        when(mockService.perform()).thenThrow(new IOException("IO error"));
        mockService.perform();
    }
}

A Test fails with IOException: IO error

B Test passes without exception

C Test fails with NullPointerException

D Test fails with RuntimeException

💡 Hint

when().thenThrow() makes the mock throw the specified exception when the method is called.

The mock is set to throw an IOException when perform() is called. Since the test calls perform(), it throws IOException causing the test to fail unless the exception is caught or expected.

❓ assertion

intermediate

Correct assertion to verify exception thrown by mock

Which assertion correctly verifies that the mocked method throws the expected exception?

JUnit

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

class Calculator {
    int divide(int a, int b) {
        return a / b;
    }
}

public class CalculatorTest {
    @Test
    void testDivideThrows() {
        Calculator mockCalc = mock(Calculator.class);
        when(mockCalc.divide(anyInt(), eq(0))).thenThrow(new ArithmeticException("Divide by zero"));
        // Which assertion below is correct?
    }
}

A assertDoesNotThrow(() -> mockCalc.divide(10, 0));

B assertTrue(mockCalc.divide(10, 0) == 0);

C assertThrows(ArithmeticException.class, () -> mockCalc.divide(10, 0));

D assertEquals(0, mockCalc.divide(10, 0));

💡 Hint

Use assertThrows to check if a method call throws an exception.

assertThrows expects the specified exception to be thrown by the lambda expression. This matches the mock setup that throws ArithmeticException when dividing by zero.

🔧 Debug

advanced

Identify the error in when().thenThrow() usage

What is the error in the following test code that uses when().thenThrow()?

JUnit

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

class Network {
    void connect() {
        // connects to network
    }
}

public class NetworkTest {
    @Test
    void testConnectThrows() {
        Network mockNetwork = mock(Network.class);
        when(mockNetwork.connect()).thenThrow(new Exception("Connection failed"));
        mockNetwork.connect();
    }
}

A Mocking void method with when() is correct

B thenThrow() cannot throw Exception objects

C No error, test will pass

D Cannot throw checked Exception without declaring it or handling it

💡 Hint

Check if the exception thrown is checked and if the method signature allows it.

connect() does not declare throwing checked Exception, so thenThrow(new Exception()) causes a compile error. For void methods, doThrow() should be used instead.

🧠 Conceptual

advanced

Difference between thenThrow() and doThrow() in Mockito

Which statement correctly describes the difference between thenThrow() and doThrow() when mocking exceptions?

A thenThrow() throws checked exceptions; doThrow() throws unchecked exceptions only

B thenThrow() is used for methods with return values; doThrow() is used for void methods

C thenThrow() can only throw RuntimeException; doThrow() can throw any Throwable

D thenThrow() is deprecated; doThrow() is the recommended replacement

💡 Hint

Consider method return types when choosing between thenThrow() and doThrow().

thenThrow() is used to stub methods that return a value to throw exceptions. doThrow() is used to stub void methods to throw exceptions.

❓ framework

expert

JUnit test behavior with chained thenThrow() calls

Given the following mock setup, what exception is thrown on the second call to process()?

JUnit

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

class Processor {
    String process() {
        return "done";
    }
}

public class ProcessorTest {
    @Test
    void testProcessMultipleExceptions() {
        Processor mockProcessor = mock(Processor.class);
        when(mockProcessor.process())
            .thenThrow(new IllegalStateException("First call failed"))
            .thenThrow(new IllegalArgumentException("Second call failed"));
        try {
            mockProcessor.process();
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        }
        try {
            mockProcessor.process();
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        }
    }
}

A IllegalArgumentException with message 'Second call failed'

B IllegalStateException with message 'First call failed'

C No exception thrown on second call

D RuntimeException with no message

💡 Hint

Mockito chains thenThrow calls to throw exceptions in order on consecutive calls.

The first call throws IllegalStateException, the second call throws IllegalArgumentException as configured by chained thenThrow calls.