* response body is [closed][ResponseBody]. The recipient of the callback may consume the response
   * body on another thread.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not
   * necessarily indicate application-layer success: `response` may still indicate an unhappy HTTP
   * response code like 404 or 500.
   */

   * custom builds of OkHttp please include a qualifier your version name, like "4.7.0-mycompany.3".
   * The version string is configured in the root project's `build.gradle`.
   *
   * Note that OkHttp's runtime version may be different from the version specified in your
   * project's build file due to the dependency resolution features of your build tool.
   *
   * [semver]: https://semver.org
   */

  val ca: Boolean,
  /** The maximum number of intermediate CAs between this and leaf certificates. */
  val maxIntermediateCas: Long?,
)

/** A private key. Note that this class doesn't support attributes or an embedded public key. */
internal data class PrivateKeyInfo(
  // v1(0), v2(1).
  val version: Long,
  val algorithmIdentifier: AlgorithmIdentifier,

    containing an IP address we must match that address against the URL's IP address, even when the
    two addresses are encoded differently, such as `192.168.1.1` and `0::0:0:FFFF:C0A8:101`. Note
    that OkHttp incorrectly rejected valid certificates resulting in a failure to connect; at no
    point were invalid certificates accepted.

    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.
      val sslContextClass = Class.forName("sun.security.ssl.SSLContextImpl")

      }
    }
  }

  /**
   * Prepare for a potential trip through all of this call's network interceptors. This prepares to
   * find an exchange to carry the request.
   *
   * Note that an exchange will not be needed if the request is satisfied by the cache.
   *
   * @param newRoutePlanner true if this is not a retry and new routing can be performed.
   */
  fun enterNetworkInterceptorExchange(

    testServerClosesOutput(ShutdownInputAtEnd)
  }

  @Test
  fun serverShutdownOutput() {
    testServerClosesOutput(ShutdownOutputAtEnd)
  }

  @Test
  fun invalidHost() {
    // Note that 1234.1.1.1 is an invalid host in a URI, but URL isn't as strict.
    client =
      client.newBuilder()
        .dns(FakeDns())
        .build()
    assertFailsWith<UnknownHostException> {
      getResponse(

    assertThat(stringPrep("\u2029")).isNull()
    assertThat(stringPrep("\ud834\udd7a")).isNull() // Note that this is one code point.
  }

  @Test fun prohibitionPrivateUse() {
    assertThat(stringPrep("\uf8ff")).isNull()
    assertThat(stringPrep("\udbff\udffd")).isNull() // Note that this is one code point.
  }

  @Test fun prohibitionNonCharacter() {
    assertThat(stringPrep("\ufdd0")).isNull()

   */
  open fun proxySelectStart(
    call: Call,
    url: HttpUrl,
  ) {
  }

  /**
   * Invoked after proxy selection.
   *
   * Note that the list of proxies is never null, but it may be a list containing
   * only [Proxy.NO_PROXY]. This comes up in several situations:
   *
   * * If neither a proxy nor proxy selector is configured.

) {
  @Test
  fun test() {
    ...
  }
}
```

Requirements
------------

MockWebServer's JUnit 5 integration works on Android 7.0+ (API level 24+) and Java 8+. Note that