* [static certificates][static_certificates].
 *
 * ## Setting up Certificate Pinning
 *
 * The easiest way to pin a host is turn on pinning with a broken configuration and read the
 * expected configuration when the connection fails. Be sure to do this on a trusted network, and
 * without man-in-the-middle tools like [Charles][charles] or [Fiddler][fiddler].
 *

        if (isEmpty()) return ""
        deleteRange(length - 2, length)
      }
    headerValue = result
  }
  return result
}

internal fun Long.commonClampToInt(): Int {
  return when {
    this > Int.MAX_VALUE -> Int.MAX_VALUE
    else -> toInt()
  }
}

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl.Builder()
    .noCache()
    .build()

      if (eqCount == 0) break // We peeked a scheme name.
      if (eqCount > 1) return // Unexpected '=' characters.
      if (skipCommasAndWhitespace()) return // Unexpected ','.

      val parameterValue =
        when {
          startsWith('"'.code.toByte()) -> readQuotedString()
          else -> readToken()
        } ?: return // Expected a value.

      val replaced = parameters.put(peek, parameterValue)
      peek = null

   * multiple requests, each request is assigned its own sequence number.
   */
  val sequenceNumber: Int,
  socket: Socket,
  /**
   * The failure MockWebServer recorded when attempting to decode this request. If, for example,
   * the inbound request was truncated, this exception will be non-null.
   */
  val failure: IOException? = null,
) {
  val method: String?
  val path: String?

     * 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(
      notBefore: Long,
      notAfter: Long,
    ) = apply {
      require(notBefore <= notAfter && notBefore == -1L == (notAfter == -1L)) {

   * mutated by the call thread only. If is accessed by background connect threads.
   */
  private val tcpConnectsInFlight = CopyOnWriteArrayList<Plan>()

  /**
   * Results are posted here as they occur. The find job is done when either one plan completes
   * successfully or all plans fail.
   */
  private val connectResults = taskRunner.backend.decorate(LinkedBlockingDeque<ConnectResult>())

  override fun find(): RealConnection {

  internal class Failure(
    val t: Throwable,
    val response: Response?,
  ) {
    val responseBody: String? =
      when {
        response != null && response.code != 101 -> response.body.string()
        else -> null
      }

    override fun toString(): String {
      return when (response) {
        null -> "Failure[$t]"
        else -> "Failure[$response]"
      }
    }
  }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.testing

object PlatformVersion {
  val majorVersion: Int by lazy {
    when (val jvmSpecVersion = getJvmSpecVersion()) {
      "1.8" -> 8
      else -> jvmSpecVersion.toInt()
    }
  }

  fun getJvmSpecVersion(): String {
    return System.getProperty("java.specification.version", "unknown")

HttpLoggingInterceptor logging = new HttpLoggingInterceptor(new Logger() {
  @Override public void log(String message) {
    Timber.tag("OkHttp").d(message);
  }
});
```

**Warning**: The logs generated by this interceptor when using the `HEADERS` or `BODY` levels have
the potential to leak sensitive information such as "Authorization" or "Cookie" headers and the
contents of request and response bodies. This data should only be logged in a controlled way or in

      } catch (_: SSLException) {
        false
      }
    }
  }

  fun verify(
    host: String,
    certificate: X509Certificate,
  ): Boolean {
    return when {
      host.canParseAsIpAddress() -> verifyIpAddress(host, certificate)
      else -> verifyHostname(host, certificate)
    }
  }

  /** Returns true if [certificate] matches [ipAddress]. */