import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.asRequestBody

class PostFile {
  private val client = OkHttpClient()

  fun run() {
    val file = File("README.md")

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = file.asRequestBody(MEDIA_TYPE_MARKDOWN),
      )

 */

package common

enum class Arch(
    val suffix: String,
    val nameOnLinuxWindows: String,
    val nameOnMac: String,
) {
    AMD64("64bit", "amd64", "x86_64"),
    AARCH64("aarch64", "aarch64", "aarch64"),
    ;

    fun asName() = name.lowercase().toCapitalized()
}

enum class Os(
    val agentRequirement: String,
    val androidHome: String,
    val jprofilerHome: String,

import java.util.Locale
import okhttp3.internal.UTC

/** The last four-digit year: "Fri, 31 Dec 9999 23:59:59 GMT". */
internal const val MAX_DATE = 253402300799999L

/**
 * Most websites serve cookies in the blessed format. Eagerly create the parser to ensure such
 * cookies are on the fast path.
 */
private val STANDARD_DATE_FORMAT =
  object : ThreadLocal<DateFormat>() {
    override fun initialValue(): DateFormat {

   *
   * If there's nothing to read and no default value, this will throw an exception.
   */
  fun fromDer(reader: DerReader): T

  fun fromDer(byteString: ByteString): T {
    val buffer = Buffer().write(byteString)
    val reader = DerReader(buffer)
    return fromDer(reader)
  }

  /**
   * Writes [value] to this adapter, unless it is the default value and can be safely omitted.
   *

  private fun followUpRequest(
    userResponse: Response,
    exchange: Exchange?,
  ): Request? {
    val route = exchange?.connection?.route()
    val responseCode = userResponse.code

    val method = userResponse.request.method
    when (responseCode) {
      HTTP_PROXY_AUTH -> {
        val selectedProxy = route!!.proxy
        if (selectedProxy.type() != Proxy.Type.HTTP) {

@Testcontainers
@Isolated
class BasicLoomTest {
  @JvmField
  @RegisterExtension
  val platform = PlatformRule()

  // Use mock server so we are strictly testing OkHttp client only in this test.
  // We should test MockWebServer later.
  @Container
  val mockServer: MockServerContainer = MockServerContainer(MOCKSERVER_IMAGE)

  val capturedOut = ByteArrayOutputStream()

  private lateinit var executor: ExecutorService

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(

package okhttp3.internal

import java.net.Authenticator
import java.net.PasswordAuthentication

class RecordingAuthenticator(
  private val authentication: PasswordAuthentication? =
    PasswordAuthentication(
      "username",
      "password".toCharArray(),
    ),
) : Authenticator() {
  val calls = mutableListOf<String>()

  override fun getPasswordAuthentication(): PasswordAuthentication? {
    calls.add(

        dst[dstIndex++] = (byte) val;
        dst[dstIndex++] = (byte) (val >> 8);
        dst[dstIndex++] = (byte) (val >> 16);
        dst[dstIndex++] = (byte) (val >> 24);
        dst[dstIndex++] = (byte) (val >> 32);
        dst[dstIndex++] = (byte) (val >> 40);
        dst[dstIndex++] = (byte) (val >> 48);
        dst[dstIndex++] = (byte) (val >> 56);
    }

 */
class RealConnection internal constructor(
  val taskRunner: TaskRunner,
  val connectionPool: RealConnectionPool,
  override val route: Route,
  /** The low-level TCP socket. */
  private val rawSocket: JavaNetSocket,
  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */
  private val javaNetSocket: JavaNetSocket,