assertEquals(listener, jobExecutor.shutdownListener);

        // Verify listener is called on shutdown
        jobExecutor.shutdown();
        assertTrue(shutdownCalled.get());
    }

    public void test_addShutdownListener_replace() {
        // Test replacing shutdown listener
        AtomicInteger callCount = new AtomicInteger(0);
        ShutdownListener listener1 = new ShutdownListener() {

### `shutdown` event { #shutdown-event }

To add a function that should be run when the application is shutting down, declare it with the event `"shutdown"`:

{* ../../docs_src/events/tutorial002.py hl[6] *}

Here, the `shutdown` event handler function will write a text line `"Application shutdown"` to a file `log.txt`.

/// info

    }

    public void test_shutdown_withListener() {
        // Add shutdown listener
        TestShutdownListener listener = new TestShutdownListener();
        scriptExecutor.addShutdownListener(listener);

        // Verify listener not called yet
        assertFalse(listener.wasShutdownCalled());

        // Call shutdown
        scriptExecutor.shutdown();

        // Verify listener was called

            return t;
        };
        cleanupExecutor = Executors.newSingleThreadScheduledExecutor(threadFactory);

        // Add shutdown hook for cleanup
        Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown, "ResourceManager-Shutdown"));

        startCleanupTask();
    }

    /**
     * Get the singleton instance
     *
     * @return ResourceManager instance
     */

# Testing Events: lifespan and startup - shutdown { #testing-events-lifespan-and-startup-shutdown }

When you need `lifespan` to run in your tests, you can use the `TestClient` with a `with` statement:

{* ../../docs_src/app_testing/tutorial004.py hl[9:15,18,27:28,30:32,41:43] *}


You can read more details about the ["Running lifespan in tests in the official Starlette documentation site."](https://www.starlette.io/lifespan/#running-lifespan-in-tests)

            lock.writeLock().unlock();
        }
    }

    /**
     * Shuts down the persistent handle manager and its background tasks
     */
    public void shutdown() {
        shutdown = true;
        scheduler.shutdown();
    }

        startLatch.countDown();

        // Wait for completion
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete within timeout");
        executor.shutdown();

        // Then - Verify no exceptions occurred
        if (!exceptions.isEmpty()) {
            fail("Concurrent operations caused exceptions: " + exceptions.get(0));
        }

            changeNotifier.stopWatching(directoryPath);
            baseLeaseManager.releaseLease(entry.getLeaseKey());
        }
    }

    /**
     * Shutdown the directory lease manager
     */
    public void shutdown() {
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }

                    log.error("Error processing audit log entry", e);
                }
            }
        });
    }

    /**
     * Shutdown the audit logger gracefully
     */
    public void shutdown() {
        shutdown = true;
        logExecutor.shutdown();
        try {
            if (!logExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                logExecutor.shutdownNow();
            }

    private static final Logger log = LoggerFactory.getLogger(AbstractCIFSContext.class);
    private boolean closed;

    /**
     * Default constructor that registers a shutdown hook for cleanup
     */
    public AbstractCIFSContext() {
        Runtime.getRuntime().addShutdownHook(this);
    }

    /**
     * @param creds the credentials to use