private val publicSuffixListDotDat = testResources / "public_suffix_list.dat"
  private val outputFile = resources / PUBLIC_SUFFIX_RESOURCE

  val request = Request("https://publicsuffix.org/list/public_suffix_list.dat".toHttpUrl())

  suspend fun import() {
    check(fileSystem.metadata(resources).isDirectory)
    check(fileSystem.metadata(testResources).isDirectory)

      .isEqualTo(date("1950-01-01T00:00:00.000+0000").time)
    assertThat(Adapters.parseUtcTime("500101010000Z"))
      .isEqualTo(date("1950-01-01T01:00:00.000+0000").time)

    assertThat(Adapters.parseUtcTime("491231225959Z"))
      .isEqualTo(date("2049-12-31T22:59:59.000+0000").time)
    assertThat(Adapters.parseUtcTime("491231235959Z"))
      .isEqualTo(date("2049-12-31T23:59:59.000+0000").time)
  }

  fun multiline() {
    consumeEvents(
      """
      |data: YHOO
      |data: +2
      |data: 10
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "YHOO\n+2\n10"))
  }

  @Test
  fun multilineCr() {
    consumeEvents(
      """
      |data: YHOO
      |data: +2
      |data: 10
      |
      |
      """.trimMargin().replace("\n", "\r"),

    var id = lastId
    var type: String? = null
    val data = Buffer()

    while (true) {
      when (source.select(options)) {
        in 0..2 -> {
          completeEvent(id, type, data)
          return true
        }

        in 3..4 -> {
          source.readData(data)
        }

        in 5..7 -> {
          data.writeByte('\n'.code) // 'data' on a line of its own.
        }

        in 8..9 -> {

    }
  }

  fun toX509Certificate(): X509Certificate {
    val data = CertificateAdapters.certificate.toDer(this)
    try {
      val certificateFactory = CertificateFactory.getInstance("X.509")
      val certificates = certificateFactory.generateCertificates(Buffer().write(data).inputStream())
      return certificates.single() as X509Certificate
    } catch (e: NoSuchElementException) {

      if (context.executionException.isPresent) return@AfterEachCallback
      assertThat(data.readByteString().hex(), "Data not empty")
        .isEqualTo("")
    }

  // Mutually exclusive. Use the one corresponding to the peer whose behavior you wish to test.
  private val serverWriter =
    WebSocketWriter(
      isClient = false,
      sink = data,
      random = random,
      perMessageDeflate = false,

  val rangeStart: Int

  data class Constant(
    override val rangeStart: Int,
    val type: Int,
  ) : MappedRange {
    val b1: Int
      get() =
        when (type) {
          TYPE_IGNORED -> 119
          TYPE_VALID -> 120
          TYPE_DISALLOWED -> 121
          else -> error("unexpected type: $type")
        }
  }

  data class Inline1(
    override val rangeStart: Int,

 * is returned by upstream, or after the upstream source has been exhausted.
 *
 * As bytes are returned from upstream they are written to a local file. Downstream sources read
 * from this file as necessary.
 *
 * This class also keeps a small buffer of bytes recently read from upstream. This is intended to
 * save a small amount of file I/O and data copying.
 */

      this.headerBlock = headerBlock
    }

    override fun data(
      inFinished: Boolean,
      streamId: Int,
      source: BufferedSource,
      length: Int,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_DATA
      this.inFinished = inFinished
      this.streamId = streamId
      this.data = source.readByteString(length.toLong()).toByteArray()
    }

      newCases += case.copy(wire = bytesOut.readByteString())
    }

    testDecoder(story.copy(cases = newCases))
  }

  companion object {
    private val RAW_DATA = arrayOf("raw-data")
  }