public final class okhttp3/logging/HttpLoggingInterceptor : okhttp3/Interceptor {
	public static final field Companion Lokhttp3/logging/HttpLoggingInterceptor$Companion;
	public final fun -deprecated_level ()Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public fun <init> ()V
	public fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;)V
	public synthetic fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;ILkotlin/jvm/internal/DefaultConstructorMarker;)V

        "network interceptor $interceptor must call proceed() exactly once",
      )
    }
  }

  @Test
  fun networkInterceptorsCannotChangeServerAddress() {
    server.enqueue(
      MockResponse
        .Builder()
        .code(500)
        .build(),
    )
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->

    builder = builder.encodedFragment("")
    val httpUrl: HttpUrl = builder.build()
  }

  @Test
  fun interceptor() {
    var interceptor: Interceptor = Interceptor { TODO() }
    interceptor = Interceptor { it: Interceptor.Chain -> TODO() }
  }

  @Test
  fun interceptorChain() {
    val chain: Interceptor.Chain = newInterceptorChain()
  }

  @Test
  fun handshakeCertificates() {

Logging Interceptor
===================

An [OkHttp interceptor][interceptors] which logs HTTP request and response data.

```java
HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(Level.BASIC);
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(logging)
  .build();
```

You can change the log level at any time by calling `setLevel()`.

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

 * [application interceptor][OkHttpClient.interceptors] or as a [OkHttpClient.networkInterceptors].
 *
 * The format of the logs created by this class should not be considered stable and may
 * 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 {

 *
 * If [algorithms] is empty this interceptor has no effect. To disable compression set
 * a specific "Accept-Encoding: identity" or similar.
 *
 * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding
 */
open class CompressionInterceptor(
  vararg val algorithms: DecompressionAlgorithm,
) : Interceptor {
  internal val acceptEncoding =
    algorithms
      .map {

import okhttp3.Headers
import okhttp3.Interceptor
import okhttp3.Response
import okhttp3.TrailersSource
import okhttp3.internal.UnreadableResponseBody
import okhttp3.internal.http2.ConnectionShutdownException
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)

      .newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->
          val response = chain.proceed(chain.request())
          // Ensure application interceptors never see a null body.
          assertThat(response.body).isNotNull()
          response
        },
      ).build()

include(":samples:slack")
include(":samples:static-server")
include(":samples:tlssurvey")
include(":samples:unixdomainsockets")
include(":container-tests")
include(":module-tests")

project(":okhttp-logging-interceptor").name = "logging-interceptor"

val androidHome = System.getenv("ANDROID_HOME")
val localProperties = Properties().apply {
  val file = rootProject.projectDir.resolve("local.properties")
  if (file.exists()) {