@Tag("Slow")
class URLConnectionTest {
  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @TempDir
  lateinit var tempDir: File

  @StartStop
  val server = MockWebServer()

  @StartStop
  val server2 = MockWebServer()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

    // StreamReset stream was reset: PROT...
    val clientCert2 =
      HeldCertificate
        .Builder()
        .serialNumber(4L)
        .commonName("Jethro Willis")
        .build()
    val client = buildClient(clientCert2)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)
    server.requireClientAuth()
    val call = client.newCall(Request.Builder().url(server.url("/")).build())

    mockWebServer.dispatcher = dispatcher
    val url = mockWebServer.url("/").toUrl()
    val conn = url.openConnection() as HttpURLConnection
    conn.responseCode // Force the connection to hit the "server".
    // Make sure our dispatcher got the request.
    assertThat(requestsMade.size).isEqualTo(1)
  }

  @Test
  fun outOfOrderResponses() {
    val firstResponseCode = AtomicInteger()
    val secondResponseCode = AtomicInteger()

        ),
      )
    val request = RecordedRequest(DEFAULT_REQUEST_LINE_HTTP_1, headers, emptyList(), 0, ByteString.EMPTY, 0, 0, socket)
    assertThat(request.url.toString()).isEqualTo("http://host-from-header.com/")
  }

  private class FakeSocket(
    private val localAddress: InetAddress,
    private val localPort: Int,
    private val remoteAddress: InetAddress = localAddress,
    private val remotePort: Int = 1234,

  }

  companion object {
    val certA1 =
      HeldCertificate
        .Builder()
        .serialNumber(100L)
        .build()
    val certA1Sha256Pin = pin(certA1.certificate)
    val certB1 =
      HeldCertificate
        .Builder()
        .serialNumber(200L)
        .build()
    val certB1Sha256Pin = pin(certB1.certificate)
    val certC1 =
      HeldCertificate
        .Builder()

class Http2Server(
  private val baseDirectory: File,
  private val sslSocketFactory: SSLSocketFactory,
) : Http2Connection.Listener() {
  private fun run() {
    val serverSocket = ServerSocket(8888)
    serverSocket.reuseAddress = true
    while (true) {
      var socket: Socket? = null
      try {
        socket = serverSocket.accept()
        val sslSocket = doSsl(socket)

    ```kotlin
      private val executor = Executors.newScheduledThreadPool(1)
      private val client = OkHttpClient()

      fun run() {
        val request = Request.Builder()
            .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
            .build()

        val startNanos = System.nanoTime()
        val call = client.newCall(request)

  }

  private companion object {
    val testInstances = CopyOnWriteArrayList<StartStopTest>()

    private val dispatcherD = ClosableDispatcher()

    @StartStop @JvmStatic
    val serverD =
      MockWebServer().apply {
        dispatcher = dispatcherD
      }

    private val dispatcherE = ClosableDispatcher()

    @StartStop @JvmStatic
    val serverE =
      MockWebServer().apply {

class Jdk8WithJettyBootPlatform(
  private val putMethod: Method,
  private val getMethod: Method,
  private val removeMethod: Method,
  private val clientProviderClass: Class<*>,
  private val serverProviderClass: Class<*>,
) : Platform() {
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    val names = alpnProtocolNames(protocols)

    try {

    val serverRoot =
      HeldCertificate
        .Builder()
        .certificateAuthority(1)
        .build()
    val serverIntermediate =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .signedBy(serverRoot)
        .build()
    val serverCertificate =
      HeldCertificate
        .Builder()
        .signedBy(serverIntermediate)
        .build()
    val server =