var first = true

        override fun createSocket(): Socket {
          if (first) {
            first = false
            firstConnectLatch.await()
          }
          return super.createSocket()
        }
      }

    client =
      client.newBuilder()
        .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE))
        .socketFactory(socketFactory)
        .addNetworkInterceptor(

    ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS, SynchronousQueue()) {
    private val exceptions: BlockingQueue<Exception> = LinkedBlockingQueue()

    override fun execute(runnable: Runnable) {
      super.execute {
        try {
          runnable.run()
        } catch (e: Exception) {
          exceptions.add(e)
        }
      }
    }

    fun takeException(): Exception {

      // Otherwise, there is no guarantee for the sequence. For example, the server may use the
      // first mocked response to respond to the second request.
      val response = super.dispatch(request)
      responseDequeuedLatches[responseIndex].countDown()
      requestCanceledLatches[responseIndex].await()
      responseIndex++
      return response
    }
  }

    log("appendingSink($file)")

    return super.appendingSink(file, mustExist)
  }

  override fun atomicMove(
    source: Path,
    target: Path,
  ) {
    log("atomicMove($source, $target)")

    super.atomicMove(source, target)
  }

  override fun createDirectory(
    dir: Path,
    mustCreate: Boolean,
  ) {
    log("createDirectory($dir)")

    super.createDirectory(dir, mustCreate)
  }

    } else {
      super.getStackTraceForCloseable(closer)
    }
  }

  override fun logCloseableLeak(
    message: String,
    stackTrace: Any?,
  ) {
    if (Build.VERSION.SDK_INT >= 30) {
      (stackTrace as CloseGuard).warnIfOpen()
    } else {
      // Unable to report via CloseGuard. As a last-ditch effort, send it to the logger.
      super.logCloseableLeak(message, stackTrace)
    }
  }

        val inetSocketAddress = hostMapping[requested.address] ?: defaultAddress ?: requested
        Platform.get().log("Socket connection to: $inetSocketAddress was: $requested")
        super.connect(inetSocketAddress, timeout)
      }
    }
  }

  val pushPromises: List<PushPromise>
    get() = promises

  init {
    setResponseCode(200)
    setHeader("Content-Length", 0L)
  }

  public override fun clone(): MockResponse {
    val result = super.clone() as MockResponse
    result.headersBuilder = headersBuilder.build().newBuilder()
    result.promises = promises.toMutableList()
    return result
  }

  @JvmName("-deprecated_getStatus")
  @Deprecated(

      Conscrypt.setApplicationProtocols(sslSocket, names.toTypedArray())
    } else {
      super.configureTlsExtensions(sslSocket, hostname, protocols)
    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    if (Conscrypt.isConscrypt(sslSocket)) {
      Conscrypt.getApplicationProtocol(sslSocket)
    } else {
      super.getSelectedProtocol(sslSocket)
    }

        }
        LogManager.getLogManager().reset()
        val handler =
          object : ConsoleHandler() {
            override fun publish(record: LogRecord) {
              super.publish(record)

              val parameters = record.parameters
              if (sslDebug && record.loggerName == "javax.net.ssl" && parameters != null) {
                System.err.println(parameters[0])
              }

        override fun contains(element: Protocol?): Boolean {
          if (element == null) throw NullPointerException()
          return super.contains(element)
        }

        override fun indexOf(element: Protocol?): Int {
          if (element == null) throw NullPointerException()
          return super.indexOf(element)
        }
      } as List<Protocol>
    val client =
      OkHttpClient.Builder()