*/
  fun schedule(
    name: String,
    delayNanos: Long = 0L,
    block: () -> Long,
  ) {
    schedule(
      object : Task(name) {
        override fun runOnce(): Long = block()
      },
      delayNanos,
    )
  }

  /**
   * Executes [block] once on a task runner thread.
   *

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(750)) {
      log.put("runOnce delays.size=${delays.size}")
      return@schedule delays.removeAt(0)
    }

    assertThat(log.take()).isEqualTo("runOnce delays.size=2")
    val t2 = System.nanoTime() / 1e6 - t1
    assertThat(t2).isCloseTo(750.0, 250.0)

    assertThat(log.take()).isEqualTo("runOnce delays.size=1")
    val t3 = System.nanoTime() / 1e6 - t1

    val task =
      object : Task("task") {
        val schedules = mutableListOf(50.µs)
        val delays = mutableListOf(200.µs, -1)

        override fun runOnce(): Long {
          log += "run@${taskFaker.nanoTime}"
          if (schedules.isNotEmpty()) {
            redQueue.schedule(this, schedules.removeAt(0))
          }
          return delays.removeAt(0)
        }

 */
package okhttp3.internal.concurrent

/**
 * A unit of work that can be executed one or more times.
 *
 * Recurrence
 * ----------
 *
 * Tasks control their recurrence schedule. The [runOnce] function returns -1L to signify that the
 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *

	// This effectively discards the very large initial flate setup cost,
	// as well as the initialization of bigBuf.
	runOnce(&bytes.Buffer{})
	b.ResetTimer()

	b.RunParallel(func(pb *testing.PB) {
		var buf bytes.Buffer
		for pb.Next() {
			runOnce(&buf)
		}
	})
}

func writeTestsToFS(tests []WriteTest) fs.FS {
	fsys := fstest.MapFS{}
	for _, wt := range tests {

    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) {
              ConnectResult(plan, throwable = e)
            }

  private val cleanupQueue: TaskQueue = taskRunner.newQueue()
  private val cleanupTask =
    object : Task("$okHttpName ConnectionPool connection closer") {
      override fun runOnce(): Long = closeConnections(System.nanoTime())
    }

  /**
   * Holding the lock of the connection being added or removed when mutating this, and check its

  )

  internal class Close(
    val code: Int,
    val reason: ByteString?,
    val cancelAfterCloseMillis: Long,
  )

  private inner class WriterTask : Task("$name writer") {
    override fun runOnce(): Long {
      try {
        if (writeOneFrame()) return 0L
      } catch (e: IOException) {
        failWebSocket(e = e, isWriter = true)
      }
      return -1L
    }
  }

   */
  private var nextSequenceNumber: Long = 0

  private val cleanupQueue = taskRunner.newQueue()
  private val cleanupTask =
    object : Task("$okHttpName Cache") {
      override fun runOnce(): Long {
        synchronized(this@DiskLruCache) {
          if (!initialized || closed) {
            return -1L // Nothing to do.
          }

          try {
            trimToSize()

HSPLokhttp3/internal/concurrent/Task;-><init>(Ljava/lang/String;ZI)V
HSPLokhttp3/internal/concurrent/TaskQueue$execute$1;-><init>(Ljava/lang/String;ZLkotlin/jvm/functions/Function0;)V
HSPLokhttp3/internal/concurrent/TaskQueue$execute$1;->runOnce()J
HSPLokhttp3/internal/concurrent/TaskQueue;-><init>(Lokhttp3/internal/concurrent/TaskRunner;Ljava/lang/String;)V
HSPLokhttp3/internal/concurrent/TaskQueue;->cancelAllAndDecide$okhttp()Z