* response will be returned to the caller that triggered it.
 *
 * Implementations should check if the initial request already included an attempt to
 * authenticate. If so it is likely that further attempts will not be useful and the authenticator
 * should give up.
 *
 * When reactive authentication is requested by an origin web server, the response code is 401

    }
    return trustManagers[0] as X509TrustManager
  }

  open fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? {
    return try {
      // Attempt to get the trust manager from an OpenJDK socket factory. We attempt this on all
      // platforms in order to support Robolectric, which mixes classes from both Android and the
      // Oracle JDK. Note that we don't support HTTP/2 or other nice features on Robolectric.

 * limitations under the License.
 */
package okhttp3.tls.internal.der

import okio.ByteString

/**
 * A value whose type is not specified statically. Use this with [Adapters.any] which will attempt
 * to resolve a concrete type.
 */
internal data class AnyValue(
  var tagClass: Int,
  var tag: Long,
  var constructed: Boolean = false,
  var length: Long = -1L,
  val bytes: ByteString,
) {

    // auth credentials.
    rawSocket?.closeQuietly()

    val nextAttempt = attempt + 1
    return when {
      nextAttempt < MAX_TUNNEL_ATTEMPTS -> {
        user.callConnectEnd(route, null)
        ConnectResult(
          plan = this,
          nextPlan =
            copy(
              attempt = nextAttempt,
              tunnelRequest = nextTunnelRequest,
            ),
        )
      }

      get() = originalRequest.url.host

    val request: Request
      get() = originalRequest

    val call: RealCall
      get() = this@RealCall

    /**
     * Attempt to enqueue this async call on [executorService]. This will attempt to clean up
     * if the executor has been shut down by reporting the call as failed.
     */
    fun executeOn(executorService: ExecutorService) {

    ): Relay {
      val randomAccessFile = RandomAccessFile(file, "rw")
      val result = Relay(randomAccessFile, upstream, 0L, metadata, bufferMaxSize)

      // Write a dirty header. That way if we crash we won't attempt to recover this.
      randomAccessFile.setLength(0L)
      result.writeHeader(PREFIX_DIRTY, -1L, -1L)

      return result
    }

    /**
     * Creates a relay that reads a recorded stream from [file].

 *
 *  3. Attempt plans from prior connect attempts for this call. These occur as either follow-ups to
 *     failed connect attempts (such as trying the next [ConnectionSpec]), or as attempts that lost
 *     a race in fast follow-up.
 *
 *  4. If there's no existing connection, make a list of routes (which may require blocking DNS

    )

    val call = client.newCall(Request(url))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("hello from IPv6")

    // In the process we made one successful connection attempt.
    assertThat(listener.recordedEventTypes().filter { it == "ConnectStart" }).hasSize(1)
    assertThat(listener.recordedEventTypes().filter { it == "ConnectFailed" }).hasSize(0)
  }

  @Test

  }

  /**
   * Returns true if there's another set of routes to attempt. Every address has at least one route.
   */
  operator fun hasNext(): Boolean = hasNextProxy() || postponedRoutes.isNotEmpty()

  @Throws(IOException::class)
  operator fun next(): Selection {
    if (!hasNext()) throw NoSuchElementException()

    // Compute the next set of routes to attempt.
    val routes = mutableListOf<Route>()
    while (hasNextProxy()) {

    detecting the TLS capabilities of the host platform.

 *  Fix: Don't crash in `HttpUrl.topPrivateDomain()` when the hostname is malformed.

 *  Fix: Don't attempt Brotli decompression if the response body is empty.


## Version 4.7.2

_2020-05-20_

 *  Fix: Don't crash inspecting whether the host platform is JVM or Android. With 4.7.0 and 4.7.1 we