connection.connectionListener.noNewExchanges(connection)
  }

  override fun doExtensiveHealthChecks(): Boolean {
    return chain.request.method != "GET"
  }

  override fun isCanceled(): Boolean {
    return call.isCanceled()
  }

  override fun candidateConnection(): RealConnection? {
    return call.connection
  }

  override fun proxySelectStart(url: HttpUrl) {

  override fun enqueue(responseCallback: Callback): Unit = error("unexpected")

  override fun cancel(): Unit = error("unexpected")

  override fun isExecuted(): Boolean = error("unexpected")

  override fun isCanceled(): Boolean = error("unexpected")

  override fun timeout(): Timeout = error("unexpected")

  override fun clone(): Call = error("unexpected")

            logger.warn("Failed to run python command.", e);
            resultBuf.append(e.getMessage()).append("\n");
        } finally {
            if (timeoutTask != null && !timeoutTask.isCanceled()) {
                timeoutTask.cancel();
            }
        }

        return resultBuf.toString();

    }

    protected void executePython() {

            }
            fail("No expected to get response")
          }
        }
      } catch (to: TimeoutCancellationException) {
        // expected
      }

      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun cancelledCall() {
    runTest {
      server.enqueue(
        MockResponse.Builder()
          .bodyDelay(5, TimeUnit.SECONDS)
          .body("abc")

     * @return 永続的かどうか
     */
    public boolean isPermanent() {
        return permanent;
    }

    /**
     * キャンセルされているかどうかを返します。
     *
     * @return キャンセルされているか
     */
    public boolean isCanceled() {
        return status == CANCELED;
    }

    /**
     * キャンセルします。
     */
    public void cancel() {
        status = CANCELED;
    }

    /**
     * 止まっているかどうか返します。
     *

            }
            fail("No expected to get response")
          }
        }
      } catch (to: TimeoutCancellationException) {
        // expected
      }

      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun cancelledCall() {
    runTest {
      server.enqueue(
        MockResponse.Builder()
          .bodyDelay(5, TimeUnit.SECONDS)
          .body("abc")

  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()
          val connectResult =

  override fun find(): RealConnection {
    var firstException: IOException? = null
    try {
      while (tcpConnectsInFlight.isNotEmpty() || routePlanner.hasNext()) {
        if (routePlanner.isCanceled()) throw IOException("Canceled")

        // Launch a new connection if we're ready to.
        val now = taskRunner.backend.nanoTime()
        var awaitTimeoutNanos = nextTcpConnectAtNanos - now

  }

  override fun noNewExchanges(connection: RealConnection) {
  }

  override fun doExtensiveHealthChecks(): Boolean = false

  override fun isCanceled(): Boolean = false

  override fun candidateConnection(): RealConnection? = null

  override fun proxySelectStart(url: HttpUrl) {
  }

  override fun proxySelectEnd(
    url: HttpUrl,

  fun connectionConnectionClosed(connection: RealConnection)

  fun noNewExchanges(connection: RealConnection)

  fun doExtensiveHealthChecks(): Boolean

  fun isCanceled(): Boolean

  fun candidateConnection(): RealConnection?

  fun proxySelectStart(url: HttpUrl)

  fun proxySelectEnd(
    url: HttpUrl,
    proxies: List<Proxy>,
  )