override fun isOneShot(): Boolean = true

        override fun writeTo(sink: BufferedSink) {
          FileInputStream(this@toRequestBody).use {
            sink.buffer.writeAll(it.source())
          }
        }
      }
    }

    /** Returns a new request body that transmits this. */
    @JvmOverloads
    @JvmStatic
    @JvmName("create")

/**
 * An OkHttp [LoggingEventListener], with android Log as the target.
 */
fun LoggingEventListener.Companion.androidLogging(
  priority: Int = Log.INFO,
  tag: String = "OkHttp",
) = LoggingEventListener.Factory { Log.println(priority, tag, it) }

/**
 * An OkHttp [HttpLoggingInterceptor], with android Log as the target.
 */
fun HttpLoggingInterceptor.Companion.androidLogging(
  priority: Int = Log.INFO,

  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testGoodDecoderInterop(story: Story) {
    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )
    testDecoder(story)
  }

  internal class StoriesTestProvider : SimpleProvider() {
    override fun arguments(): List<Any> = createStories(HpackJsonUtil.storiesForCurrentDraft())
  }

class CookieTest {
  val url = "https://example.com/".toHttpUrl()

  @Test fun simpleCookie() {
    val cookie = parse(url, "SID=31d4d96e407aad42")
    assertThat(cookie.toString()).isEqualTo("SID=31d4d96e407aad42; path=/")
  }

  @Test fun noEqualsSign() {
    assertThat(parse(url, "foo")).isNull()
    assertThat(parse(url, "foo; Path=/")).isNull()
  }

  @Test fun emptyName() {
    assertThat(parse(url, "=b")).isNull()

}

internal fun Char.parseHexDigit(): Int =
  when (this) {
    in '0'..'9' -> this - '0'
    in 'a'..'f' -> this - 'a' + 10
    in 'A'..'F' -> this - 'A' + 10
    else -> -1
  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

internal infix fun Int.and(mask: Long): Long = toLong() and mask

        override fun contentType() = original.contentType()

        override fun contentLength() = original.contentLength()

        override fun source() = uppercase(original.source()).buffer()
      }
    }

    private fun uppercase(original: Source): Source {
      return object : ForwardingSource(original) {
        override fun read(
          sink: Buffer,
          byteCount: Long,

      k += BASE
    }
    return k + (((BASE - TMIN + 1) * delta) / (delta + SKEW))
  }

  private fun String.requiresEncode(
    pos: Int,
    limit: Int,
  ): Boolean {
    for (i in pos until limit) {
      if (this[i].code >= INITIAL_N) return true
    }
    return false
  }

  private fun String.codePoints(
    pos: Int,
    limit: Int,
  ): List<Int> {
    val result = mutableListOf<Int>()

      }
    } while (cursor.next() != -1)
  }

  fun closeCodeExceptionMessage(code: Int): String? {
    return if (code < 1000 || code >= 5000) {
      "Code must be in range [1000,5000): $code"
    } else if (code in 1004..1006 || code in 1015..2999) {
      "Code $code is reserved and may not be used."
    } else {
      null
    }
  }

  fun validateCloseCode(code: Int) {

  private val responses = mutableListOf<RecordedResponse>()

  @Synchronized
  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    responses.add(RecordedResponse(call.request(), null, null, null, e))
    (this as Object).notifyAll()
  }

  @Synchronized
  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    val body = response.body.string()

 */
class JettyHttpClientTest {
  private val client = HttpClient()

  @BeforeEach fun setUp() {
    client.start()
  }

  @AfterEach fun tearDown() {
    client.stop()
  }

  @Test fun get(server: MockWebServer) {
    server.enqueue(MockResponse(body = "hello, Jetty HTTP Client"))

    val request =
      client.newRequest(server.url("/").toUri())