}
                protected override fun createTestExecuter() = object: TestExecuter<TestExecutionSpec> {
                    override fun execute(s:TestExecutionSpec, t: TestResultProcessor) {}
                    override fun stopNow() {}
                }
                protected override fun createTestExecutionSpec() = object: TestExecutionSpec {}

        .byteCount(),
    ).isEqualTo(20L)
  }

  @Test fun addDate() {
    val expected = Date(0L)
    val headers =
      Headers
        .Builder()
        .add("testDate", expected)
        .build()
    assertThat(headers["testDate"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getDate("testDate")).isEqualTo(Date(0L))
  }

  @Test fun addInstant() {
    val expected = Instant.ofEpochMilli(0L)

        get() = branchName == EXPERIMENTAL_BRANCH

    fun vcsRootId() = DslContext.settingsRoot.id.toString()

    fun gradlePromoteVcsRootId() = if (isExperimental) GRADLE_PROMOTE_EXPERIMENTAL_VCS_ROOT_ID else GRADLE_PROMOTE_MASTER_VCS_ROOT_ID

    fun promoteNightlyTaskName() = nightlyTaskName("promote")

    fun prepNightlyTaskName() = nightlyTaskName("prep")

    fun promoteMilestoneTaskName(): String =
        when {

    return out
  }

  private fun windowUpdate(windowSizeIncrement: Long): Buffer {
    val out = Buffer()
    Http2Writer(out, true).windowUpdate(expectedStreamId, windowSizeIncrement)
    return out
  }

  private fun assertHeaderBlock(): Http2Reader.Handler =
    object : BaseTestHandler() {
      override fun headers(
        inFinished: Boolean,
        streamId: Int,

        readyQueues.removeAt(i)
      }
    }
  }

  interface Backend {
    fun nanoTime(): Long

    fun coordinatorNotify(taskRunner: TaskRunner)

    fun coordinatorWait(
      taskRunner: TaskRunner,
      nanos: Long,
    )

    fun <T> decorate(queue: BlockingQueue<T>): BlockingQueue<T>

    fun execute(
      taskRunner: TaskRunner,
      runnable: Runnable,
    )
  }

  }

  @Test
  fun cacheControl() {
    val request =
      Request
        .Builder()
        .cacheControl(CacheControl.Builder().noCache().build())
        .url("https://square.com")
        .build()
    assertThat(request.headers("Cache-Control")).containsExactly("no-cache")
    assertThat(request.cacheControl.noCache).isTrue()
  }

  @Test
  fun emptyCacheControlClearsAllCacheControlHeaders() {

    }

    private
    fun loaderClassBytesIndexFor(loader: ClassLoader): ClassBytesIndex = { classFilePath ->
        loader.getResource(classFilePath)?.let {
            { loader.getResourceAsStream(classFilePath).use { it!!.readBytes() } }
        }
    }

    private
    fun openJarFile(file: File) =
        openJars.computeIfAbsent(file, ::JarFile)

    override fun close() {

    level = DeprecationLevel.ERROR,
  )
  fun size(): Int = size

  fun encodedName(index: Int): String = encodedNames[index]

  fun name(index: Int): String = encodedName(index).percentDecode(plusIsSpace = true)

  fun encodedValue(index: Int): String = encodedValues[index]

  fun value(index: Int): String = encodedValue(index).percentDecode(plusIsSpace = true)

  override fun contentType(): MediaType = CONTENT_TYPE

  }

  private fun drainCancelQueue(eventSource: EventSource) {
    if (cancel) {
      cancel = false
      eventSource.cancel()
    }
  }

  private fun nextEvent(): Any =
    events.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for event.")

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,

  private val redQueue = taskRunner.newQueue()
  private val blueQueue = taskRunner.newQueue()
  private val greenQueue = taskRunner.newQueue()

  @AfterEach
  internal fun tearDown() {
    taskFaker.close()
  }

  @Test fun executeDelayed() {
    redQueue.execute("task", 100.µs) {
      log += "run@${taskFaker.nanoTime}"
    }

    taskFaker.advanceUntil(0.µs)
    assertThat(log).containsExactly()