import okhttp3.ResponseBody.Companion.asResponseBody
import okhttp3.internal.http.promisesBody
import okio.BufferedSource
import okio.GzipSource
import okio.Source
import okio.buffer

/**
 * Transparent Compressed response support.
 *
 * The algorithm map will be turned into a heading such as "Accept-Encoding: br, gzip"
 *
 * If [algorithms] is empty this interceptor has no effect. To disable compression set

import okio.GzipSink
import okio.buffer

internal class GzipRequestBody(
  val delegate: RequestBody,
) : RequestBody() {
  override fun contentType() = delegate.contentType()

  // We don't know the compressed length in advance!
  override fun contentLength() = -1L

  override fun writeTo(sink: BufferedSink) {
    GzipSink(sink).buffer().use(delegate::writeTo)
  }

  override fun isOneShot() = delegate.isOneShot()

@SuppressWarnings("serial") // uses writeReplace(), not default serialization
final class SingletonImmutableSet<E> extends ImmutableSet<E> {
  // We deliberately avoid caching the asList and hashCode here, to ensure that with
  // compressed oops, a SingletonImmutableSet packs all the way down to the optimal 16 bytes.

  final transient E element;

  SingletonImmutableSet(E element) {
    this.element = Preconditions.checkNotNull(element);
  }

  @Test
  fun testNoDecompress() {
    val s = "hello not compressed world".encodeUtf8()

    val response = response("https://example.com/", s)

    val decompressed = zstdInterceptor.decompress(response)
    assertThat(decompressed.header("Content-Encoding")).isNull()

    val responseString = decompressed.body.string()
    assertThat(responseString).isEqualTo("hello not compressed world")
  }

  @Test
  fun testUnknownAlgorithm() {

Interceptors can be chained. Suppose you have both a compressing interceptor and a checksumming interceptor: you'll need to decide whether data is compressed and then checksummed, or checksummed and then compressed. OkHttp uses lists to track interceptors, and interceptors are called in order.

![Interceptors Diagram](../assets/images/******@****.***)

### Application Interceptors

}

normalization {
  runtimeClasspath {
    /*
       - The below two ignored files are generated during test execution
       by the test: okhttp/src/test/java/okhttp3/osgi/OsgiTest.java

       - The compressed index.xml file contains a timestamp property which
       changes with every test execution, such that running the test
       actually changes the test classpath itself. This means that it

    return result
  }

  @Throws(EOFException::class)
  private fun skipName(source: Buffer) {
    // 0 - 63 bytes
    var length = source.readByte().toInt()

    if (length < 0) {
      // compressed name pointer, first two bits are 1
      // drop second byte of compression offset
      source.skip(1)
    } else {
      while (length > 0) {
        // skip each part of the domain name

			<arg>
  "(application/xml"
+ "|application/xhtml+xml"
+ "|application/rdf+xml"
+ "|application/pdf"
+ "|application/x-freemind"
+ "|application/lha"
+ "|application/x-lha"
+ "|application/x-lha-compressed"
+ "|text/xml"
+ "|text/xml-external-parsed-entity"
+ "|text/html)"
			</arg>
		</postConstruct>
	</component>

        result.replace("HEADERS", "PUSH_PROMISE") // TODO: Avoid allocation.
      }
      type == TYPE_DATA && flags and FLAG_COMPRESSED != 0 -> {
        result.replace("PRIORITY", "COMPRESSED") // TODO: Avoid allocation.
      }
      else -> result
    }
  }

      .isEqualTo("<< 0x00000003 10000 HEADERS       PRIORITY")
    assertThat(frameLog(true, 3, 10000, TYPE_DATA, 0x20))
      .isEqualTo("<< 0x00000003 10000 DATA          COMPRESSED")
  }

  /**
   * Ensures that valid flag combinations appear visually correct, and invalid show in hex.  This
   * also demonstrates how sparse the lookup table is.
   */
  @Test