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

    ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor();
    assertFalse(executor.isShutdown());
    assertFalse(executor.isTerminated());
    executor.shutdown();
    assertTrue(executor.isShutdown());
    assertTrue(executor.isTerminated());
  }

  public void testNoOpScheduledExecutorInvokeAll() throws ExecutionException, InterruptedException {

 * with the abstract {@link #execute execute(Runnable)} method.
 *
 * <p>In addition to {@link #execute}, subclasses must implement all methods related to shutdown and
 * termination.
 *
 * @author Chris Povirk
 * @since 14.0
 */
@CheckReturnValue
@GwtIncompatible
@J2ktIncompatible
@ElementTypesAreNonnullByDefault

 * with the abstract {@link #execute execute(Runnable)} method.
 *
 * <p>In addition to {@link #execute}, subclasses must implement all methods related to shutdown and
 * termination.
 *
 * @author Chris Povirk
 * @since 14.0
 */
@CheckReturnValue
@GwtIncompatible
@J2ktIncompatible
@ElementTypesAreNonnullByDefault

      println("Test count: $count")
      for (number in 1..count) {
        runTest(number, count)
      }
      updateReports()
    } finally {
      client.dispatcher.executorService.shutdown()
    }
  }

  private fun runTest(
    number: Long,
    count: Long,
  ) {
    val latch = CountDownLatch(1)
    val startNanos = AtomicLong()
    newWebSocket(

    @Override
    public void run () {
        try {
            this.closed = true;
            close();
        }
        catch ( CIFSException e ) {
            log.warn("Failed to close context on shutdown", e);
        }
    }

  private val socksProxy = SocksProxy()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    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 =

            listenerLatch.countDown();
          }
        },
        directExecutor());
  }

  @Override
  protected void tearDown() throws Exception {
    if (exec != null) {
      exec.shutdown();
    }

    super.tearDown();
  }

  public void testListenerDoesNotRunUntilTaskCompletes() throws Exception {

    // Test default state of not started.
    assertEquals(1, listenerLatch.getCount());

          .build(),
      )
      .addQuicHint("google.com", 443, 443)
      .addQuicHint("www.google.com", 443, 443)
      .build()

  @After
  fun tearDown() {
    engine.shutdown()
    cacheDir.deleteRecursively()
  }

  @Test
  fun get() {
    val executor = Executors.newCachedThreadPool()

    val completableFuture = execute(engine, executor, "https://google.com/robots.txt")

      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Exception e) {
          e.printStackTrace();
        }
      });
    }
    executor.shutdown();
  }

  private void drainQueue() throws Exception {
    for (HttpUrl url; (url = queue.take()) != null; ) {
      if (!fetchedUrls.add(url)) {
        continue;
      }