.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)

            System.out.format("%d%% done\n", (100 * bytesRead) / contentLength);
          }
        }
      }
    };

    OkHttpClient client = new OkHttpClient.Builder()
        .addNetworkInterceptor(chain -> {
          Response originalResponse = chain.proceed(chain.request());
          return originalResponse.newBuilder()
              .body(new ProgressResponseBody(originalResponse.body(), progressListener))

        }
      }
      return chain.proceed(chain.request());
    }
  };

  private final OkHttpClient client = new OkHttpClient.Builder()
      .addNetworkInterceptor(CHECK_HANDSHAKE_INTERCEPTOR)
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

        // can be read from the cache.
        System.out.println("Force cache: true");
        clientForCall = client.newBuilder()
            .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
            .build();
      } else {
        System.out.println("Force cache: false");
        clientForCall = client;
      }

### Network Interceptors

Registering a network interceptor is quite similar. Call `addNetworkInterceptor()` instead of `addInterceptor()`:

```java
OkHttpClient client = new OkHttpClient.Builder()
    .addNetworkInterceptor(new LoggingInterceptor())
    .build();

Request request = new Request.Builder()
    .url("http://www.publicobject.com/helloworld.txt")

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

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