//     timeout is hit we like to tear down the whole stream.

    private const val SOURCE_UPSTREAM = 1
    private const val SOURCE_FILE = 2

    @JvmField val PREFIX_CLEAN = "OkHttp cache v1\n".encodeUtf8()

    @JvmField val PREFIX_DIRTY = "OkHttp DIRTY :(\n".encodeUtf8()
    private const val FILE_HEADER_SIZE = 32L

    /**

    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun racingReaders() {
    val pipe = Pipe(1024)
    val sink = pipe.sink.buffer()
    val relay = edit(file, pipe.source, metadata, 5)
    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)
    sink.writeUtf8("abcdefghij")

  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  val server1 = MockWebServer()

  @StartStop
  val server2 = MockWebServer()

  private var listener = RecordingEventListener()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  val dns = FakeDns()

    server!!.enqueue(MockResponse(body = "abc"))
    ProxySelector.setDefault(null)
    val client = clientTestRule.newClient()
    val request = Request(server!!.url("/"))
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test fun sslSocketFactorySetAsSocketFactory() {
    val builder = OkHttpClient.Builder()
    assertFailsWith<IllegalArgumentException> {

  private val organizationName = "2.5.4.10"
  private val businessCategory = "2.5.4.15"
  private val subjectKeyIdentifier = "2.5.29.14"
  private val keyUsage = "2.5.29.15"
  private val crlDistributionPoints = "2.5.29.31"
  private val certificatePolicies = "2.5.29.32"
  private val authorityKeyIdentifier = "2.5.29.35"
  private val extendedKeyUsage = "2.5.29.37"

  @Test
  fun `decode simple certificate`() {
    val certificateBase64 =

import okio.buffer
import okio.use
import org.junit.jupiter.api.Test

class RequestTest {
  @Test
  fun constructor() {
    val url = "https://example.com/".toHttpUrl()
    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val method = "PUT"
    val request =
      Request(
        url = url,
        headers = headers,
        method = method,
        body = body,
      )

 * fills, it is doubled.
 */
@Suppress("NAME_SHADOWING")
object Hpack {
  private const val PREFIX_4_BITS = 0x0f
  private const val PREFIX_5_BITS = 0x1f
  private const val PREFIX_6_BITS = 0x3f
  private const val PREFIX_7_BITS = 0x7f

  private const val SETTINGS_HEADER_TABLE_SIZE = 4_096

  /**
   * The decoder has ultimate control of the maximum size of the dynamic table but we can choose

              val a1024x1024 = "a".repeat(1024 * 1024)
              repeat(100) {
                sink.writeUtf8(a1024x1024)
              }
            }
          },
        ).build()
    val buffer = Buffer()
    multipartBody.writeTo(buffer)

    val multipartReader = MultipartReader(buffer, "foo")
    val onlyPart = multipartReader.nextPart()!!

      require(utf8.readByte() == '.'.code.toByte())
      val vN = utf8.readDecimalLong()
      writeVariableLengthLong(vN)
    }
  }

  /** Used for tags and subidentifiers. */
  private fun writeVariableLengthLong(v: Long) {
    val sink = sink()
    val bitCount = 64 - java.lang.Long.numberOfLeadingZeros(v)
    val byteCount = (bitCount + 6) / 7
    for (shift in (byteCount - 1) * 7 downTo 0 step 7) {

    )
    server.enqueue(
      MockResponse(body = "GHI"),
    )
    val call1 = client.newCall(Request(server.url("/")))
    val response1 = call1.execute()
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    val call3 = client.newCall(Request(server.url("/")))
    val response3 = call3.execute()
    assertThat(response1.body.string()).isEqualTo("ABC")