* 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.
 */
class Relay private constructor(
  /**
   * Read/write persistence of the upstream source and its metadata. Its layout is as follows:
   *

    assertThat(requestedHosts).containsExactly(*expectedHosts)
    requestedHosts.clear()
  }

  /** Allocates and returns `count` fake IPv4 addresses like [255.0.0.100, 255.0.0.101].  */
  fun allocate(count: Int): List<InetAddress> {
    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {
        return@map InetAddress.getByAddress(

  }

  fun acceptFrame() {
    frameCount++
  }

  /** Maximum length of an outbound data frame.  */
  fun maxOutboundDataLength(): Int = writer.maxDataLength()

  /** Count of frames sent or received.  */
  fun frameCount(): Int = frameCount

  fun sendFrame(): Http2Writer {
    outFrames.add(OutFrame(frameCount++, bytesOut.size, false))
    return writer
  }

  /**

  }

  /**
   * Reads `count` characters from the stream. If the stream is exhausted before `count`
   * characters can be read, the remaining characters are returned and the stream is closed.
   */
  private fun readAscii(
    inputStream: InputStream,
    count: Int,
  ): String {
    val result = StringBuilder()
    for (i in 0 until count) {
      val value = inputStream.read()

    val bytes = "060229ffffff7f".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.OBJECT_IDENTIFIER.fromDer(bytes)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("unexpected byte count at OBJECT IDENTIFIER")
    }
  }

  /**
   * ```
   * Point ::= SEQUENCE {
   *   x [0] INTEGER OPTIONAL,
   *   y [1] INTEGER OPTIONAL
   * }
   * ```
   */
  data class Point(

      return state.policy.backoffDelayMillis.jitterBy(state.policy.backoffJitterMillis) * 1_000_000
    }
  }

  private fun Long.jitterBy(amount: Int): Long {
    return this + ThreadLocalRandom.current().nextInt(amount * -1, amount)
  }

  class AddressState(
    val address: Address,
    val queue: TaskQueue,
    var policy: ConnectionPool.AddressPolicy,
  ) {
    /**

  }

  fun run() {
    try {
      val count = getTestCount()
      println("Test count: $count")
      for (number in 1..count) {
        runTest(number, count)
      }
      updateReports()
    } finally {
      client.dispatcher.executorService.shutdown()
    }
  }

  private fun runTest(
    number: Long,
    count: Long,
  ) {
    val latch = CountDownLatch(1)

    }

    val questionCount = buf.readShort().toInt() and 0xffff
    val answerCount = buf.readShort().toInt() and 0xffff
    buf.readShort() // authority record count
    buf.readShort() // additional record count

    for (i in 0 until questionCount) {
      skipName(buf) // name
      buf.readShort() // type
      buf.readShort() // class
    }

    for (i in 0 until answerCount) {

    return List(elements.size / 2) { Header(elements[it * 2]!!, elements[it * 2 + 1]!!) }
  }

  @JvmStatic
  fun repeat(
    c: Char,
    count: Int,
  ): String {
    val array = CharArray(count)
    Arrays.fill(array, c)
    return String(array)
  }

  /**
   * Okio buffers are internally implemented as a linked list of arrays. Usually this implementation

import okio.ForwardingFileSystem
import okio.ForwardingSource
import okio.Path
import okio.Sink
import okio.Source
import okio.blackholeSink
import okio.buffer

/**
 * A cache that uses a bounded amount of space on a filesystem. Each cache entry has a string key
 * and a fixed number of values. Each key must match the regex `[a-z0-9_-]{1,64}`. Values are byte