} finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS));
        executor.shutdown();
    }

    @Test
    @DisplayName("Test invalid session ID handling")
    public void testInvalidSessionIdHandling() {
        assertThrows(CIFSException.class, () -> {

    // Cause acceptConnections() to break out.
    serverSocket.closeQuietly()

    // Await shutdown.
    for (queue in taskRunner.activeQueues()) {
      if (!queue.idleLatch().await(5, TimeUnit.SECONDS)) {
        throw AssertionError("Gave up waiting for queue to shut down")
      }
    }
    taskRunnerBackend.shutdown()
  }

  private fun serveConnection(
    connectionIndex: Int,
    raw: Socket,

                .get(10, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.warn("Error during witness client shutdown", e);
        }
        
        // Shutdown scheduler
        scheduler.shutdown();
        
        // Close RPC client
        if (rpcClient != null) {
            rpcClient.close();
        }
    }
}
```

                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }
                });
            }

            executor.shutdown();
            assertTrue(executor.awaitTermination(30, TimeUnit.SECONDS), "All threads should complete within timeout");

            // Analyze timing consistency across threads
            if (!timings.isEmpty()) {

                    }
                }
            });
        }

        startLatch.countDown();
        endLatch.await(10, TimeUnit.SECONDS);
        executor.shutdown();

        assertEquals(threadCount * operationsPerThread, crawlerContext.getAccessCount());
    }

    /**
     * Test status getter and setter
     */
    public void test_status() {

    socketFactory[proxyServer2] = server2.socketAddress

    println("\n\nRequest to ${server2.socketAddress}")
    executeSynchronously(request)
      .apply {
        // We may have a single failed request if not clean shutdown
        if (cleanClose) {
          assertSuccessful()
          assertCode(200)

          assertThat(server2.requestCount).isEqualTo(1)
        } else {

  /** Returns the lifecycle state of the service. */
  State state();

  /**
   * If the service is {@linkplain State#STARTING starting} or {@linkplain State#RUNNING running},
   * this initiates service shutdown and returns immediately. If the service is {@linkplain
   * State#NEW new}, it is {@linkplain State#TERMINATED terminated} without having been started nor

 *       MoreExecutors.directExecutor());
 *
 *     Runtime.getRuntime().addShutdownHook(new Thread() {
 *       public void run() {
 *         // Give the services 5 seconds to stop to ensure that we are responsive to shutdown
 *         // requests.
 *         try {
 *           manager.stopAsync().awaitStopped(5, TimeUnit.SECONDS);
 *         } catch (TimeoutException timeout) {
 *           // stopping timed out
 *         }

 *       MoreExecutors.directExecutor());
 *
 *     Runtime.getRuntime().addShutdownHook(new Thread() {
 *       public void run() {
 *         // Give the services 5 seconds to stop to ensure that we are responsive to shutdown
 *         // requests.
 *         try {
 *           manager.stopAsync().awaitStopped(5, TimeUnit.SECONDS);
 *         } catch (TimeoutException timeout) {
 *           // stopping timed out
 *         }

    assertThat(Sets.union(cache.asMap().keySet(), removalNotifications.keySet()))
        .isEqualTo(expectedKeys);
    assertThat(cache.asMap().keySet()).containsNoneIn(removalNotifications.keySet());
    threadPool.shutdown();
    threadPool.awaitTermination(300, SECONDS);
  }

  /**
   * Calls get() repeatedly from many different threads, and tests that all of the removed entries