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

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

internal class RealStream(
  private val http2Stream: Http2Stream,
) : Stream {
  override val requestBody = http2Stream.getSource().buffer()
  override val responseBody = http2Stream.getSink().buffer()

  override fun cancel() {
    http2Stream.closeLater(ErrorCode.CANCEL)
  }

    cls: Class<out IOException?>?,
    message: String?,
  ) {
    val event = nextEvent() as Failure
    assertThat(event.response!!.code).isEqualTo(code)
    if (body != null) {
      assertThat(event.responseBody).isEqualTo(body)
    }
    assertThat(event.t.javaClass).isEqualTo(cls)
    assertThat(event.t.message).isEqualTo(message)
  }

  /** Expose this recorder as a frame callback and shim in "ping" events.  */

  override fun intercept(chain: Chain): Response {
    return uppercaseResponse(chain.proceed(chain.request()))
  }

  private fun uppercaseResponse(response: Response): Response {
    val uppercaseBody: ResponseBody =
      object : ForwardingResponseBody(response.body) {
        override fun source(): BufferedSource {
          return uppercaseSource(delegate().source()).buffer()
        }
      }
    return response.newBuilder()

 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import okhttp3.Headers
import okhttp3.RequestBody
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.ResponseBody
import okhttp3.ResponseBody.Companion.toResponseBody
import okio.ArrayIndexOutOfBoundsException
import okio.Buffer
import okio.BufferedSink
import okio.BufferedSource
import okio.ByteString.Companion.decodeHex

   * Called when the HTTP response was successfully returned by the remote server. The callback may
   * proceed to read the response body with [Response.body]. The response is still live until its
   * response body is [closed][ResponseBody]. The recipient of the callback may consume the response
   * body on another thread.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not

import java.io.IOException
import kotlin.test.assertFailsWith
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response
import okhttp3.ResponseBody.Companion.toResponseBody
import okhttp3.brotli.internal.uncompress
import okio.ByteString
import okio.ByteString.Companion.EMPTY
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8

import okhttp3.RequestBody
import okhttp3.Response
import okhttp3.ResponseBody
import okhttp3.internal.http2.Header
import okio.Buffer
import okio.BufferedSource
import okio.Source

@JvmField
internal val EMPTY_HEADERS: Headers = commonEmptyHeaders

@JvmField
internal val EMPTY_REQUEST: RequestBody = commonEmptyRequestBody

@JvmField
internal val EMPTY_RESPONSE: ResponseBody = commonEmptyResponse

          .post("Uncompressed".toRequestBody().gzip())
          .build(),
      ).execute()
    val responseBody = response.body
    assertThat(responseBody.string(), "Expected response body to be valid")
      .isEqualTo("Uncompressed")
    responseBody.close()
    networkLogs
      .assertLogEqual("--> POST $url http/1.1")
      .assertLogEqual("Content-Encoding: gzip")

        }
      }
    }

    fun takeException(): Exception {
      return exceptions.take()
    }
  }

  companion object {
    fun uppercase(original: ResponseBody): ResponseBody {
      return object : ResponseBody() {
        override fun contentType() = original.contentType()

        override fun contentLength() = original.contentLength()