this.maxAgeSeconds = maxAgeSecondsLong.commonClampToInt()
    }

    /**
     * Accept cached responses that have exceeded their freshness lifetime by up to `maxStale`. If
     * unspecified, stale cache responses will not be used.
     *
     * @param maxStale a non-negative integer. This is stored and transmitted with
     *     [TimeUnit.SECONDS] precision; finer precision will be lost.
     */

been, leading to rare cases of infinite retries. Please upgrade to this release!

 *  Fix: don't return stale DNS entries in `DnsOverHttps`. We were caching DNS results indefinitely
    rather than the duration specified in the response's cache-control header.
 *  Fix: Verify certificate IP addresses in canonical form. When a server presents a TLS certificate

  internal val namesAndValues: Array<String>,
) : Iterable<Pair<String, String>> {
  /** Returns the last value corresponding to the specified field, or null. */
  operator fun get(name: String): String? = commonHeadersGet(namesAndValues, name)

  /**
   * Returns the last value corresponding to the specified field parsed as an HTTP date, or null if
   * either the field is absent or cannot be parsed as a date.
   */

    private var keySize: Int = 0

    init {
      ecdsa256()
    }

    /**
     * Sets the certificate to be valid in ```[notBefore..notAfter]```. Both endpoints are specified
     * in the format of [System.currentTimeMillis]. Specify -1L for both values to use the default
     * interval, 24 hours starting when the certificate is created.
     */
    fun validityInterval(

      if (state != STATE_READING_RESPONSE_BODY) throw IllegalStateException("state: $state")

      detachTimeout(timeout)

      state = STATE_CLOSED
    }
  }

  /** An HTTP body with a fixed length specified in advance. */
  private inner class FixedLengthSource(private var bytesRemaining: Long) :
    AbstractSource() {
    init {
      if (bytesRemaining == 0L) {
        responseBodyComplete()
      }
    }

      }

    return dateFormat.format(date)
  }

  /**
   * Returns a composite adapter for a struct or data class. This may be used for both SEQUENCE and
   * SET types.
   *
   * The fields are specified as a list of member adapters. When decoding, a value for each
   * non-optional member but be included in sequence.
   *
   * TODO: for sets, sort by tag when encoding.

     *
     * @param streamId when a client-initiated stream ID (odd number), the origin of this alternate
     *     service is the origin of the stream. When zero, the origin is specified in the `origin`
     *     parameter.
     * @param origin when present, the [origin](http://tools.ietf.org/html/rfc6454) is typically

      }

      /** Add a part to the body. */
      fun addPart(part: Part) =
        apply {
          parts += part
        }

      /** Assemble the specified parts into a request body. */
      fun build(): MultipartBody {
        check(parts.isNotEmpty()) { "Multipart body must have at least one part." }
        return MultipartBody(boundary, type, parts.toImmutableList())

      }

      return Cookie(
        cookieName, cookieValue, expiresAt, domain, path, secureOnly, httpOnly,
        persistent, hostOnly, sameSite,
      )
    }

    /** Parse a date as specified in RFC 6265, section 5.1.1. */
    private fun parseExpires(
      s: String,
      pos: Int,
      limit: Int,
    ): Long {
      var pos = pos
      pos = dateCharacterOffset(s, pos, limit, false)

    the cache, network, or both. OkHttp 2 offers more detail with raw access to
    the cache and network responses in the new `Response` class.

 *  **TunnelRequest is gone.** It specified how to connect to an HTTP proxy.
    OkHttp 2 uses the new `Request` class for this.

 *  **Dispatcher** is a new class that manages the queue of asynchronous calls. It