import org.junit.jupiter.api.io.TempDir

class RequestBodyTest {
  private lateinit var filePath: okio.Path

  @BeforeEach
  fun setup(
    @TempDir tempDir: Path,
  ) {
    filePath = tempDir.toOkioPath() / "file.txt"
  }

  @Test
  fun testFileDescriptor() {
    assertOnFileDescriptor { fd ->
      val requestBody = fd.toRequestBody()

      assertThat(requestBody.contentLength()).isEqualTo(-1L)

   * most [BufferedSource] instances, but not of [Buffer].
   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {

import org.junit.jupiter.api.Test

class TagsTest {
  @Test
  fun emptyTags() {
    val tags = EmptyTags
    assertThat(tags[String::class]).isNull()
  }

  @Test
  fun singleElement() {
    val tags = EmptyTags.plus(String::class, "hello")
    assertThat(tags[String::class]).isEqualTo("hello")
  }

  @Test
  fun multipleElements() {
    val tags =
      EmptyTags

      this.hostOnly = hostOnly
    }

    fun path(path: String) =
      apply {
        require(path.startsWith("/")) { "path must start with '/'" }
        this.path = path
      }

    fun secure() =
      apply {
        this.secure = true
      }

    fun httpOnly() =
      apply {
        this.httpOnly = true
      }

    fun sameSite(sameSite: String) =
      apply {

) : X509ExtendedTrustManager() {
  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers

  override fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,
    socket: Socket,
  ) {
    if (socket.peerName() !in insecureHosts) {
      delegate.checkServerTrusted(chain, authType, socket)
    }
  }

  override fun checkServerTrusted(

     * (either the origin server, cache, or both).
     */
    fun interceptors(): MutableList<Interceptor> = interceptors

    fun addInterceptor(interceptor: Interceptor) =
      apply {
        interceptors += interceptor
      }

    @JvmName("-addInterceptor") // Prefix with '-' to prevent ambiguous overloads from Java.
    inline fun addInterceptor(crossinline block: (chain: Interceptor.Chain) -> Response) =

    if (flushHeaders) {
      connection.flush()
    }
  }

  fun enqueueTrailers(trailers: Headers) {
    withLock {
      check(!sink.finished) { "already finished" }
      require(trailers.size != 0) { "trailers.size() == 0" }
      this.sink.trailers = trailers
    }
  }

  fun readTimeout(): Timeout = readTimeout

  fun writeTimeout(): Timeout = writeTimeout

  /**

    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  fun String.toOneShotRequestBody(): RequestBody =
    object : RequestBody() {
      override fun contentType() = null

      override fun isOneShot(): Boolean = true

      override fun contentLength() = ******@****.***8Size()

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8(this@toOneShotRequestBody)
      }

        private
        fun openJarFile(file: Path): ZipInputStream {
            return ZipInputStream(Files.newInputStream(file))
        }
    }

    /**
     * Implementation code that can be unit-tested.
     *
     * <p>Visible for testing.</p>
     */
    class Implementation(private val excludes: List<String>, private val includes: List<String>) {
        fun collectPackages(files: Iterable<Path>): Trie {

  }

  @Synchronized private fun checkNotClosed() {
    check(!closed) { "cache is closed" }
  }

  /** Force buffered operations to the filesystem. */
  @Synchronized
  @Throws(IOException::class)
  override fun flush() {
    if (!initialized) return

    checkNotClosed()
    trimToSize()
    journalWriter!!.flush()
  }

  @Synchronized fun isClosed(): Boolean = closed