*
   * @throws RejectedExecutionException if the queue is shut down and the task is not cancelable.
   */
  fun schedule(
    task: Task,
    delayNanos: Long = 0L,
  ) {
    taskRunner.withLock {
      if (shutdown) {
        if (task.cancelable) {
          taskRunner.logger.taskLog(task, this) { "schedule canceled (queue is shutdown)" }
          return
        }

        // Close the writer on the writer's thread.
        val writerToClose = this.writer
        if (writerToClose != null) {
          this.writer = null
          taskQueue.execute("$name writer close", cancelable = false) {
            writerToClose.closeQuietly()
          }
        }

        this.taskQueue.shutdown()
      }

      sendOnClosed = !failed && writer == null && receivedCloseCode != -1
    }

      boundSocketAddress = InetSocketAddress(boundSocketAddress.address, serverSocket.localPort)
    } finally {
      this.socketAddress_ = boundSocketAddress
    }

    taskRunner.newQueue().execute(toString(), cancelable = false) {
      try {
        logger.fine("$this starting to accept connections")
        acceptConnections()
      } catch (e: Throwable) {
        logger.log(Level.WARNING, "$this failed unexpectedly", e)

    delegate.awaitTerminated(timeout, unit);
  }

  interface Cancellable {
    void cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();
  }

  private static final class FutureAsCancellable implements Cancellable {
    private final Future<?> delegate;

    FutureAsCancellable(Future<?> delegate) {
      this.delegate = delegate;
    }

    delegate.awaitTerminated(timeout, unit);
  }

  interface Cancellable {
    void cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();
  }

  private static final class FutureAsCancellable implements Cancellable {
    private final Future<?> delegate;

    FutureAsCancellable(Future<?> delegate) {
      this.delegate = delegate;
    }

    return if (connection.noNewExchanges || maxIdleConnections == 0) {
      connection.noNewExchanges = true
      connections.remove(connection)
      if (connections.isEmpty()) cleanupQueue.cancelAll()
      scheduleOpener(connection.route.address)
      true
    } else {
      scheduleCloser()
      false
    }
  }

  fun evictAll() {
    val i = connections.iterator()

          try {
            backend.coordinatorWait(this@TaskRunner, minDelayNanos)
          } catch (_: InterruptedException) {
            // Will cause all tasks to exit unless more are scheduled!
            cancelAll()
          } finally {
            coordinatorWaiting = false
          }
        }
      }
    }
  }

  /** Start another thread, unless a new thread is already scheduled to start. */

      val waitTime = (entryTime + 1_000_000_000L - System.nanoTime())
      if (!queue.idleLatch().await(waitTime, TimeUnit.NANOSECONDS)) {
        TaskRunner.INSTANCE.withLock {
          TaskRunner.INSTANCE.cancelAll()
        }
        fail<Unit>("Queue still active after 1000 ms")
      }
    }
  }

  override fun beforeEach(context: ExtensionContext) {
    testName = context.displayName

    beforeEach()

  }

  /**
   * Cancel all calls currently enqueued or executing. Includes calls executed both
   * [synchronously][Call.execute] and [asynchronously][Call.enqueue].
   */
  @Synchronized
  fun cancelAll() {
    for (call in readyAsyncCalls) {
      call.call.cancel()
    }
    for (call in runningAsyncCalls) {
      call.call.cancel()
    }
    for (call in runningSyncCalls) {
      call.cancel()

    val runningCalls: List<Call> = dispatcher.runningCalls()
    val queuedCallsCount: Int = dispatcher.queuedCallsCount()
    val runningCallsCount: Int = dispatcher.runningCallsCount()
    dispatcher.cancelAll()
  }

  @Test
  fun dispatcherFromMockWebServer() {
    val dispatcher =
      object : okhttp3.mockwebserver.Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse = TODO()