fileCache.remove(path);
        }
    }

    /**
     * Shutdown the lease manager
     */
    public void shutdown() {
        log.info("Shutting down lease manager");

        // Stop cleanup executor
        if (cleanupExecutor != null) {
            cleanupExecutor.shutdown();
            try {
                if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {

- JSON schema: Схема JSON
- password flow: потік паролю
- mobile: мобільний
- body: тіло
- form: форма
- path: шлях
- query: запит
- cookie: кукі
- header: заголовок
- startup: запуск
- shutdown: вимкнення
- lifespan: тривалість життя
- authorization: авторизація
- forwarded header: направлений заголовок
- dependable: залежний
- dependent: залежний
- bound: межа
- concurrency: рівночасність

    future.addListener(latch::countDown, exec);

    assertEquals(1, latch.getCount());
    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void tearDown() {
    exec.shutdown();
  }

  public void testCompletedFuture(@Nullable Object expectedValue)
      throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    int getMaxMessageSize();

    /**
     * Clean up provider resources
     *
     * This method should be called when the provider is no longer needed
     * to release any system resources.
     */
    void shutdown();

 * ```
 *
 * ## Shutdown Isn't Necessary
 *
 * The threads and connections that are held will be released automatically if they remain idle. But
 * if you are writing a application that needs to aggressively release unused resources you may do
 * so.
 *
 * Shutdown the dispatcher's executor service with [shutdown()][ExecutorService.shutdown]. This will

    executor.shutdown();
    assertFalse(awaitTerminationUninterruptibly(executor, 1000, MILLISECONDS));
    assertFalse(executor.isTerminated());
    assertInterrupted();
  }

  public void testTryAwaitTerminationInfiniteTimeout() {
    ExecutorService executor = newFixedThreadPool(1);
    requestInterruptIn(500);
    executor.execute(new SleepTask(1000));
    executor.shutdown();

    future.addListener(latch::countDown, exec);

    assertEquals(1, latch.getCount());
    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void tearDown() {
    exec.shutdown();
  }

  public void testCompletedFuture(@Nullable Object expectedValue)
      throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

  @StartStop
  private val server = MockWebServer()

  private val socksProxy = SocksProxy()

  @BeforeEach
  fun setUp() {
    socksProxy.play()
  }

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

  @Test
  fun proxy() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    server.enqueue(MockResponse.Builder().body("def").build())
    val client =
      clientTestRule

                        throw new AssertionError();
                    }
                  }
                  return threadSum;
                }
              }));
    }
    threadPool.shutdown();
    assertTrue(threadPool.awaitTermination(300, SECONDS));
    long sum = 0;
    for (Future<Long> f : futures) {
      sum += f.get();
    }
    assertEquals(sum, map.get(key));
  }

    }

    @AfterEach
    public void tearDown() throws Exception {
        if (directoryLeaseManager != null) {
            directoryLeaseManager.shutdown();
        }
        if (baseLeaseManager != null) {
            baseLeaseManager.shutdown();
        }
        if (mocks != null) {
            mocks.close();
        }
    }

    @Test