* change slightly between releases. If you need a stable logging format, use your own interceptor.
 */
class HttpLoggingInterceptor
  @JvmOverloads
  constructor(
    private val logger: Logger = Logger.DEFAULT,
  ) : Interceptor {
    @Volatile private var headersToRedact = emptySet<String>()

    @Volatile private var queryParamsNameToRedact = emptySet<String>()

    @set:JvmName("level")
    @Volatile

The [spec][rfc_7692] includes a sophisticated mechanism for client and server to negotiate
compression features. We strive to offer great performance in our default configuration and so we're
making compression the default for everyone starting with this release candidate.

Please be considerate of your servers and their operators as you roll out this release. Compression

      )
    factory.init(null as KeyStore?)
    val trustManagers = factory.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {
      "Unexpected default trust managers: ${trustManagers.contentToString()}"
    }
    return trustManagers[0] as X509TrustManager
  }

  open fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? {
    return try {

        .pingIntervalMillis(pingIntervalMillis)
        .flowControlListener(flowControlListener)
        .build()
    this.http2Connection = http2Connection
    this.allocationLimit = Http2Connection.DEFAULT_SETTINGS.getMaxConcurrentStreams()
    http2Connection.start()
  }

  /**
   * Returns true if this connection can carry a stream allocation to `address`. If non-null

     * security. ECDSA keys are noticeably faster than RSA keys.
     *
     * This is the default configuration and has been since this API was introduced in OkHttp
     * 3.11.0. Note that the default may change in future releases.
     */
    fun ecdsa256() =
      apply {
        keyAlgorithm = "EC"
        keySize = 256
      }

    /**

      "sent ping but didn't receive pong within 500ms (after 1 successful ping/pongs)",
    )
  }

  @Test
  fun messagesNotCompressedWhenNotConfigured() {
    val message = repeat('a', RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE.toInt())
    server.webSocket!!.send(message)
    taskFaker.runTasks()
    assertThat(client.clientSourceBufferSize())
      .isGreaterThan(message.length.toLong()) // Not compressed.

          algorithm = it[0] as String,
          parameters = it[1],
        )
      },
    )

  /**
   * ```
   * BasicConstraints ::= SEQUENCE {
   *   cA                      BOOLEAN DEFAULT FALSE,
   *   pathLenConstraint       INTEGER (0..MAX) OPTIONAL
   * }
   * ```
   */
  private val basicConstraints: BasicDerAdapter<BasicConstraints> =
    Adapters.sequence(
      "BasicConstraints",

  return String.format(Locale.US, format, *args)
}

@Throws(IOException::class)
internal fun BufferedSource.readBomAsCharset(default: Charset): Charset {
  return when (select(UNICODE_BOMS)) {
    0 -> UTF_8
    1 -> UTF_16BE
    2 -> UTF_16LE
    3 -> UTF_32BE
    4 -> UTF_32LE
    -1 -> default
    else -> throw AssertionError()
  }
}

internal fun checkDuration(
  name: String,
  duration: Long,

        handshakeCertificates.sslSocketFactory(),
        handshakeCertificates.trustManager,
      )
      .build()
  }

  private fun buildServerSslSocketFactory(): SSLSocketFactory {
    // The test uses JDK default SSL Context instead of the Platform provided one
    // as Conscrypt seems to have some differences, we only want to test client side here.
    return try {
      val keyManager =
        newKeyManager(
          null,

      apply {
        this.status = status
      }

    /**
     * Removes all HTTP headers including any "Content-Length" and "Transfer-encoding" headers that
     * were added by default.
     */
    fun clearHeaders() =
      apply {
        headers = Headers.Builder()
      }

    /**
     * Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a name followed