inFrames.add(inFrame)
      }
    }
  }

  fun openSocket(): Socket = Socket("localhost", port)

  @Synchronized override fun close() {
    executor.shutdown()
    socket?.closeQuietly()
    serverSocket?.closeQuietly()
  }

  override fun toString(): String = "MockHttp2Peer[$port]"

  private class OutFrame(
    val sequence: Int,
    val start: Long,
    val truncated: Boolean,

    }
  }

  private fun supportsUrl(url: HttpUrl): Boolean {
    lock.assertHeld()

    val routeUrl = route.address.url

    if (url.port != routeUrl.port) {
      return false // Port mismatch.
    }

    if (url.host == routeUrl.host) {
      return true // Host match. The URL is supported.
    }

    )
  }

  companion object {
    private const val PROXY_A_PORT = 1001
    private const val PROXY_A_HOST = "proxya"
    private val proxyA =
      Proxy(
        Proxy.Type.HTTP,
        InetSocketAddress.createUnresolved(PROXY_A_HOST, PROXY_A_PORT),
      )

    private const val PROXY_B_PORT = 1002
    private const val PROXY_B_HOST = "proxyb"
    private val proxyB =
      Proxy(

    configureClientAndServerProxies(http2 = false)
    server.enqueue(
      MockResponse(body = "response body"),
    )
    val port = server.port
    val url =
      server.url("/").newBuilder()
        .host("::1")
        .port(port)
        .build()
    val request = Request(url)
    val response = client.newCall(request).execute()

      serverSocket!!.accept().use { rawSocket ->
        val sslSocket =
          server.sslSocketFactory().createSocket(
            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,
          ) as SSLSocket
        sslSocket.use {
          sslSocket.useClientMode = false
          sslSocket.wantClientAuth = true
          sslSocket.startHandshake()

        val sslSocket =
          route.address.sslSocketFactory.createSocket(
            rawSocket,
            route.address.url.host,
            route.address.url.port,
            // autoClose:
            true,
          ) as SSLSocket

        val tlsEquipPlan = planWithCurrentOrInitialConnectionSpec(connectionSpecs, sslSocket)

          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(hostnameVerifier)
        .build()
    host = "${server.hostName}:${server.port}"
    url = server.url("/")
  }

  @Test
  fun levelGetter() {
    // The default is NONE.
    assertThat(applicationInterceptor.level).isEqualTo(Level.NONE)
    for (level in Level.entries) {

name: docs

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

permissions:
  contents: read

env:
  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false"

jobs:
  test_docs:
    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest

      socketHost = address.url.host
      socketPort = address.url.port
    } else {
      val proxyAddress = proxy.address()
      require(proxyAddress is InetSocketAddress) {
        "Proxy.address() is not an InetSocketAddress: ${proxyAddress.javaClass}"
      }
      socketHost = proxyAddress.socketHost
      socketPort = proxyAddress.port
    }

    if (socketPort !in 1..65535) {

    val connect1 = server.takeRequest()
    assertThat(connect1.requestLine).isEqualTo("CONNECT android.com:$port HTTP/1.1")
    assertThat(connect1.headers["Proxy-Authorization"]).isNull()

    val connect2 = server.takeRequest()
    assertThat(connect2.requestLine).isEqualTo("CONNECT android.com:$port HTTP/1.1")
    assertThat(connect2.headers["Proxy-Authorization"]).isEqualTo("password")