Harshavardhana <******@****.***> 1716837466 -0700

        byte[] compressed = compressionService.compress(testData, CompressionService.COMPRESSION_LZ77);
        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
        // Compressed size should typically be smaller (though not guaranteed for all data)

        byte[] decompressed = compressionService.decompress(compressed, CompressionService.COMPRESSION_LZ77);

     * @param algorithm the compression algorithm to use
     * @return the compressed data
     * @throws CIFSException if compression fails
     */
    byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException;

    /**
     * Decompresses data that was compressed with the specified algorithm.
     *
     * @param compressedData the compressed data
     * @param algorithm the compression algorithm that was used

 */
package okhttp3

import okhttp3.ResponseBody.Companion.asResponseBody
import okhttp3.internal.http.promisesBody
import okio.BufferedSource
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

### 4. Excluded Types

- Already compressed objects are not fit for compression since they do not have compressible patterns.
Such objects do not produce efficient [`LZ compression`](https://en.wikipedia.org/wiki/LZ77_and_LZ78)
which is a fitness factor for a lossless data compression.

Pre-compressed input typically compresses in excess of 2GiB/s per core,

            method.setAccessible(true);

            // Compressed forms should remain unchanged
            assertEquals("::1", method.invoke(null, "::1"));
            assertEquals("2001:db8::1", method.invoke(null, "2001:db8::1"));

            // Expanded forms should be compressed
            assertEquals("::1", method.invoke(null, "0:0:0:0:0:0:0:1"));

        }
        return address;
    }

    /**
     * Compresses an IPv6 address string to its canonical compressed form.
     * For example, "0:0:0:0:0:0:0:1" becomes "::1"
     *
     * @param ipv6Address the IPv6 address string to compress
     * @return the compressed IPv6 address string
     */
    protected static String compressIPv6(final String ipv6Address) {

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

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

///

## Use cases { #use-cases }

Some use cases include:

* Converting non-JSON request bodies to JSON (e.g. [`msgpack`](https://msgpack.org/index.html)).
* Decompressing gzip-compressed request bodies.
* Automatically logging all request bodies.

## Handling custom request body encodings { #handling-custom-request-body-encodings }