.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> {
      client.newCall(request).execute()

  fun staleCoalescedConnection() {
    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()

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

          return super.createSocket()
        }
      }

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

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

        handshakeEnabledCipherSuites = socket.enabledCipherSuites.toList()

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

      Interceptor { chain: Interceptor.Chain ->
        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)

    closeWebSockets(webSocket, serverListener.assertOpen())
  }

  @Test
  fun webSocketAndNetworkInterceptors() {
    client =
      client.newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            throw AssertionError() // Network interceptors don't execute.
          },
        )
        .build()
    webServer.enqueue(

    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() }