Why can't you use when(...).thenThrow(...) for a void method, and how do you stub a void method to throw?

## The problem with when() and void Mockito's `when(...)` is designed around a clever trick: you *call the method on the mock*, Mockito records that call internally, and the value you pass to `when(...)` is just the method's return value (Mockito ignores the value itself — it uses the recorded invocation). For example `when(repo.find(1L))` passes the return of `find` into `when`. A **`void`** method returns nothing. You literally cannot write `when(mock.save(x))` because `save` has no value to hand to `when(...)` — the code does not compile. So the whole `when(...).thenThrow(...)` grammar is unavailable for `void` methods. ## The do-family solution Mockito offers an alternate grammar where the stubbed call comes **last**, so a return value is never needed: ```java doThrow(new IllegalStateException("disk full")).when(mock).save(x); ``` Read it as: "do throw this exception, when the mock's `save(x)` is called." `when(mock)` returns the mock itself; the *next* method call (`save(x)`) is the one being stubbed. Because the stubbed method is invoked as a *statement* (not inside `when(...)`), `void` is fine. Siblings in the do-family: `doReturn(...)`, `doNothing()`, `doAnswer(...)`, `doCallRealMethod()`. `doNothing()` is the explicit "do nothing" (the default for voids) and is handy in a chain. ## Class or instance — same rules `doThrow` accepts an exception instance or a class, identical to `thenThrow`: the class form uses the no-arg constructor; the instance form gives you the message/cause. The **checked-exception constraint** also still holds — a checked exception must appear in the method's `throws` clause. ## Consecutive calls ```java doThrow(new TimeoutException()).doNothing().when(mock).flush(); // 1st flush() throws, 2nd onward does nothing ``` ## Why do-form matters for spies A **spy** wraps a *real* object: unstubbed methods run the real implementation. With `when(spy.method())`, Java must *evaluate* `spy.method()` to pass its result into `when(...)`, which **actually runs the real method** — possibly with side effects or exceptions — before you've stubbed it. The do-form (`doThrow(...).when(spy).method()`) never executes the real method during stubbing, so it is the safe, recommended choice for spies, and for any method whose real execution you must avoid. ## Summary - `void` methods can't use `when(...).thenThrow(...)` (no return value to pass in). - Use `doThrow(...).when(mock).voidMethod()`. - The do-form also works for returning methods and is required/safer for spies. - Same class-vs-instance options and the same checked-exception rule apply.