.message("Intercepted!")
          .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
          .build()
      }
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    assertFailsWith<IllegalStateException> {

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

    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    val connection = AtomicReference<Connection?>()
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            connection.set(chain!!.connection())
            chain.proceed(chain.request())
          },
        ).build()

                  if (cipherSuites != null) {
                    cipherSuites(*cipherSuites.toTypedArray())
                  }
                }.build(),
            ),
          )
        }
      }.addNetworkInterceptor {
        val socket = it.connection()!!.socket() as SSLSocket

        handshakeEnabledCipherSuites = socket.enabledCipherSuites.toList()

        it.proceed(it.request())
      }.build()

    // Capture the connection so that we can later make it stale.
    var connection: RealConnection? = null
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain ->
            connection = chain.connection() as RealConnection
            chain.proceed(chain.request())
          },
        ).build()

    server.enqueue(

        }
      }

    client =
      client
        .newBuilder()
        .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE))
        .socketFactory(socketFactory)
        .addNetworkInterceptor(
          Interceptor { chain ->
            try {
              chain.proceed(chain.request())
            } finally {
              firstConnectLatch.countDown()
            }
          },

        chain.proceed(chain.request())
      }
    val original = clientTestRule.newClient()
    original
      .newBuilder()
      .addInterceptor(interceptor)
      .addNetworkInterceptor(interceptor)
      .build()
    assertThat(original.interceptors.size).isEqualTo(0)
    assertThat(original.networkInterceptors.size).isEqualTo(0)
  }

  /**

        // Since this test knowingly leaks a connection, avoid using the default shared connection
        // pool, which should remain clean for subsequent tests.
        .connectionPool(ConnectionPool())
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            val response =
              chain!!.proceed(
                chain.request(),
              )
            responsesNotClosed.add(response)

    builder = builder.addInterceptor { it: Interceptor.Chain -> TODO() }
    val networkInterceptors: List<Interceptor> = builder.networkInterceptors()
    builder = builder.addNetworkInterceptor(Interceptor { TODO() })
    builder = builder.addNetworkInterceptor { it: Interceptor.Chain -> TODO() }
    builder = builder.eventListener(EventListener.NONE)
    builder = builder.eventListenerFactory { TODO() }

    fun addNetworkInterceptor(interceptor: Interceptor) =
      apply {
        networkInterceptors += interceptor
      }

    @JvmName("-addNetworkInterceptor") // Prefix with '-' to prevent ambiguous overloads from Java.
    inline fun addNetworkInterceptor(crossinline block: (chain: Interceptor.Chain) -> Response) =
      addNetworkInterceptor(Interceptor { chain -> block(chain) })

    /**