import okhttp3.ResponseBody.Companion.asResponseBody
import okhttp3.internal.http.promisesBody
import okio.GzipSource
import okio.buffer
import okio.source
import org.brotli.dec.BrotliInputStream

fun uncompress(response: Response): Response {
  if (!response.promisesBody()) {
    return response
  }
  val body = response.body
  val encoding = response.header("Content-Encoding") ?: return response

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

    val uncompressed = uncompress(response)

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

  @Test

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.brotli

import okhttp3.Interceptor
import okhttp3.Response
import okhttp3.brotli.internal.uncompress

/**
 * Transparent Brotli response support.
 *
 * Adds Accept-Encoding: br to request and checks (and strips) for Content-Encoding: br in

        .request(Request.Builder().url("https://example.com/").build())
        .body(readBrotli10G().toResponseBody())
        .protocol(Protocol.HTTP_2)
        .build()

    val uncompressed = uncompress(response)

    assertFailure {
      uncompressed.body.string()
    }.isInstanceOf<IOException>()
      .message()
      .isNotNull()
      .matches(
        Regex(

		if cpErr != nil {
			return cpErr
		}

		return nil
	})
}

func TestMain(m *testing.M) {
	code := m.Run()
	// Cleanup uncompress snapshot charts
	os.RemoveAll(string(snapshotCharts))
	os.Exit(code)
}

func TestManifestGenerateComponentHubTag(t *testing.T) {
	g := NewWithT(t)

First, we create a `GzipRequest` class, which will overwrite the `Request.body()` method to decompress the body in the presence of an appropriate header.

If there's no `gzip` in the header, it will not try to decompress the body.

That way, the same route class can handle gzip compressed or uncompressed requests.

```Python hl_lines="8-15"
{!../../../docs_src/custom_request_and_route/tutorial001.py!}
```

					skipEnc *= sseDAREEncPackageBlockSize
					compressedOffset += skipEnc
					// Skip this number of uncompressed bytes.
					partSkip -= uCompOff
				}
			}
		} else {
			// Not encrypted
			var idx s2.Index
			_, err := idx.Load(s2.RestoreIndexHeaders(oi.Parts[firstPartIdx].Index))

			// Find compressed/uncompressed offsets of our partskip
			compOff, uCompOff, err2 := idx.Find(partSkip)

 * `server_max_window_bits`. This harms our ability to support these parameters:
 *
 *  * If `client_max_window_bits` is less than 15, OkHttp must close the web socket with code 1010.
 *    Otherwise it would compress values in a way that servers could not decompress.
 *  * If `server_max_window_bits` is less than 15, OkHttp will waste memory on an oversized buffer.
 *
 * See [RFC 7692, 7.1][rfc_7692] for details on negotiation process.
 *

	if w.f != nil {
		if err := w.closeCurrentFile(); err != nil {
			return err
		}

		// This function is a no-op if opts.Compress is false
		// writes an error in JSON form to stderr, if we cannot
		// compress.
		if err := w.compress(); err != nil {
			msg := fmt.Sprintf("unable to compress log file %v: %v, ignoring and moving on", w.f.Name(), err)
			stdErrEnc.Encode(&log.Entry{
				Level:   ErrorKind,
				Message: msg,

					return
				}
			}
		case "Compress":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
				z.Compress = nil
			} else {
				if z.Compress == nil {
					z.Compress = new(bool)
				}
				*z.Compress, err = dc.ReadBool()
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
			}