projectPathToExecutedTaskPaths.computeIfAbsent(taskPathToProjectPath(taskPath)) { mutableListOf() }.add(taskPath)
    }

    private
    fun addFailedTaskPath(taskPath: String) {
        projectPathToFailedTaskPaths.computeIfAbsent(taskPathToProjectPath(taskPath)) { mutableListOf() }.add(taskPath)
    }

    private

  @Test fun executeScheduledEarlierReplacesRepeatedLater() {
    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()) {

  class Builder {
    private var notBefore = -1L
    private var notAfter = -1L
    private var commonName: String? = null
    private var organizationalUnit: String? = null
    private val altNames = mutableListOf<String>()
    private var serialNumber: BigInteger? = null
    private var keyPair: KeyPair? = null
    private var signedBy: HeldCertificate? = null
    private var maxIntermediateCas = -1

  private var runCallCount = 0

  /** Queues with tasks that are currently executing their [TaskQueue.activeTask]. */
  private val busyQueues = mutableListOf<TaskQueue>()

  /** Queues not in [busyQueues] that have non-empty [TaskQueue.futureTasks]. */
  private val readyQueues = mutableListOf<TaskQueue>()

  private val runnable: Runnable =
    object : Runnable {
      override fun run() {
        var incrementedRunCallCount = false

    val pushPromises: MutableList<PushPromise>

    val settings: Settings

    constructor() {
      this.inTunnel = false
      this.informationalResponses = mutableListOf()
      this.status = "HTTP/1.1 200 OK"
      this.bodyVar = null
      this.streamHandlerVar = null
      this.webSocketListenerVar = null
      this.headers =
        Headers.Builder()

        .build()
    assertEquals(
      listOf(Protocol.HTTP_1_1),
      client.protocols,
    )
  }

  @Test fun nullProtocolInList() {
    val protocols =
      mutableListOf(
        Protocol.HTTP_1_1,
        null,
      )
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient.Builder()
        .protocols(protocols as List<Protocol>)
    }.also { expected ->

  private var limit = -1L

  /** Type hints scoped to the call stack, manipulated with [withTypeHint]. */
  private val typeHintStack = mutableListOf<Any?>()

  /**
   * The type hint for the current object. Used to pick adapters based on other fields, such as
   * in extensions which have different types depending on their extension ID.
   */
  var typeHint: Any?

 * elements are in the same order as in this.
 */
internal fun Array<String>.intersect(
  other: Array<String>,
  comparator: Comparator<in String>,
): Array<String> {
  val result = mutableListOf<String>()
  for (a in this) {
    for (b in other) {
      if (comparator.compare(a, b) == 0) {
        result.add(a)
        break
      }
    }
  }
  return result.toTypedArray()
}

/**

    internal val key: String,
  ) {
    /** Lengths of this entry's files. */
    internal val lengths: LongArray = LongArray(valueCount)
    internal val cleanFiles = mutableListOf<Path>()
    internal val dirtyFiles = mutableListOf<Path>()

    /** True if this entry has ever been published. */
    internal var readable: Boolean = false

  ): RecordedRequest {
    var request = ""
    val headers = Headers.Builder()
    var contentLength = -1L
    var chunked = false
    val requestBody = TruncatingBuffer(bodyLimit)
    val chunkSizes = mutableListOf<Int>()
    var failure: IOException? = null

    try {
      request = source.readUtf8LineStrict()
      if (request.isEmpty()) {
        throw ProtocolException("no request because the stream is exhausted")