internal var activeTask: Task? = null

  /** Scheduled tasks ordered by [Task.nextExecuteNanoTime]. */
  internal val futureTasks = mutableListOf<Task>()

  /** True if the [activeTask] should be canceled when it completes. */
  internal var cancelActiveTask = false

  /**
   * Returns a snapshot of tasks currently scheduled for execution. Does not include the

 *
 * The task runner is also responsible for releasing held threads when the library is unloaded.
 * This is for the benefit of container environments that implement code unloading.
 *
 * Most applications should share a process-wide [TaskRunner] and use queues for per-client work.
 */
class TaskRunner(
  val backend: Backend,
  internal val logger: Logger = TaskRunner.logger,
) {
  val lock: ReentrantLock = ReentrantLock()

 * They don't specify whether a specific proxy server should be used or how to authenticate with that proxy server....

 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,
 * attempt to mutate the event parameters, or be reentrant back into the client.
 * Any IO - writing to files or network should be done asynchronously.
 */
@ExperimentalOkHttpApi
abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,

        append(request.url)
      } else {
        append(requestPath(request.url))
      }
      append(" HTTP/1.1")
    }

  /**
   * Returns true if the request line should contain the full URL with host and port (like "GET
   * http://android.com/foo HTTP/1.1") or only the path (like "GET /foo HTTP/1.1").
   */
  private fun includeAuthorityInRequestLine(
    request: Request,

  fun request(): Request

  /**
   * Invokes the request immediately, and blocks until the response can be processed or is in error.
   *
   * To avoid leaking resources callers should close the [Response] which in turn will close the
   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed

internal fun Regex.matchAtPolyfill(
  input: CharSequence,
  index: Int,
): MatchResult? {
  val candidate = find(input, index) ?: return null
  if (candidate.range.first != index) return null // Didn't match where it should have.
  return candidate
}

@JvmField
val EMPTY_BYTE_ARRAY: ByteArray = ByteArray(0)

/** Byte order marks. */
internal val UNICODE_BOMS =
  Options.of(
    // UTF-8.
    "efbbbf".decodeHex(),

    val request2 = Request.Builder().url(server.url("/")).build()
    val response2 = client.newCall(request2).execute()
    assertThat(response2.body.string()).isEqualTo("def")

    // The HTTP calls should share a single connection.
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun proxySelector() {
    server.enqueue(MockResponse.Builder().body("abc").build())

    assertThat(logs.map { it.msg }).containsExactly(
      "--> GET http://google.com/robots.txt",
      "<-- HTTP FAILED: java.net.UnknownHostException: shortcircuit",
    )
    // We should consider if these logs should retain Exceptions
    assertThat(logs.last().throwable).isNull()
  }

  @Test
  fun testLoggingEventListener() {
    val client =

     * were added by default.
     */
    fun clearHeaders() =
      apply {
        headers = Headers.Builder()
      }

    /**
     * Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a name followed
     * by a colon and a value.
     */
    fun addHeader(header: String) =
      apply {
        headers.add(header)
      }

    /**