[]string{"api"},
	)
	observations := []struct {
		val   float64
		label string
	}{
		{
			val:   0.02,
			label: labels[0],
		},
		{
			val:   0.07,
			label: labels[1],
		},
		{
			val:   0.11,
			label: labels[1],
		},
		{
			val:   0.19,
			label: labels[1],
		},
		{
			val:   0.31,
			label: labels[1],
		},
		{
			val:   0.61,
			label: labels[3],
		},
		{

   */
  @get:JvmName("encodedPathSegments")
  val encodedPathSegments: List<String>
    get() {
      val pathStart = url.indexOf('/', scheme.length + 3)
      val pathEnd = url.delimiterOffset("?#", pathStart, url.length)
      val result = mutableListOf<String>()
      var i = pathStart
      while (i < pathEnd) {
        i++ // Skip the '/'.
        val segmentEnd = url.delimiterOffset('/', i, pathEnd)

internal class SequentialExchangeFinder(
  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()

  @Test fun comparePlainAndCompactTables() {
    val buffer = Buffer()
    for (codePoint in 0..0x10ffff) {
      val allowedByTable = table.map(codePoint, buffer)
      val tableMappedTo = buffer.readUtf8()

      val allowedByCompactTable = compactTable.map(codePoint, buffer)
      val compactTableMappedTo = buffer.readUtf8()

 * [tls_history]: https://square.github.io/okhttp/tls_configuration_history/
 */
class ConnectionSpec internal constructor(
  @get:JvmName("isTls") val isTls: Boolean,
  @get:JvmName("supportsTlsExtensions") val supportsTlsExtensions: Boolean,
  internal val cipherSuitesAsString: Array<String>?,
  private val tlsVersionsAsString: Array<String>?,
) {
  /**
   * Returns the cipher suites to use for a connection. Returns null if all of the SSL socket's

import java.util.logging.Handler
import java.util.logging.LogRecord

object JsseDebugLogging {
  data class JsseDebugMessage(val message: String, val param: String?) {
    enum class Type {
      Handshake,
      Plaintext,
      Encrypted,
      Setup,
      Unknown,
    }

    val type: Type
      get() =
        when {
          message == "adding as trusted certificates" -> Type.Setup

 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule, BeforeEachCallback, AfterEachCallback {
  constructor(loggerName: Class<*>) : this(Logger.getLogger(loggerName.getName()))

  private val logs = LinkedBlockingQueue<String>()

  private val handler =
    object : Handler() {
      override fun publish(logRecord: LogRecord) {

 * as part of MODERN_TLS or folded into the default OkHttp client once published and
 * available in JDK11 or Conscrypt.
 */
private val TLS_13 =
  ConnectionSpec.Builder(true)
    .cipherSuites(*TLS13_CIPHER_SUITES.toTypedArray())
    .tlsVersions(TlsVersion.TLS_1_3)
    .build()

private val TLS_12 =
  ConnectionSpec.Builder(ConnectionSpec.RESTRICTED_TLS)
    .tlsVersions(TlsVersion.TLS_1_2)
    .build()

            }
        }

    private
    val JApiClass.sourceFilePath: String
        get() = if (isKotlin) kotlinSourceFilePath else javaSourceFilePath

    private
    val JApiClass.javaSourceFilePath: String
        get() = fullyQualifiedName
            .replace(".", "/")
            .replace(innerClassesPartRegex, "") + ".java"

    private
    val innerClassesPartRegex =
        "\\$.*".toRegex()

      }
    }

    val isAndroid: Boolean
      get() = Platform.Companion.isAndroid

    companion object {
      const val PROPERTY_NAME = "okhttp.platform"
      const val CONSCRYPT_PROPERTY = "conscrypt"
      const val CORRETTO_PROPERTY = "corretto"
      const val JDK9_PROPERTY = "jdk9"
      const val JDK8_ALPN_PROPERTY = "jdk8alpn"
      const val JDK8_PROPERTY = "jdk8"