by BehindJava

How to test methods that call System.exit() in Java

Home » java » How to test methods that call System.exit() in Java

This is a quick tutorial on methods that call System.exit() in Java.

Why System.exit() ?

Instead of terminating with System.exit(whateverValue), why not throw an unchecked exception? In normal use it will drift all the way out to the JVM’s last-ditch catcher and shut your script down (unless you decide to catch it somewhere along the way, which might be useful someday).

In the JUnit scenario it will be caught by the JUnit framework, which will report that such-and-such test failed and move smoothly along to the next.

Most solutions will be following:

  • Terminate the test (method, not the entire run) the moment System.exit() is called
  • Ignore an already installed SecurityManager
  • Sometimes be quite specific to a test framework
  • Restrict to be used at max once per test case

Thus, most solutions are not suited for situations where:

  • Verification of side-effects are to be performed after the call to System.exit()
  • An existing security manager is part of the testing.
  • A different test framework is used.
  • You want to have multiple verifications in a single test case. This may be strictly not recommended, but can be very convenient at times, especially in combination with assertAll(), for example.

The following class provides a method assertExits(int expectedStatus, Executable executable) which asserts that System.exit() is called with a specified status value, and the test can continue after it. It works the same way as JUnit 5 assertThrows. It also respects an existing security manager.

There is one remaining problem: When the code under test installs a new security manager which completely replaces the security manager set by the test. All other SecurityManager-based solutions known to me suffer the same problem.


import static java.lang.System.getSecurityManager;
import static java.lang.System.setSecurityManager;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static;

public enum ExitAssertions {

    public static <E extends Throwable> void assertExits(final int expectedStatus, final ThrowingExecutable<E> executable) throws E {
        final SecurityManager originalSecurityManager = getSecurityManager();
        setSecurityManager(new SecurityManager() {
            public void checkPermission(final Permission perm) {
                if (originalSecurityManager != null)

            public void checkPermission(final Permission perm, final Object context) {
                if (originalSecurityManager != null)
                    originalSecurityManager.checkPermission(perm, context);

            public void checkExit(final int status) {
                throw new ExitException(status);
        try {
            fail("Expected System.exit(" + expectedStatus + ") to be called, but it wasn't called.");
        } catch (final ExitException e) {
            assertEquals(expectedStatus, e.status, "Wrong System.exit() status.");
        } finally {

    public interface ThrowingExecutable<E extends Throwable> {
        void run() throws E;

    private static class ExitException extends SecurityException {
        final int status;

        private ExitException(final int status) {
            this.status = status;

You can use the class like this:

    void example() {
        assertExits(0, () -> System.exit(0)); // succeeds
        assertExits(1, () -> System.exit(1)); // succeeds
        assertExits(2, () -> System.exit(1)); // fails

The code can easily be ported to JUnit 4, TestNG, or any other framework, if necessary. The only framework-specific element is failing the test. This can easily be changed to something framework-independent (other than a Junit 4 Rule

There is room for improvement, for example, overloading assertExits() with customizable messages.