val response =
      response("https://httpbin.org/brotli", s.decodeHex()) {
        header("Content-Encoding", "br")
      }

    val uncompressed = brotliInterceptor.decompress(response)

    val responseString = uncompressed.body.string()
    assertThat(responseString).contains("\"brotli\": true,")
    assertThat(responseString).contains("\"Accept-Encoding\": \"br\"")
  }

  @Test

    server.enqueue(
      MockResponse
        .Builder()
        .setHeader("Content-Type", PLAIN)
        .body(Buffer().writeUtf8("Uncompressed"))
        .build(),
    )
    val response =
      client
        .newCall(
          request()
            .post("Uncompressed".toRequestBody())
            .gzip()
            .build(),
        ).execute()
    val responseBody = response.body

  fun request(): Request

  /**
   * Returns the size in bytes of all messages enqueued to be transmitted to the server. This
   * doesn't include framing overhead. If compression is enabled, uncompressed messages size
   * is used to calculate this value. It also doesn't include any bytes buffered by the operating
   * system or network intermediaries. This method returns 0 if no messages are waiting in the

    callback.assertTextMessage("Hello")
  }

  @Test fun serverWithCompressionCompressedHelloTwoChunks() {
    data.write("418460b420bb92fced72".decodeHex()) // first 4 bytes of compressed 'Hello'
    data.write("80833851d9d4f156d9".decodeHex()) // last 3 bytes of compressed 'Hello'
    serverReaderWithCompression.processNextFrame()
    callback.assertTextMessage("Hello")
  }

  @Test fun clientTwoFrameHello() {

   * addresses, the output follows <a href="http://tools.ietf.org/html/rfc5952">RFC 5952</a> section
   * 4. The main difference is that this method uses "::" for zero compression, while Java's version
   * uses the uncompressed form (except on Android, where the zero compression is also done). The
   * other difference is that this method outputs any scope ID in the format that it was provided at

   * addresses, the output follows <a href="http://tools.ietf.org/html/rfc5952">RFC 5952</a> section
   * 4. The main difference is that this method uses "::" for zero compression, while Java's version
   * uses the uncompressed form (except on Android, where the zero compression is also done). The
   * other difference is that this method outputs any scope ID in the format that it was provided at

        header("Content-Encoding", "gzip")
      }

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

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

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

exposed by a sidecar could not be accessed using a Service. ([#128850](https://github.com/kubernetes/kubernetes/pull/128850), [@toVersus](https://github.com/toVersus)) [SIG Network and Testing]
- Fixed compressed kubelet log file permissions to use uncompressed kubelet log file permissions. ([#129893](https://github.com/kubernetes/kubernetes/pull/129893), [@simonfogliato](https://github.com/simonfogliato)) [SIG Node]

      decompress(response)
    } else {
      chain.proceed(chain.request())
    }

  /**
   * Returns a decompressed copy of the Response, typically via a streaming Source.
   * If no known decompression or the response is not compressed, returns the response unmodified.
   */
  internal fun decompress(response: Response): Response {
    if (!response.promisesBody()) {
      return response

        byte[] originalBytes = testData.getBytes();

        byte[] compressed = searchHelper.gzipCompress(originalBytes);
        byte[] decompressed = searchHelper.gzipDecompress(compressed);

        assertEquals(testData, new String(decompressed));
        // For small strings, gzip overhead might make compressed data larger
        // So we just verify that compression/decompression works correctly