*  Fix: Don't crash with a `NullPointerException` if a server sends a close while we're sending a
    ping. OkHttp had a race condition bug.


## Version 4.6.0

_2020-04-28_

 *  Fix: Follow HTTP 307 and 308 redirects on methods other than GET and POST. We're reluctant to
    change OkHttp's behavior in handling common HTTP status codes, but this fix is overdue! The new

       * Content-Length: 3
       *
       * Hi?
       * --> END POST
       *
       * <-- 200 OK (22ms)
       * Content-Type: plain/text
       * Content-Length: 6
       *
       * Hello!
       * <-- END HTTP
       * ```
       */
      BODY,
    }

    fun interface Logger {
      fun log(message: String)

      companion object {

    val request =
      Request(
        server.url("/"),
        body = "Hello".toRequestBody("text/plain".toMediaType()),
      )
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("Body")
    val request1 = server.takeRequest()
    assertThat(request1.body.readUtf8()).isEqualTo("Hello")
    val request2 = server.takeRequest()

  /** Prepares the socket addresses to attempt for the current proxy or host. */
  @Throws(IOException::class)
  private fun resetNextInetSocketAddress(proxy: Proxy) {
    // Clear the addresses. Necessary if getAllByName() below throws!
    val mutableInetSocketAddresses = mutableListOf<InetSocketAddress>()
    inetSocketAddresses = mutableInetSocketAddresses

    val socketHost: String
    val socketPort: Int

    method: String,
  ): Request? {
    // Does the client allow redirects?
    if (!client.followRedirects) return null

    val location = userResponse.header("Location") ?: return null
    // Don't follow redirects to unsupported protocols.
    val url = userResponse.request.url.resolve(location) ?: return null

    // If configured, don't follow redirects between SSL and non-SSL.

          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = IOException("canceled"))
        }
        connectTcpNextPlan != null -> {
          events += "plan $id needs follow-up"
          ConnectResult(this, nextPlan = connectTcpNextPlan)
        }
        else -> {
          events += "plan $id TCP connected"
          connectState = ConnectState.TCP_CONNECTED

      apply {
        this.authenticator = authenticator
      }

    /** Configure this client to follow redirects. If unset, redirects will be followed. */
    fun followRedirects(followRedirects: Boolean) =
      apply {
        this.followRedirects = followRedirects
      }

    /**
     * Configure this client to allow protocol redirects from HTTPS to HTTP and from HTTP to HTTPS.

    server.enqueue(
      MockResponse.Builder()
        .addHeader("Allow: GET, HEAD")
        .addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
        .addHeader("Cache-Control: max-age=0")
        .body("A")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .addHeader("Allow: GET, HEAD, PUT")
        .code(HttpURLConnection.HTTP_NOT_MODIFIED)

   *
   * We get plan0 and plan1 from the route planner.
   * We get plan2 as a follow-up to plan1, typically retry the same IP but different TLS.
   * We get plan3 as a retry of plan0, which was canceled when it lost the race.
   *
   * This test confirms that we prefer to do the TLS follow-up (plan2) before the TCP retry (plan3).
   * It also confirms we enforce the 250 ms delay in each race.
   */
  @Test

   * provides support.
   */
  QUIC("quic"),

  /**
   * HTTP/3 is the third and upcoming major version of the Hypertext Transfer Protocol used to
   * exchange information. HTTP/3 runs over QUIC, which is published as RFC 9000.
   *
   * HTTP/3 is not natively supported by OkHttp, but provided to allow a theoretical interceptor
   * that provides support.