import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.ResponseBody
import okio.BufferedSource

class RealResponseBody(
  /**
   * Use a string to avoid parsing the content type until needed. This also defers problems caused
   * by malformed content types.
   */
  private val contentTypeString: String?,
  private val contentLength: Long,
  private val source: BufferedSource,
) : ResponseBody() {

    assertThat(cache.hitCount()).isEqualTo(0)
  }

  private fun corruptCertificate(cacheEntry: Path) {
    var content = fileSystem.source(cacheEntry).buffer().readUtf8()
    content = content.replace("MII", "!!!")
    fileSystem.sink(cacheEntry).buffer().writeUtf8(content).close()
  }

  @Test
  fun responseCachingAndRedirects() {
    server.enqueue(
      MockResponse.Builder()

   * content to go along with it. https://github.com/square/okhttp/issues/358
   */
  @Test
  fun noTransparentGzipFor304NotModified() {
    server.enqueue(
      MockResponse.Builder()
        .clearHeaders()
        .code(HttpURLConnection.HTTP_NOT_MODIFIED)
        .addHeader("Content-Encoding: gzip")
        .build(),
    )

            "description": "Additional Response",
            "content": {
                "application/json": {
                    "schema": {
                        "$ref": "#/components/schemas/Message"
                    }
                }
            }
        },
        "200": {
            "description": "Successful Response",
            "content": {
                "application/json": {

  private fun send404(
    stream: Http2Stream,
    path: String,
  ) {
    val responseHeaders =
      listOf(
        Header(":status", "404"),
        Header(":version", "HTTP/1.1"),
        Header("content-type", "text/plain"),
      )
    stream.writeHeaders(
      responseHeaders = responseHeaders,
      outFinished = false,
      flushHeaders = false,
    )
    val out = stream.getSink().buffer()

 * limitations under the License.
 */

repositories {
    maven {
        name = "Gradle public repository"
        url = uri("https://repo.gradle.org/gradle/public")
        content {
            includeGroup("net.rubygrapefruit")
            includeModule("flot", "flot")
            includeModule("org.gradle", "gradle-tooling-api")

      for ((key, value) in gist!!.files!!) {
        println(key)
        println(value.content)
      }
    }
  }

  @JsonClass(generateAdapter = true)
  data class Gist(var files: Map<String, GistFile>?)

  @JsonClass(generateAdapter = true)
  data class GistFile(var content: String?)
}

fun main() {
  ParseResponseWithMoshi().run()

          return Buffer().writeUtf8("hello")
        }
      }
    assertFailsWith<IOException> {
      body.bytes()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "Content-Length (10) and stream length (5) disagree",
      )
    }
  }

  @Test
  fun bytesThrowsMoreThanIntMaxValue() {
    val body: ResponseBody =
      object : ResponseBody() {

        .status("HTTP/1.1 204")
        .removeHeader("Content-Length")
        .build()
    server.enqueue(responseWithoutBody)
    val call = client.newCall(Request(server.url("/foo")))
    val response = call.execute()

    // Body contains nothing.
    assertThat(response.body.bytes().size).isEqualTo(0)
    assertThat(response.body.contentLength()).isEqualTo(0)

    // Content-Length header doesn't exist in a 204 response.

    assertThat(allAddresses).isEmpty()
  }

  @Test
  fun testRequestOnNetwork() {
    assumeNetwork()

    val context = InstrumentationRegistry.getInstrumentation().context
    val connectivityManager =
      context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val network =
      connectivityManager.activeNetwork ?: throw AssumptionViolatedException("No active network")