HSPLandroidx/lifecycle/DispatchQueue;-><init>()V
HSPLandroidx/lifecycle/DispatchQueue;->canRun()Z
HSPLandroidx/lifecycle/DispatchQueue;->drainQueue()V
HSPLandroidx/lifecycle/DispatchQueue;->enqueue(Ljava/lang/Runnable;)V
HSPLandroidx/lifecycle/Lifecycle$1;-><clinit>()V
HSPLandroidx/lifecycle/Lifecycle$Event;-><clinit>()V
HSPLandroidx/lifecycle/Lifecycle$Event;-><init>(Ljava/lang/String;I)V

    // TODO test jdk.tls.client.enableSessionTicketExtension
    // TODO check debugging information

    enableTls()

    server.enqueue(MockResponse(body = "abc"))

    val request = Request(server.url("/"))

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)

    if (plan is FailedPlan) return plan.result

    // Connect TCP asynchronously.
    tcpConnectsInFlight += plan
    val taskName = "$okHttpName connect ${routePlanner.address.url.redact()}"
    taskRunner.newQueue().schedule(
      object : Task(taskName) {
        override fun runOnce(): Long {
          val connectResult =
            try {
              plan.connectTcp()
            } catch (e: Throwable) {

    responses.add(RecordedResponse(call.request(), response, null, body, null))
    (this as Object).notifyAll()
  }

  /**
   * Returns the recorded response triggered by `request`. Throws if the response isn't
   * enqueued before the timeout.
   */
  @Synchronized
  fun await(url: HttpUrl): RecordedResponse {
    val timeoutMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime()) + TIMEOUT_MILLIS
    while (true) {

  /** Returns the delay in nanoseconds until the next execution, or -1L to not reschedule. */
  abstract fun runOnce(): Long

  internal fun initQueue(queue: TaskQueue) {
    if (this.queue === queue) return

    check(this.queue === null) { "task is in multiple queues" }
    this.queue = queue
  }

  override fun toString(): String = name

    val request: RecordedRequest = mockWebServer.takeRequest()
    val nullableRequest: RecordedRequest? = mockWebServer.takeRequest(0L, TimeUnit.SECONDS)
    var requestCount: Int = mockWebServer.requestCount
    mockWebServer.enqueue(MockResponse())
    mockWebServer.start()
    mockWebServer.start(0)
    mockWebServer.start(InetAddress.getLocalHost(), 0)
    mockWebServer.shutdown()
    var dispatcher: Dispatcher = mockWebServer.dispatcher

  }

  private enum class ResumePriority {
    /** Resumes as soon as the condition is satisfied. */
    BeforeOtherTasks,

    /** Resumes after the already-enqueued tasks. */
    AfterEnqueuedTasks,

    /** Resumes after all other tasks, including tasks enqueued while yielding. */
    AfterOtherTasks,
  }

  /** Returns the task that was started, or null if there were no tasks to start. */

[2020-01-01 00:00:00] << 0x00000003     0 DATA          END_STREAM
[2020-01-01 00:00:00] << 0x00000000     8 GOAWAY
[2020-01-01 00:00:05] << 0x00000000     8 GOAWAY
```

### Task Runner Logging 

This logs task enqueues, starts, and finishes.

```
[2020-01-01 00:00:00] Q10000 scheduled after   0 µs: OkHttp ConnectionPool
[2020-01-01 00:00:00] Q10000 starting              : OkHttp ConnectionPool

  private val taskRunner = TaskRunner(backend)
  private val queue = taskRunner.newQueue()

  @AfterEach fun tearDown() {
    backend.shutdown()
  }

  @Test fun test() {
    val t1 = System.nanoTime() / 1e6

    val delays = mutableListOf(TimeUnit.MILLISECONDS.toNanos(1000), -1L)
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(750)) {
      log.put("runOnce delays.size=${delays.size}")

}

public abstract interface class okhttp3/Call : java/lang/Cloneable {
	public abstract fun cancel ()V
	public abstract fun clone ()Lokhttp3/Call;
	public abstract fun enqueue (Lokhttp3/Callback;)V
	public abstract fun execute ()Lokhttp3/Response;
	public abstract fun isCanceled ()Z
	public abstract fun isExecuted ()Z
	public abstract fun request ()Lokhttp3/Request;