}

    override fun pushPromise(
      streamId: Int,
      associatedStreamId: Int,
      headerBlock: List<Header>,
    ) {
      this.type = Http2.TYPE_PUSH_PROMISE
      this.streamId = streamId
      this.associatedStreamId = associatedStreamId
      this.headerBlock = headerBlock
    }

    override fun alternateService(
      streamId: Int,
      origin: String,

    val result = if (flags < FLAGS.size) FLAGS[flags]!! else BINARY[flags]
    // Special case types that have overlap flag values.
    return when {
      type == TYPE_PUSH_PROMISE && flags and FLAG_END_PUSH_PROMISE != 0 -> {
        result.replace("HEADERS", "PUSH_PROMISE") // TODO: Avoid allocation.
      }
      type == TYPE_DATA && flags and FLAG_COMPRESSED != 0 -> {
        result.replace("PRIORITY", "COMPRESSED") // TODO: Avoid allocation.

    headersDelayAmount = delay
    headersDelayUnit = unit
  }

  fun getHeadersDelay(unit: TimeUnit): Long = unit.convert(headersDelayAmount, headersDelayUnit)

  fun withPush(promise: PushPromise) =
    apply {
      promises.add(promise)
    }

  fun withSettings(settings: Settings) =
    apply {
      this.settings = settings
    }

  fun withWebSocketUpgrade(listener: WebSocketListener) =

    /** HTTP/2: Size in bytes of the table used to decode the sender's header blocks. */
    const val HEADER_TABLE_SIZE = 1

    /** HTTP/2: The peer must not send a PUSH_PROMISE frame when this is 0. */
    const val ENABLE_PUSH = 2

    /** Sender's maximum number of concurrent streams. */
    const val MAX_CONCURRENT_STREAMS = 4

    assertThat(frameLog(true, 3, 10000, TYPE_CONTINUATION, 0x4))
      .isEqualTo("<< 0x00000003 10000 CONTINUATION  END_HEADERS")
    assertThat(frameLog(true, 4, 10000, TYPE_PUSH_PROMISE, 0x4))
      .isEqualTo("<< 0x00000004 10000 PUSH_PROMISE  END_PUSH_PROMISE")
  }

  @Test
  fun flagOverlapOn0x20() {
    assertThat(frameLog(true, 3, 10000, TYPE_HEADERS, 0x20))
      .isEqualTo("<< 0x00000003 10000 HEADERS       PRIORITY")

    val request =
      Request.Builder()
        .url(url)
        .build()

    val promise = CompletableFuture<Response>()

    val call = client.newCall(request)
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          promise.completeExceptionally(e)
        }

        override fun onResponse(

class FakeProxySelector : ProxySelector() {
  val proxies: MutableList<Proxy> = mutableListOf()

  fun addProxy(proxy: Proxy): FakeProxySelector {
    proxies.add(proxy)
    return this
  }

  override fun select(uri: URI): List<Proxy> {
    // Don't handle 'socket' schemes, which the RI's Socket class may request (for SOCKS).
    return if (uri.scheme == "http" || uri.scheme == "https") proxies else listOf(Proxy.NO_PROXY)
  }

import okhttp3.Dns.Companion.SYSTEM

/**
 * A domain name service that resolves IP addresses for host names. Most applications will use the
 * [system DNS service][SYSTEM], which is the default. Some applications may provide their own
 * implementation to use a different DNS server, to prefer IPv6 addresses, to prefer IPv4 addresses,
 * or to force a specific known IP address.
 *
 * Implementations of this interface must be safe for concurrent use.

                return new MockResponse().setResponseCode(200);
            case "/v1/check/version/":
                return new MockResponse().setResponseCode(200).setBody("version=9");
            case "/v1/profile/info":
                return new MockResponse().setResponseCode(200).setBody("{\\\"info\\\":{\\\"name\":\"Lucas Albuquerque\",\"age\":\"21\",\"gender\":\"male\"}}");
        }

    delegate.proxySelectStart(call, url)
  }

  override fun proxySelectEnd(
    call: Call,
    url: HttpUrl,
    proxies: List<Proxy>,
  ) {
    logWithTime("proxySelectEnd: $proxies")

    delegate.proxySelectEnd(call, url, proxies)
  }

  override fun dnsStart(
    call: Call,
    domainName: String,
  ) {
    logWithTime("dnsStart: $domainName")