}
    }

  private val backend = TaskRunner.RealBackend(threadFactory)
  private val taskRunner = TaskRunner(backend)
  private val queue = taskRunner.newQueue()

  @AfterEach fun tearDown() {
    backend.shutdown()
  }

  @Test fun test() {
    val t1 = System.nanoTime() / 1e6

    val delays = mutableListOf(TimeUnit.MILLISECONDS.toNanos(1000), -1L)
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(750)) {

# Testing Events: startup - shutdown

Cuando necesitas que tus manejadores de eventos (`startup` y `shutdown`) se ejecuten en tus tests, puedes usar el `TestClient` con un statement `with`:

    }

    @Test
    void testShutdown() {
        assertDoesNotThrow(() -> channelManager.shutdown());

        // Multiple shutdowns should be safe
        assertDoesNotThrow(() -> channelManager.shutdown());
    }

    @Test
    void testLoadBalancerAccess() {
        ChannelLoadBalancer balancer = channelManager.getLoadBalancer();

            return defaultCreds;
        }

        @Override
        public boolean close() throws CIFSException {
            closeCalled = true;
            // Call super.close() to ensure the shutdown hook is removed
            return super.close();
        }

        public boolean isCloseCalled() {
            return closeCalled;
        }

        @Override

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

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

  /** Simple same thread listening executor service that doesn't handle shutdown. */
  private static class TestListeningExecutorService extends AbstractListeningExecutorService {

    @Override
    public void execute(Runnable runnable) {
      assertThat(runnable).isInstanceOf(TrustedListenableFutureTask.class);
      runnable.run();
    }

    @Override
    public void shutdown() {}

    @Override
    public List<Runnable> shutdownNow() {

  /** Simple same thread listening executor service that doesn't handle shutdown. */
  private static class TestListeningExecutorService extends AbstractListeningExecutorService {

    @Override
    public void execute(Runnable runnable) {
      assertThat(runnable).isInstanceOf(TrustedListenableFutureTask.class);
      runnable.run();
    }

    @Override
    public void shutdown() {}

    @Override
    public List<Runnable> shutdownNow() {

            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();
            }

        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));
        }

                    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();
            }