"java.util.ListIterator" to "kotlin.collections.ListIterator",
        "java.util.Collection" to "kotlin.collections.Collection",
        "java.util.List" to "kotlin.collections.List",
        "java.util.ArrayList" to "kotlin.collections.ArrayList",
        "java.util.Set" to "kotlin.collections.Set",
        "java.util.HashSet" to "kotlin.collections.HashSet",
        "java.util.LinkedHashSet" to "kotlin.collections.LinkedHashSet",

    override fun asStringForDebugging(): String = withValidityAssertion { fe10Type.asStringForDebugging(analysisContext) }

    override val conjuncts: List<KtType> by cached {
        val result = ArrayList<KtType>(supertypes.size)
        val isNullable = fe10Type.isMarkedNullable
        for (supertype in supertypes) {
            val mappedSupertype = if (isNullable) supertype.makeNullable() else supertype

    return lookupHttps(hostname)
  }

  @Throws(UnknownHostException::class)
  private fun lookupHttps(hostname: String): List<InetAddress> {
    val networkRequests = ArrayList<Call>(2)
    val failures = ArrayList<Exception>(2)
    val results = ArrayList<InetAddress>(5)

    buildRequest(hostname, networkRequests, results, failures, DnsRecordCodec.TYPE_A)

    if (includeIPv6) {

class MockHttp2Peer : Closeable {
  private var frameCount = 0
  private var client = false
  private val bytesOut = Buffer()
  private var writer = Http2Writer(bytesOut, client)
  private val outFrames: MutableList<OutFrame> = ArrayList()
  private val inFrames: BlockingQueue<InFrame> = LinkedBlockingQueue()
  private var port = 0
  private val executor = Executors.newSingleThreadExecutor(threadFactory("MockHttp2Peer"))

        list(certificate, intermediateCa, trusted),
      )
  }

  @Test
  fun chainMaxLength() {
    val heldCertificates = chainOfLength(10)
    val certificates: MutableList<Certificate> = ArrayList()
    for (heldCertificate in heldCertificates) {
      certificates.add(heldCertificate.certificate)
    }
    val root = heldCertificates[heldCertificates.size - 1].certificate
    val cleaner = get(root)

        TE,
        TRANSFER_ENCODING,
        ENCODING,
        UPGRADE,
      )

    fun http2HeadersList(request: Request): List<Header> {
      val headers = request.headers
      val result = ArrayList<Header>(headers.size + 4)
      result.add(Header(TARGET_METHOD, request.method))
      result.add(Header(TARGET_PATH, RequestLine.requestPath(request.url)))
      val host = request.header("Host")
      if (host != null) {

   *
   * https://github.com/square/okhttp/issues/2409
   */
  @Test
  fun connectionsAreNotReusedIfNetworkInterceptorInterferes() {
    val responsesNotClosed: MutableList<Response?> = ArrayList()
    client =
      client.newBuilder()
        // Since this test knowingly leaks a connection, avoid using the default shared connection
        // pool, which should remain clean for subsequent tests.

    assertThat(server2.takeRequest().sequenceNumber, "Expected connection reuse")
      .isEqualTo(1)
  }

  @Test
  fun redirectWithProxySelector() {
    val proxySelectionRequests: MutableList<URI> = ArrayList()
    client =
      client.newBuilder()
        .proxySelector(
          object : ProxySelector() {
            override fun select(uri: URI): List<Proxy> {
              proxySelectionRequests.add(uri)

    applyConnectionSpec(tlsSpec, socket, isFallback = true)
    assertThat(socket.enabledProtocols).containsExactly(
      TlsVersion.TLS_1_2.javaName,
    )
    val expectedCipherSuites: MutableList<String> = ArrayList()
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName)
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName)

    initialize()
    return object : MutableIterator<Snapshot> {
      /** Iterate a copy of the entries to defend against concurrent modification errors. */
      private val delegate = ArrayList(lruEntries.values).iterator()

      /** The snapshot to return from [next]. Null if we haven't computed that yet. */
      private var nextSnapshot: Snapshot? = null