*/
  fun toDer(
    writer: DerWriter,
    value: T,
  )

  fun toDer(value: T): ByteString {
    val buffer = Buffer()
    val writer = DerWriter(buffer)
    toDer(writer, value)
    return buffer.readByteString()
  }

  /**
   * Returns an adapter that expects this value wrapped by another value. Typically this occurs
   * when a value has both a context or application tag and a universal tag.
   *

        .writeByte(3) // String literal not Huffman encoded (len = 3).
        .writeByte('b'.code)
        .writeByte('a'.code)
        .writeByte('r'.code)
        .readByteString()
    val actual = bytesOut.readByteString()
    assertThat(actual).isEqualTo(expected)
  }

  @Test
  fun staticTableIndexedHeaders() {
    hpackWriter!!.writeHeaders(headerEntries(":method", "GET"))

      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()
    }

    override fun rstStream(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_RST_STREAM

    }

    skipRestOfLine()

    result +=
      Mapping(
        sourceCodePoint0.toInt(),
        sourceCodePoint1.toInt(),
        type,
        mappedTo.readByteString(),
      )
  }

  return SimpleIdnaMappingTable(result)
}

internal data class Mapping(
  val sourceCodePoint0: Int,
  val sourceCodePoint1: Int,
  val type: Int,

        throw IOException("Required SETTINGS preface not received")
      }
    } else {
      // The server reads the CONNECTION_PREFACE byte string.
      val connectionPreface = source.readByteString(CONNECTION_PREFACE.size.toLong())
      if (logger.isLoggable(FINE)) logger.fine(format("<< CONNECTION ${connectionPreface.hex()}"))
      if (CONNECTION_PREFACE != connectionPreface) {

        throw IOException(
          "response size exceeds limit ($MAX_RESPONSE_SIZE bytes): ${body.contentLength()} bytes",
        )
      }

      val responseBytes = body.source().readByteString()

      return DnsRecordCodec.decodeAnswers(hostname, responseBytes)
    }
  }

  private fun buildRequest(
    hostname: String,
    type: Int,
  ): Request =
    Request

   * may trigger an [OutOfMemoryError]. Prefer to stream the response body if this is a
   * possibility for your response.
   */
  @Throws(IOException::class)
  fun byteString() = consumeSource(BufferedSource::readByteString) { it.size }

  private inline fun <T : Any> ResponseBody.consumeSource(
    consumer: (BufferedSource) -> T,
    sizeMapper: (T) -> Int,
  ): T {
    val contentLength = contentLength()

        ) {
          assertThat(inFinished).isFalse()
          assertThat(streamId).isEqualTo(expectedStreamId)
          assertThat(length).isEqualTo(Http2.INITIAL_MAX_FRAME_SIZE)
          val data = source.readByteString(length.toLong())
          for (b in data.toByteArray()) {
            assertThat(b).isEqualTo(2.toByte())
          }
        }
      },
    )
  }

  @Test fun dataFrameNotAssociateWithStream() {

      requestLine = request,
      headers = headers.build(),
      chunkSizes = chunkSizes,
      bodySize = requestBody.receivedByteCount,
      body =
        when {
          hasBody -> requestBody.buffer.readByteString()
          else -> null
        },
      connectionIndex = connectionIndex,
      exchangeIndex = exchangeIndex,
      socket = socket,
      failure = failure,
    )
  }

        if (bodyBuffer.isProbablyUtf8()) {
          append(" \\\n  --data ${bodyBuffer.readUtf8().shellEscape()}")
        } else {
          append(" \\\n  --data-binary ${bodyBuffer.readByteString().hex().shellEscape()}")
        }
      }
    }

  private fun String.shellEscape(): String = "'${replace("'", "'\\''")}'"