val relay = edit(file, pipe.source, metadata, 5)
    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)
    sink.writeUtf8("abcdefghij")
    Thread.sleep(500)
    sink.writeUtf8("klmnopqrst")
    sink.close()
    assertThat<ByteString>(future1.get())
      .isEqualTo("abcdefghijklmnopqrst".encodeUtf8())

    val request1ReceivedAt = System.currentTimeMillis()
    assertThat(server.takeRequest().headers["If-None-Match"]).isNull()

    // Hit that stored response. It's different, but Vary says it doesn't matter.
    Thread.sleep(10) // Make sure the timestamps are unique.
    val cacheHit =
      executeSynchronously(
        "/",
        "Accept-Language",
        "en-US",
        "Accept-Charset",
        "UTF-8",
      )

    assertThat(recordedRequest!!.method).isEqualTo("GET")
    assertThat(recordedRequest.path).isEqualTo(
      "/lookup?ct&dns=AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ",
    )
    Thread.sleep(2000)
    server.enqueue(
      dnsResponse(
        "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c000500010" +

import okhttp3.internal.toHostHeader
import okio.BufferedSink
import okio.BufferedSource
import okio.buffer
import okio.sink
import okio.source

/**
 * A single attempt to connect to a remote server, including these steps:
 *
 *  * [TCP handshake][connectSocket]
 *  * Optional [CONNECT tunnels][connectTunnel]. When using an HTTP proxy to reach an HTTPS server

        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()

    // Sleep longer than the HTTP client's read timeout.
    Thread.sleep((client.readTimeoutMillis + 500).toLong())
    server.send("abc")
    clientListener.assertTextMessage("abc")
    closeWebSockets(webSocket, server)
  }

  @Test

      yieldUntil(ResumePriority.BeforeOtherTasks) {
        contextSwitchCount > contextSwitchCountBefore
      }
    }
  }

  /** Sleep until [durationNanos] elapses. For use by the task threads. */
  fun sleep(durationNanos: Long) {
    taskRunner.lock.withLock {
      val sleepUntil = nanoTime + durationNanos
      yieldUntil { nanoTime >= sleepUntil }
    }
  }

  /**

    assertThat(realTaskRunner.activeQueues()).isNotEmpty()
    Thread.sleep(100)
    val threads = arrayOfNulls<Thread>(Thread.activeCount() * 2)
    Thread.enumerate(threads)
    for (t in threads) {
      if (t != null && t.name == "OkHttp TaskRunner") {
        t.interrupt()
      }
    }
    Thread.sleep(100)
    assertThat(realTaskRunner.activeQueues()).isEmpty()
  }

    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/master' || contains(github.event.pull_request.labels.*.name, 'documentation')

    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Configure JDK
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'

      var readyTask: Task? = null
      var multipleReadyTasks = false

      // Decide what to run. This loop's goal wants to:
      //  * Find out what this thread should do (either run a task or sleep)
      //  * Find out if there's enough work to start another thread.
      eachQueue@ for (queue in readyQueues) {
        val candidate = queue.futureTasks[0]

  private fun waitForConnectionShutdown(connection: RealConnection?) {
    if (connection!!.isHealthy(false)) {
      Thread.sleep(100L)
    }
    if (connection.isHealthy(false)) {
      Thread.sleep(2000L)
    }
    if (connection.isHealthy(false)) {
      throw TimeoutException("connection didn't shutdown within timeout")
    }
  }

  /**