.post("Hello".toRequestBody())
          .build()
      }
    assertThat(e).hasMessage("expected a null request body with 'Connection: upgrade'")
  }

  private fun enableTls(vararg protocols: Protocol) {
    client =
      client
        .newBuilder()
        .protocols(protocols.toList())
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),

      }

    fun bootstrapDnsHosts(bootstrapDnsHosts: List<InetAddress>?) =
      apply {
        this.bootstrapDnsHosts = bootstrapDnsHosts
      }

    fun bootstrapDnsHosts(vararg bootstrapDnsHosts: InetAddress): Builder = bootstrapDnsHosts(bootstrapDnsHosts.toList())

    fun systemDns(systemDns: Dns) =
      apply {
        this.systemDns = systemDns
      }
  }

      newHeadersToRedact += headersToRedact
      newHeadersToRedact += name
      headersToRedact = newHeadersToRedact
    }

    fun redactQueryParams(vararg name: String) {
      val newQueryParamsNameToRedact = TreeSet(String.CASE_INSENSITIVE_ORDER)
      newQueryParamsNameToRedact += queryParamsNameToRedact
      newQueryParamsNameToRedact.addAll(name)

      "ConnectStart",
      "SecureConnectStart",
    )
    assertThat(recordedEventTypes).endsWith("CallFailed")
  }

  private fun buildClient(
    heldCertificate: HeldCertificate?,
    vararg intermediates: X509Certificate,
  ): OkHttpClient {
    val builder =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(serverRootCa.certificate)
    if (heldCertificate != null) {

     * that we expect to be known by the remote peer. The peer already has that certificate so
     * transmitting it is unnecessary.
     */
    fun heldCertificate(
      heldCertificate: HeldCertificate,
      vararg intermediates: X509Certificate,
    ) = apply {
      this.heldCertificate = heldCertificate
      this.intermediates = arrayOf(*intermediates) // Defensive copy.
    }

    /**

  private fun allAscii(encoding: Encoding) =
    apply {
      for (i in 0..127) {
        encodings[i] = encoding
      }
    }

  fun override(
    encoding: Encoding,
    vararg codePoints: Int,
  ) = apply {
    for (codePoint in codePoints) {
      encodings[codePoint] = encoding
    }
  }

  fun nonPrintableAscii(encoding: Encoding) =
    apply {

    )

    taskFaker.advanceUntil(250.ms)
    assertEvents(
      "take plan 1",
      "plan 0 cancel",
      "plan 0 TCP connect canceled",
    )
  }

  private fun assertEvents(vararg expected: String) {
    val actual = generateSequence { routePlanner.events.poll() }.toList()
    assertThat(actual).containsExactly(*expected)
  }

  private val Int.ms: Long
    get() = this * 1_000_000L

    assertBytes(0xbe)
    assertThat(hpackWriter!!.headerCount).isEqualTo(2)
  }

  private fun newReader(source: Buffer): Hpack.Reader = Hpack.Reader(source, 4096)

  private fun byteStream(vararg bytes: Int): Buffer = Buffer().write(intArrayToByteArray(bytes))

  private fun checkEntry(
    entry: Header,
    name: String,
    value: String,
    size: Int,
  ) {

          .build(),
      )
    val response1 = call1.execute()
    assertThat(response1.body.string()).isEqualTo("abc")
  }

  private fun newServerSocketFactory(
    heldCertificate: HeldCertificate,
    vararg intermediates: X509Certificate,
  ): SSLSocketFactory {
    // Test setup fails on JDK9
    // java.security.KeyStoreException: Certificate chain is not valid
    // at sun.security.pkcs12.PKCS12KeyStore.setKeyEntry

    assertThat(readFileOrNull(getDirtyFile("k1", 0))).isNull()
  }

  private fun assertJournalEquals(vararg expectedBodyLines: String) {
    assertThat(readJournalLines()).isEqualTo(
      listOf(DiskLruCache.MAGIC, DiskLruCache.VERSION_1, "100", "2", "") + expectedBodyLines,
    )
  }

  private fun createJournal(vararg bodyLines: String) {
    createJournalWithHeader(
      DiskLruCache.MAGIC,