Top 30 JUnit 6 and Mockito Interview Questions (2026)

@Test
void q01_platformJupiterVintage() {
    List<String> engines = new ArrayList<>();
    for (TestEngine e : ServiceLoader.load(TestEngine.class)) {
        engines.add(e.getId() + " " + e.getVersion().orElse("?"));
    }
    p("TestEngines found on the classpath (ServiceLoader<TestEngine>):");
    engines.forEach(e -> p("  %s", e));
    p("Jupiter API version  : %s", org.junit.jupiter.api.Test.class.getPackage().getImplementationVersion());
    p("Platform launcher    : %s", org.junit.platform.launcher.Launcher.class.getPackage().getImplementationVersion());
    p("Platform engine API  : %s", TestEngine.class.getPackage().getImplementationVersion());
    p("junit-vintage engine : %s", engines.stream().anyMatch(e -> e.startsWith("junit-vintage")) ? "present" : "not on the classpath");
    assertEquals(1, engines.size());
    assertTrue(engines.get(0).startsWith("junit-jupiter 6."));
    assertEquals(org.junit.jupiter.api.Test.class.getPackage().getImplementationVersion(),
            org.junit.platform.launcher.Launcher.class.getPackage().getImplementationVersion());
}

TestEngines found on the classpath (ServiceLoader<TestEngine>):
  junit-jupiter 6.1.3
Jupiter API version  : 6.1.3
Platform launcher    : 6.1.3
Platform engine API  : 6.1.3
junit-vintage engine : not on the classpath

Why it matters in practice. A test class is only run if an engine that understands it is on the classpath. This module has no Vintage engine, so the output lists exactly one engine. The 6.0.0 release notes also say the Vintage engine is now deprecated and reports an INFO-level discovery issue when it finds a JUnit 4 test class (release-notes-sourced; not executed here).

@Test
void q02_removedAndBaseline() throws Exception {
    int major;
    try (InputStream in = org.junit.jupiter.api.Test.class.getResourceAsStream("Test.class")) {
        byte[] head = in.readNBytes(8);
        major = ((head[6] & 0xff) << 8) | (head[7] & 0xff);
    }
    p("class-file major version of org.junit.jupiter.api.Test : %d (Java %d)", major, major - 44);
    String removed = "org.junit.jupiter.api.MethodOrderer$Alphanumeric";
    try {
        Class.forName(removed);
        p("%s : still present", removed);
    } catch (ClassNotFoundException e) {
        p("Class.forName(\"%s\") -> ClassNotFoundException", removed);
    }
    assertEquals(61, major);
    assertThrows(ClassNotFoundException.class, () -> Class.forName(removed));
    p("(the 5.14.4 versus 6.1.3 jar comparison is scripts/compare-5-vs-6.sh -> q02-jar-comparison.txt)");
}

class-file major version of org.junit.jupiter.api.Test : 61 (Java 17)
Class.forName("org.junit.jupiter.api.MethodOrderer$Alphanumeric") -> ClassNotFoundException
(the 5.14.4 versus 6.1.3 jar comparison is scripts/compare-5-vs-6.sh -> q02-jar-comparison.txt)

junit-jupiter-api 5.14.4 : class-file major version 52 (Java 8), MethodOrderer$Alphanumeric entries in jar: 1
junit-jupiter-api 6.1.3 : class-file major version 61 (Java 17), MethodOrderer$Alphanumeric entries in jar: 0

public static class PerMethod {
    public static int instances;
    final int id = ++instances;

    @BeforeAll
    static void beforeAll() {
        Log.add("@BeforeAll (static)");
    }

    @BeforeEach
    void beforeEach() {
        Log.add("@BeforeEach on instance #" + id);
    }

    @Test
    void first() {
        Log.add("  test first() on instance #" + id);
    }

    @Test
    void second() {
        Log.add("  test second() on instance #" + id);
    }

    @AfterEach
    void afterEach() {
        Log.add("@AfterEach on instance #" + id);
    }

    @AfterAll
    static void afterAll() {
        Log.add("@AfterAll (static)");
    }
}

@BeforeAll (static)
@BeforeEach on instance #1
  test second() on instance #1
@AfterEach on instance #1
@BeforeEach on instance #2
  test first() on instance #2
@AfterEach on instance #2
@AfterAll (static)

Trap. Look at the order of the two tests: second() ran before first(). Declaration order is not execution order (Q6).

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public static class PerClass {
    public static int instances;
    final int id = ++instances;
    int counter;

    @BeforeAll
    void beforeAll() {
        Log.add("@BeforeAll (non-static) on instance #" + id);
    }

    @Test
    void first() {
        counter++;
        Log.add("first(): instance #" + id + ", counter=" + counter);
    }

    @Test
    void second() {
        counter++;
        Log.add("second(): instance #" + id + ", counter=" + counter);
    }
}

@BeforeAll (non-static) on instance #1
second(): instance #1, counter=1
first(): instance #1, counter=2

Trap. You have traded isolation for convenience. A test that passes only because an earlier test left a field set is the root of the flaky-test problem in Q29. Use PER_CLASS for expensive read-only setup (a client, a parsed fixture), not for state the tests mutate. The default can also be changed project-wide with the documented junit.jupiter.testinstance.lifecycle.default configuration parameter.

public static class Outer {
    @BeforeEach
    void outerBefore() {
        Log.add("outer @BeforeEach");
    }

    @AfterEach
    void outerAfter() {
        Log.add("outer @AfterEach");
    }

    @Test
    void outerTest() {
        Log.add("  outerTest()");
    }

    @Nested
    class Inner {
        @BeforeEach
        void innerBefore() {
            Log.add("inner @BeforeEach");
        }

        @AfterEach
        void innerAfter() {
            Log.add("inner @AfterEach");
        }

        @Test
        void innerTest() {
            Log.add("  innerTest()");
        }
    }
}

outer @BeforeEach
  outerTest()
outer @AfterEach
outer @BeforeEach
inner @BeforeEach
  innerTest()
inner @AfterEach
outer @AfterEach

@Test
void q06_methodOrder() {
    Map<String, String> byName = Map.of("junit.jupiter.testmethod.order.default",
            org.junit.jupiter.api.MethodOrderer.MethodName.class.getName());
    Map<String, String> byDisplay = Map.of("junit.jupiter.testmethod.order.default",
            org.junit.jupiter.api.MethodOrderer.DisplayName.class.getName());
    Run dflt = Run.of(LifecycleFixtures.Ordering.class);
    Run name = Run.of(LifecycleFixtures.Ordering.class, byName);
    Run disp = Run.of(LifecycleFixtures.Ordering.class, byDisplay);
    p("declared order in the source     : zebra(), apple(), mango(), banana()");
    p("default (no orderer configured)  : %s", names(dflt));
    p("MethodOrderer.MethodName         : %s", names(name));
    p("MethodOrderer.DisplayName        : %s", names(disp));
    assertEquals("[apple(), banana(), mango(), zebra()]", names(name));
    assertEquals(4, dflt.events.size());
    assertNotEquals("[zebra(), apple(), mango(), banana()]", names(name));
}

declared order in the source     : zebra(), apple(), mango(), banana()
default (no orderer configured)  : [banana(), apple(), mango(), zebra()]
MethodOrderer.MethodName         : [apple(), banana(), mango(), zebra()]
MethodOrderer.DisplayName        : [apple(), banana(), mango(), zebra()]

Trap. MethodOrderer.Alphanumeric, which older tutorials still use, no longer exists in JUnit 6 (Q2). Replace it with MethodName; the code will not compile otherwise.

@Test
void q07_groupedAssertions() {
    MultipleFailuresError e = assertThrows(MultipleFailuresError.class, () -> assertAll("order",
            () -> assertEquals(1, 2, "quantity"),
            () -> assertEquals("A", "B", "code"),
            () -> assertTrue(true)));
    p("assertAll reported %d failures from 3 assertions:", e.getFailures().size());
    p("%s", e.getMessage());
    IllegalStateException ise = assertThrows(IllegalStateException.class, () -> {
        throw new IllegalStateException("boom");
    });
    p("assertThrows returns the exception: getMessage() = %s", ise.getMessage());
    assertEquals(2, e.getFailures().size());
}

assertAll reported 2 failures from 3 assertions:
order (2 failures)
	org.opentest4j.AssertionFailedError: quantity ==> expected: <1> but was: <2>
	org.opentest4j.AssertionFailedError: code ==> expected: <A> but was: <B>
assertThrows returns the exception: getMessage() = boom

@Test
void q08_timeoutVsPreemptive() {
    String test = Thread.currentThread().getName();
    String[] seenBy = new String[2];
    org.junit.jupiter.api.Assertions.assertTimeout(java.time.Duration.ofSeconds(1),
            () -> seenBy[0] = Thread.currentThread().getName());
    org.junit.jupiter.api.Assertions.assertTimeoutPreemptively(java.time.Duration.ofSeconds(1),
            () -> seenBy[1] = Thread.currentThread().getName());
    p("assertTimeout            runs the code on the test thread : %s", seenBy[0].equals(test));
    p("assertTimeoutPreemptively runs the code on the test thread : %s", seenBy[1].equals(test));

    var slow1 = assertThrows(org.opentest4j.AssertionFailedError.class,
            () -> org.junit.jupiter.api.Assertions.assertTimeout(java.time.Duration.ofMillis(50),
                    () -> Thread.sleep(200)));
    String m1 = slow1.getMessage();
    p("assertTimeout failure message (trimmed at ' by '): %s", m1.substring(0, m1.indexOf(" by ")));
    var slow2 = assertThrows(org.opentest4j.AssertionFailedError.class,
            () -> org.junit.jupiter.api.Assertions.assertTimeoutPreemptively(java.time.Duration.ofMillis(50),
                    () -> Thread.sleep(2000)));
    p("assertTimeoutPreemptively failure message: %s", slow2.getMessage());
    assertTrue(seenBy[0].equals(test));
    assertFalse(seenBy[1].equals(test));
}

assertTimeout            runs the code on the test thread : true
assertTimeoutPreemptively runs the code on the test thread : false
assertTimeout failure message (trimmed at ' by '): execution exceeded timeout of 50 ms
assertTimeoutPreemptively failure message: execution timed out after 50 ms

Trap. Because the preemptive variant leaves the test thread, anything bound to that thread is invisible to the code: thread-local security or transaction context, and Mockito’s mockStatic (Q25). The real assertTimeout failure message ends with the overrun in milliseconds, which varies from run to run, so the transcript cuts it at by .

public static class Outcomes {
    @Test
    void passes() {
        assertEquals(2, 1 + 1);
    }

    @Test
    void assertionFails() {
        assertEquals(3, 1 + 1);
    }

    @Test
    void assumptionFails() {
        assumeTrue(false, "not on this machine");
        throw new AssertionError("never reached");
    }
}

assertionFails() -> FAILED
assumptionFails() -> ABORTED
passes() -> SUCCESSFUL

Trap. Assumptions are for environment (“needs Docker”), never for business conditions. An assumption that quietly fails on CI turns a real test into a permanent skip, and nobody is told.

@ExtendWith(Tracer.class)
public static class CallbackOrder {
    @BeforeEach
    void beforeEachMethod() {
        Log.add("test class: @BeforeEach method");
    }

    @Test
    void theTest() {
        Log.add("test class: the test body");
    }
}

declared: beforeAll
declared: beforeEach
test class: @BeforeEach method
declared: beforeTestExecution
test class: the test body
declared: afterTestExecution
declared: afterEach
declared: afterAll

@ExtendWith(Tracer.class)
public static class Registration {
    @RegisterExtension
    static final Tracer PROGRAMMATIC = new Tracer("programmatic(static field)");

    @Test
    void theTest() {
        Log.add("test body");
    }
}

declared: beforeAll
programmatic(static field): beforeAll
declared: beforeEach
programmatic(static field): beforeEach
declared: beforeTestExecution
programmatic(static field): beforeTestExecution
test body
programmatic(static field): afterTestExecution
declared: afterTestExecution
programmatic(static field): afterEach
declared: afterEach
programmatic(static field): afterAll
declared: afterAll

Trap. Do not rely on ordering between several extensions of the same kind; if two extensions must cooperate, make the dependency explicit. Per the user guide, a @RegisterExtension field must not be private and needs to be static for class-level callbacks such as beforeAll to reach it (documented, not executed here).

public static class TenantResolver implements ParameterResolver {
    @Override
    public boolean supportsParameter(ParameterContext p, ExtensionContext c) {
        return p.getParameter().getType() == Tenant.class;
    }

    @Override
    public Object resolveParameter(ParameterContext p, ExtensionContext c) {
        return new Tenant("tenant-for-" + c.getRequiredTestMethod().getName());
    }
}

@ExtendWith(TenantResolver.class)
public static class Injection {
    @Test
    void resolvesCustomAndBuiltIn(Tenant tenant, TestInfo info) {
        Log.add("custom parameter : " + tenant);
        Log.add("built-in TestInfo: displayName=" + info.getDisplayName());
    }
}

custom parameter : Tenant[name=tenant-for-resolvesCustomAndBuiltIn]
built-in TestInfo: displayName=resolvesCustomAndBuiltIn(Tenant, TestInfo)

public static class Sources {
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    void valueSource(int n) {
        assertTrue(n > 0);
    }

    @ParameterizedTest
    @CsvSource({"apple, 1", "banana, 2"})
    void csvSource(String fruit, int qty) {
        assertTrue(qty > 0);
    }

    @ParameterizedTest
    @MethodSource("pairs")
    void methodSource(String key, int value) {
        assertTrue(value > 0);
    }

    static Stream<Arguments> pairs() {
        return Stream.of(Arguments.of("x", 10), Arguments.of("y", 20));
    }

    @ParameterizedTest
    @EnumSource(Level.class)
    void enumSource(Level level) {
        assertTrue(level != null);
    }

    @ParameterizedTest
    @NullAndEmptySource
    @ValueSource(strings = {" "})
    void nullAndEmpty(String s) {
        assertTrue(s == null || s.isBlank());
    }
}

enumSource(Level) / [1] LOW -> SUCCESSFUL
enumSource(Level) / [2] HIGH -> SUCCESSFUL
valueSource(int) / [1] 1 -> SUCCESSFUL
valueSource(int) / [2] 2 -> SUCCESSFUL
valueSource(int) / [3] 3 -> SUCCESSFUL
nullAndEmpty(String) / [1] null -> SUCCESSFUL
nullAndEmpty(String) / [2] "" -> SUCCESSFUL
nullAndEmpty(String) / [3] " " -> SUCCESSFUL
csvSource(String, int) / [1] "apple", "1" -> SUCCESSFUL
csvSource(String, int) / [2] "banana", "2" -> SUCCESSFUL
methodSource(String, int) / [1] "x", 10 -> SUCCESSFUL
methodSource(String, int) / [2] "y", 20 -> SUCCESSFUL

public static class CsvConversion {
    @ParameterizedTest(name = "[{index}] a={0} b={1}")
    @CsvSource(value = {"x,", ",y", "'',z", "NIL,w", "'a,b',q"}, nullValues = "NIL")
    void csv(String a, String b) {
        Log.add("a=" + show(a) + "  b=" + show(b));
    }

    private static String show(String s) {
        return s == null ? "null" : "\"" + s + "\"";
    }
}

display name: csv(String, String) / [1] a="x" b=null -> SUCCESSFUL
display name: csv(String, String) / [2] a=null b="y" -> SUCCESSFUL
display name: csv(String, String) / [3] a="" b="z" -> SUCCESSFUL
display name: csv(String, String) / [4] a=null b="w" -> SUCCESSFUL
display name: csv(String, String) / [5] a="a,b" b="q" -> SUCCESSFUL
--- values the test method received ---
a="x"  b=null
a=null  b="y"
a=""  b="z"
a=null  b="w"
a="a,b"  b="q"

public static class Dynamic {
    static int beforeEachRuns;

    @BeforeEach
    void beforeEach() {
        beforeEachRuns++;
        Log.add("@BeforeEach ran (" + beforeEachRuns + " time so far)");
    }

    @TestFactory
    List<DynamicTest> squares() {
        return List.of(1, 2, 3).stream()
                .map(n -> DynamicTest.dynamicTest("square of " + n,
                        () -> assertTrue(n * n >= n)))
                .toList();
    }
}

@BeforeEach ran (1 time so far)
squares() / square of 1 -> SUCCESSFUL
squares() / square of 2 -> SUCCESSFUL
squares() / square of 3 -> SUCCESSFUL

public static class Conditions {
    @Test
    @Disabled("waiting for the fix in ticket 1234")
    void disabled() {
    }

    @Test
    @EnabledIfSystemProperty(named = "lab.run.slow", matches = "true")
    void onlyWithProperty() {
    }

    @Test
    @Tag("fast")
    void fast() {
    }

    @Test
    @Tag("slow")
    void slow() {
    }
}

--- no filter ---
disabled() -> SKIPPED (waiting for the fix in ticket 1234)
fast() -> SUCCESSFUL
onlyWithProperty() -> SKIPPED (System property [lab.run.slow] does not exist)
slow() -> SUCCESSFUL
--- includeTags("fast") ---
fast() -> SUCCESSFUL

Trap. A skip with a vague reason is permanent in practice. The report line System property [lab.run.slow] does not exist is the kind of message you want: it says exactly what to set. JRE-range conditions now default their minimum to Java 17 (release-notes-sourced).

public static class TempDirs {
    public static volatile Path seen;

    @TempDir
    Path dir;

    @Test
    void writesAFile() throws Exception {
        Files.writeString(dir.resolve("a.txt"), "hello");
        seen = dir;
        Log.add("inside the test : dir exists = " + Files.exists(dir)
                + ", files = " + Files.list(dir).count());
    }
}

inside the test : dir exists = true, files = 1
after the test finished : dir exists = false

@Test
void q18_mockVersusSpy() {
    Counter c1 = mock(Counter.class);
    Counter c2 = spy(new Counter());
    p("mock: next() -> %d, next() -> %d, real code ran %d times", c1.next(), c1.next(), c1.realCalls());
    p("spy : next() -> %d, next() -> %d, real code ran %d times", c2.next(), c2.next(), c2.realCalls());
    assertEquals(0, c1.next());
    assertEquals(3, c2.next());
    assertEquals(0, c1.realCalls());
    assertEquals(3, c2.realCalls());
}

mock: next() -> 0, next() -> 0, real code ran 0 times
spy : next() -> 1, next() -> 2, real code ran 2 times

Interview follow-up. Reaching for a spy is often a sign that the class under test does too much. Prefer a real collaborator or a mock; use a spy when you must keep most real behaviour and replace one method (legacy code you cannot refactor yet).

@Test
void q19_whenVersusDoReturnOnSpy() {
    Counter viaWhen = spy(new Counter());
    when(viaWhen.next()).thenReturn(100);
    p("when(spy.next()).thenReturn(100): real method ran while stubbing = %d time(s)", viaWhen.realCalls());
    Counter viaDo = spy(new Counter());
    doReturn(100).when(viaDo).next();
    p("doReturn(100).when(spy).next()   : real method ran while stubbing = %d time(s)", viaDo.realCalls());
    p("both return %d and %d after stubbing", viaWhen.next(), viaDo.next());
    assertEquals(1, viaWhen.realCalls());
    assertEquals(0, viaDo.realCalls());
}

when(spy.next()).thenReturn(100): real method ran while stubbing = 1 time(s)
doReturn(100).when(spy).next()   : real method ran while stubbing = 0 time(s)
both return 100 and 100 after stubbing

@Test
void q20_verify() {
    PaymentGateway gw = mock(PaymentGateway.class);
    when(gw.charge("a", 500)).thenReturn(true);
    OrderService svc = new OrderService(gw, Clock.systemUTC());
    svc.place("a", 500);
    svc.place("b", 700);
    svc.place("a", 900);
    verify(gw, times(2)).charge(eq("a"), anyLong());
    verify(gw, atLeastOnce()).audit("declined b");
    verify(gw, never()).lookup("x");
    InOrder order = inOrder(gw);
    order.verify(gw).charge("a", 500);
    order.verify(gw).audit("charged a 500");
    order.verify(gw).charge("b", 700);
    p("times / atLeastOnce / never / inOrder: all passed");
    Throwable e1 = assertThrows(WantedButNotInvoked.class, () -> verify(gw).lookup("zzz"));
    p("--- verify(gw).lookup(\"zzz\") ---");
    p("%s", firstLines(e1, 2));
    Throwable e2 = assertThrows(ArgumentsAreDifferent.class, () -> verify(gw).audit("declined c"));
    p("--- verify(gw).audit(\"declined c\") ---");
    p("%s", firstLines(e2, 6));
    Throwable e3 = assertThrows(NeverWantedButInvoked.class, () -> verify(gw, never()).audit("declined b"));
    p("--- verify(gw, never()).audit(\"declined b\") ---");
    p("%s", firstLines(e3, 2));
}

times / atLeastOnce / never / inOrder: all passed
--- verify(gw).lookup("zzz") ---
Wanted but not invoked:
paymentGateway.lookup("zzz");
--- verify(gw).audit("declined c") ---
Argument(s) are different! Wanted:
paymentGateway.audit("declined c");
-> at lab.jm.D_MockitoCoreTest.lambda$q20_verify$1(D_MockitoCoreTest.java:90)
Actual invocations have different arguments:
paymentGateway.charge("a", 500L);
-> at lab.jm.OrderService.place(OrderService.java:17)
--- verify(gw, never()).audit("declined b") ---
paymentGateway.audit("declined b");
Never wanted here:

Trap. Over-verifying couples the test to the implementation: verify the outcomes that matter to the caller (a charge was attempted, an audit line was written), not every internal call.

@Test
void q21_matchersAndCaptor() {
    PaymentGateway gw = mock(PaymentGateway.class);
    InvalidUseOfMatchersException mixed = assertThrows(InvalidUseOfMatchersException.class,
            () -> when(gw.charge("a", anyLong())).thenReturn(true));
    p("when(gw.charge(\"a\", anyLong())) -> %s", mixed.getClass().getSimpleName());
    p("%s", firstLines(mixed, 3));
    OrderService svc = new OrderService(gw, Clock.systemUTC());
    svc.place("zoe", 1234);
    ArgumentCaptor<String> account = ArgumentCaptor.forClass(String.class);
    ArgumentCaptor<Long> cents = ArgumentCaptor.forClass(Long.class);
    verify(gw).charge(account.capture(), cents.capture());
    p("ArgumentCaptor saw account=%s cents=%d", account.getValue(), cents.getValue());
    assertEquals("zoe", account.getValue());
    assertEquals(1234L, cents.getValue());
}

when(gw.charge("a", anyLong())) -> InvalidUseOfMatchersException
Invalid use of argument matchers!
2 matchers expected, 1 recorded:
-> at lab.jm.D_MockitoCoreTest.lambda$q21_matchersAndCaptor$0(D_MockitoCoreTest.java:103)
ArgumentCaptor saw account=zoe cents=1234

@ExtendWith(MockitoExtension.class)
public static class StrictByDefault {
    @Mock
    PaymentGateway gateway;

    @Test
    void unusedStub() {
        when(gateway.lookup("42")).thenReturn("Ada");
    }
}

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public static class Lenient {
    @Mock
    PaymentGateway gateway;

    @Test
    void unusedStub() {
        when(gateway.lookup("42")).thenReturn("Ada");
    }
}

MockitoExtension (default strictness):
  unusedStub() -> FAILED
  org.mockito.exceptions.misusing.UnnecessaryStubbingException
    
    Unnecessary stubbings detected.
    Clean & maintainable test code requires zero unnecessary code.
    Following stubbings are unnecessary (click to navigate to relevant line of code):
      1. -> at lab.jm.fixtures.MockitoFixtures$StrictByDefault.unusedStub(MockitoFixtures.java:25)
    Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.
@MockitoSettings(strictness = LENIENT):
  unusedStub() -> SUCCESSFUL

@Test
void q23_stubbingStyles() {
    PaymentGateway gw = mock(PaymentGateway.class);
    when(gw.charge("a", 1)).thenReturn(true, false).thenThrow(new IllegalStateException("gateway down"));
    p("consecutive stubbing: %s, %s", gw.charge("a", 1), gw.charge("a", 1));
    IllegalStateException ex = assertThrows(IllegalStateException.class, () -> gw.charge("a", 1));
    p("third call throws   : %s", ex.getMessage());
    doThrow(new RuntimeException("audit store full")).when(gw).audit("x");
    RuntimeException v = assertThrows(RuntimeException.class, () -> gw.audit("x"));
    p("void method via doThrow: %s", v.getMessage());
    given(gw.lookup("7")).willAnswer(inv -> "user-" + inv.getArgument(0));
    p("thenAnswer / BDD willAnswer: lookup(\"7\") = %s", gw.lookup("7"));
    assertEquals("user-7", gw.lookup("7"));
    // Stubbing a void method with when(...) does not compile, which is why doThrow/doNothing exist.
}

consecutive stubbing: true, false
third call throws   : gateway down
void method via doThrow: audit store full
thenAnswer / BDD willAnswer: lookup("7") = user-7

@Test
void q28_unstubbedDefaults() {
    Probe m = mock(Probe.class);
    p("int            -> %s", m.number());
    p("boolean        -> %s", m.flag());
    p("String         -> %s", m.text());
    p("List<String>   -> %s", m.list());
    p("Optional<String> -> %s", m.opt());
    p("long           -> %s", m.big());
    assertEquals(0, m.number());
    assertEquals(List.of(), m.list());
    assertEquals(Optional.empty(), m.opt());
    assertTrue(m.text() == null);
}

interface Probe {
    int number();

    boolean flag();

    String text();

    List<String> list();

    Optional<String> opt();

    long big();
}

int            -> 0
boolean        -> false
String         -> null
List<String>   -> []
Optional<String> -> Optional.empty
long           -> 0

Trap. In Q20 the account "b" was never stubbed, so charge returned false and the service answered DECLINED. A test that expected a different outcome would have failed for a reason that looks unrelated to the missing stub.

@Test
void q24_finalClassesAndMockMaker() throws Exception {
    FinalPricer pricer = mock(FinalPricer.class);
    when(pricer.price(3)).thenReturn(999);
    p("FinalPricer is final: %s", java.lang.reflect.Modifier.isFinal(FinalPricer.class.getModifiers()));
    p("mock(FinalPricer.class).price(3) = %d (real code would give 30)", pricer.price(3));
    p("mock.getClass() == FinalPricer.class : %s", pricer.getClass() == FinalPricer.class);
    var maker = org.mockito.internal.configuration.plugins.Plugins.getMockMaker();
    p("default MockMaker : %s", maker.getClass().getName());
    int major;
    try (InputStream in = org.mockito.Mockito.class.getResourceAsStream("Mockito.class")) {
        byte[] head = in.readNBytes(8);
        major = ((head[6] & 0xff) << 8) | (head[7] & 0xff);
    }
    p("class-file major version of org.mockito.Mockito : %d (Java %d)", major, major - 44);
    assertEquals(999, pricer.price(3));
    assertTrue(pricer.getClass() == FinalPricer.class);
    assertTrue(maker.getClass().getSimpleName().contains("Inline"));
    assertEquals(55, major);
}

FinalPricer is final: true
mock(FinalPricer.class).price(3) = 999 (real code would give 30)
mock.getClass() == FinalPricer.class : true
default MockMaker : org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker
class-file major version of org.mockito.Mockito : 55 (Java 11)

@Test
void q25_mockStatic() throws Exception {
    p("before            : %s", Ids.newOrderId());
    AtomicReference<String> otherThread = new AtomicReference<>();
    try (MockedStatic<Ids> ids = mockStatic(Ids.class)) {
        ids.when(Ids::newOrderId).thenReturn("MOCK-ID");
        p("inside the scope  : %s", Ids.newOrderId());
        Thread t = new Thread(() -> otherThread.set(Ids.newOrderId()));
        t.start();
        t.join();
        p("other thread sees : %s", otherThread.get());
        ids.verify(Ids::newOrderId, org.mockito.Mockito.times(1));
    }
    p("after the scope   : %s", Ids.newOrderId());
    assertEquals("REAL-ID", otherThread.get());
    assertEquals("REAL-ID", Ids.newOrderId());
}

before            : REAL-ID
inside the scope  : MOCK-ID
other thread sees : REAL-ID
after the scope   : REAL-ID

Interview follow-up. If you need mockStatic often, the design is asking for a seam: pass an IdGenerator in, or use a Clock as in Q29. Static mocking is a tool for code you cannot change.

@Test
void q26_mockConstruction() {
    p("before : %s", Receipt.print("tea"));
    try (MockedConstruction<Receipt> mc = mockConstruction(Receipt.class,
            (mock, ctx) -> when(mock.render()).thenReturn("FAKE " + ctx.arguments()))) {
        p("inside : %s", Receipt.print("tea"));
        p("constructed during the scope: %d", mc.constructed().size());
        assertEquals(1, mc.constructed().size());
    }
    p("after  : %s", Receipt.print("tea"));
    assertFalse(Receipt.print("tea").startsWith("FAKE"));
}

before : RECEIPT[tea]
inside : FAKE [tea]
constructed during the scope: 1
after  : RECEIPT[tea]

Mockito is currently self-attaching to enable the inline-mock-maker. This will no longer work in future releases of the JDK. Please add Mockito as an agent to your build as described in Mockito's documentation: https://javadoc.io/doc/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html#0.3
WARNING: A Java agent has been loaded dynamically (~/.m2/repository/net/bytebuddy/byte-buddy-agent/1.17.7/byte-buddy-agent-1.17.7.jar)
WARNING: If a serviceability tool is in use, please run with -XX:+EnableDynamicAgentLoading to hide this warning
WARNING: If a serviceability tool is not in use, please run with -Djdk.instrument.traceUsage for more information
WARNING: Dynamic loading of agents will be disallowed by default in a future release

<!-- Mockito's recommended setup on JDK 21+: load its agent at JVM start instead of self-attaching.
     scripts/no-agent.sh overrides this property to reproduce the warning (Q27). -->
<mockito.agentArg>-javaagent:${settings.localRepository}/org/mockito/mockito-core/${mockito.version}/mockito-core-${mockito.version}.jar</mockito.agentArg>

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>3.6.0</version>
  <configuration>
    <argLine>${mockito.agentArg} -Duser.timezone=UTC -Dfile.encoding=UTF-8</argLine>
  </configuration>
</plugin>

public static class SharedState {
    public static final List<String> REGISTRY = new ArrayList<>();

    @Test
    void a_registersUser() {
        REGISTRY.add("ada");
    }

    @Test
    void b_assumesUserExists() {
        assertEquals(1, REGISTRY.size(), "registry should contain the user registered by another test");
    }
}

public static class ReverseOrder implements MethodOrderer {
    @Override
    public void orderMethods(MethodOrdererContext context) {
        context.getMethodDescriptors().sort(
                (x, y) -> y.getMethod().getName().compareTo(x.getMethod().getName()));
    }
}

--- order a_, b_ (alphabetical) ---
a_registersUser() -> SUCCESSFUL
b_assumesUserExists() -> SUCCESSFUL
--- order b_, a_ (reversed) ---
b_assumesUserExists() -> FAILED
a_registersUser() -> SUCCESSFUL
  AssertionFailedError: registry should contain the user registered by another test ==> expected: <1> but was: <0>
--- time: the same code with an injected Clock ---
acceptsOrders() at 10:00 UTC : true
acceptsOrders() at 23:30 UTC : false

public static class Intermittent {
    @RepeatedTest(value = 6, failureThreshold = 1)
    void failsOnThirdRepetition(RepetitionInfo info) {
        assertTrue(info.getCurrentRepetition() != 3, "intermittent failure on repetition 3");
    }

    @RepeatedTest(value = 6)
    void withoutThreshold(RepetitionInfo info) {
        assertTrue(info.getCurrentRepetition() != 3, "intermittent failure on repetition 3");
    }
}

failsOnThirdRepetition(RepetitionInfo) / repetition 1 of 6 -> SUCCESSFUL
failsOnThirdRepetition(RepetitionInfo) / repetition 2 of 6 -> SUCCESSFUL
failsOnThirdRepetition(RepetitionInfo) / repetition 3 of 6 -> FAILED
failsOnThirdRepetition(RepetitionInfo) / repetition 4 of 6 -> SKIPPED (Failure threshold [1] exceeded)
failsOnThirdRepetition(RepetitionInfo) / repetition 5 of 6 -> SKIPPED (Failure threshold [1] exceeded)
failsOnThirdRepetition(RepetitionInfo) / repetition 6 of 6 -> SKIPPED (Failure threshold [1] exceeded)
withoutThreshold(RepetitionInfo) / repetition 1 of 6 -> SUCCESSFUL
withoutThreshold(RepetitionInfo) / repetition 2 of 6 -> SUCCESSFUL
withoutThreshold(RepetitionInfo) / repetition 3 of 6 -> FAILED
withoutThreshold(RepetitionInfo) / repetition 4 of 6 -> SUCCESSFUL
withoutThreshold(RepetitionInfo) / repetition 5 of 6 -> SUCCESSFUL
withoutThreshold(RepetitionInfo) / repetition 6 of 6 -> SUCCESSFUL
failed=2 skipped=3

Trap. Build-level retry (for example Surefire’s rerunFailingTestsCount) can turn a red build green and report the test as “flaky”. That keeps the pipeline moving but hides a real defect; treat it as a short-term bandage with a ticket attached (documented, not executed here).