Gary Hale <******@****.***> <******@****.***>
Hans Dockter <hans@gradle.com>
Hans Dockter <hans@gradle.com> <hans******@****.***>
Hans Dockter <hans@gradle.com> <hans@Hans-Dockters-MacBook-Pro.local>
Hans Dockter <hans@gradle.com> <hans@gradle.biz>
Hans Dockter <hans@gradle.com> <hd@hd-desktop.(none)>
Hans Dockter <hans@gradle.com> <******@****.***>
Hans Dockter <hans@gradle.com> U-WIN-T79U3J3QLBC\Hans Dockter <Hans Dockter@WIN-T79U3J3QLBC.(none)>

OdHOim9+
-----END PRIVATE KEY-----
```

Recommendations
---------------

Typically servers need a held certificate plus a chain of intermediates. Servers only need the
private key for their own certificate. The chain served by a server doesn't need the root
certificate.

The trusted roots don't need to be the same for client and server when using client authentication.

import okhttp3.internal.skipAll
import okio.buffer

/** This is the last interceptor in the chain. It makes a network call to the server. */
object CallServerInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.exchange!!
    val request = realChain.request

    )
    fun getLevel(): Level = level

    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
      val level = this.level

      val request = chain.request()
      if (level == Level.NONE) {
        return chain.proceed(request)
      }

      val logBody = level == Level.BODY
      val logHeaders = logBody || level == Level.HEADERS

    val interceptedCount = AtomicInteger()
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            assertThat(chain.request().body).isNull()
            val response = chain.proceed(chain.request())
            assertThat(response.header("Connection")).isEqualTo("Upgrade")
            assertThat(response.body).isInstanceOf<UnreadableResponseBody>()

  internal fun newCodec(
    client: OkHttpClient,
    chain: RealInterceptorChain,
  ): ExchangeCodec {
    val okHttpSocket = this.socket
    val http2Connection = this.http2Connection

    return if (http2Connection != null) {
      Http2ExchangeCodec(client, this, chain, http2Connection)
    } else {
      javaNetSocket.soTimeout = chain.readTimeoutMillis()

    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            chain!!
              .proceed(chain.request())
              .use { a -> assertThat(a.body.string()).isEqualTo("a") }
            chain.proceed(chain.request())
          },
        ).build()

  @BeforeEach
  fun setUp() {
    client =
      OkHttpClient
        .Builder()
        .addNetworkInterceptor(
          Interceptor { chain ->
            when {
              extraNetworkInterceptor != null -> extraNetworkInterceptor!!.intercept(chain)
              else -> chain.proceed(chain.request())
            }
          },
        ).addNetworkInterceptor(networkInterceptor)
        .addInterceptor(applicationInterceptor)

    } catch (ignored: IllegalArgumentException) {
    }
  }

  @Test fun clonedInterceptorsListsAreIndependent() {
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        chain.proceed(chain.request())
      }
    val original = clientTestRule.newClient()
    original
      .newBuilder()
      .addInterceptor(interceptor)
      .addNetworkInterceptor(interceptor)

  @J2ktIncompatible
  @GwtIncompatible // SynchronousQueue
  public static <E> SynchronousQueue<E> newSynchronousQueue() {
    return new SynchronousQueue<>();
  }

  /**
   * Drains the queue as {@link BlockingQueue#drainTo(Collection, int)}, but if the requested {@code
   * numElements} elements are not available, it will wait for them up to the specified timeout.
   *