JUnit 4 ships several ready-made rules — `TemporaryFolder`, `ExternalResource`, `Timeout`, `ExpectedException`, `TestName` and `ErrorCollector`. What does each one do, and which of them is now discouraged?

## Why built-in rules matter Almost every custom rule people write is a variation on one of the shipped ones. Knowing the catalogue keeps you from reinventing them, and each illustrates a different capability of the rule mechanism. ## TemporaryFolder Creates a fresh directory before the test and deletes it (recursively) afterwards, so file-touching tests never collide or leave litter. Use `folder.newFile("x.txt")`, `folder.newFolder("sub")`, `folder.getRoot()`. Since JUnit 4.13, `TemporaryFolder.builder().assureDeletion().build()` makes the rule *fail* the test when deletion does not succeed — useful on platforms where an open handle silently blocks cleanup. As a `@Rule` you get one folder per test; as a `@ClassRule`, one per class. ## ExternalResource An abstract `TestRule` with two hooks: ```java protected void before() throws Throwable {} protected void after() {} ``` It is the correct starting point for "start something, then stop it" — a server, a connection pool, a container, a temp workspace. It already handles calling `after()` in a `finally`, so cleanup runs even when the test throws. `TemporaryFolder` itself extends it. ## Timeout Fails a test that runs longer than a limit. `@Rule public Timeout timeout = Timeout.seconds(5);` applies the limit to *every* method in the class, which is its advantage over `@Test(timeout = …)` on each method. It executes the statement on a separate thread and interrupts it on expiry — so a test that ignores interruption may leave the thread running. `Timeout.builder().withTimeout(5, SECONDS).withLookingForStuckThread(true).build()` adds the stuck thread's stack trace to the failure. Note that JUnit documents `Timeout` as undefined behaviour when used as a `@ClassRule`. ## DisableOnDebug Wraps another rule and disables it when the JVM is running under a debugger: `@Rule public TestRule timeout = new DisableOnDebug(Timeout.seconds(5));`. Without it, every debugging session ends in a spurious timeout failure. This is the classic "nice-to-know" answer that shows real usage. ## TestName `@Rule public TestName name = new TestName();` then `name.getMethodName()` inside the test. Useful for naming generated artifacts or log lines per test. It is a thin `TestWatcher` that records the description. ## ErrorCollector Lets a test report several problems in one run rather than stopping at the first assertion failure: `collector.checkThat(actual, is(expected))`, `collector.addError(throwable)`, `collector.checkSucceeds(callable)`. Failures accumulate and are reported together at the end. It extends `Verifier`, the general "run an extra check after the test body" rule. Both are documented as undefined behaviour at class scope. ## TestWatcher Not a resource but an observer: override `succeeded(Description)`, `failed(Throwable, Description)`, `skipped(AssumptionViolatedException, Description)`, `starting`, `finished`. It never changes the outcome — it is how you dump a screenshot, page source or server log on failure. `Stopwatch` is a sibling that times each test. ## ExpectedException — the discouraged one The old declarative style: ```java @Rule public ExpectedException thrown = ExpectedException.none(); @Test public void rejectsBadInput() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("amount"); service.charge(-1); } ``` `ExpectedException.none()` is deprecated as of JUnit 4.13, with the javadoc pointing at `Assert.assertThrows`. The reasons are practical: the expectation is declared before the action, so any statement after it — including setup lines — could satisfy it, hiding the real source of the exception; and once the rule catches the exception you cannot make further assertions on it. `assertThrows` scopes the expectation to exactly one lambda and hands the exception back: ```java IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> service.charge(-1)); assertThat(e.getMessage(), containsString("amount")); ``` ## Picking the right one Resource with a lifecycle → `ExternalResource`. Files → `TemporaryFolder`. Diagnostics on failure → `TestWatcher`. Several independent checks in one test → `ErrorCollector` (but consider whether the test is doing too much). Exceptions → `assertThrows`, not `ExpectedException`. Hanging tests → `Timeout`, wrapped in `DisableOnDebug` so debugging still works.