*
   * Otherwise if the response has a `Content-Type` header that specifies a charset, that is used
   * to determine the charset of the response bytes.
   *
   * Otherwise the response bytes are decoded as UTF-8.
   */
  fun charStream(): Reader =
    reader ?: BomAwareReader(source(), charset()).also {
      reader = it
    }

  /**
   * Returns the response as a string.
   *

    }

    /**
     * Wraps the reader with a {@link BufferedReader} if necessary.
     *
     * @param reader the reader
     * @return the wrapped reader
     */
    protected static Reader wrap(final Reader reader) {
        if (reader instanceof BufferedReader) {
            return reader;
        }
        if (reader instanceof StringReader) {
            return reader;
        }

    BufferedReader reader = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

            final Settings settings) {
        super(indexSettings, name);
    }

    @Override
    public Reader create(final Reader tokenStream) {
        return new IterationMarkCharFilter(tokenStream);
    }

        final Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
        if (readers.hasNext()) {
            final ImageReader reader = readers.next();
            try {
                reader.setInput(input);
                final ImageReadParam param = reader.getDefaultReadParam();
                final int width = reader.getWidth(0);
                final int height = reader.getHeight(0);

    /**
     * Test method for
     * {@link org.codelibs.core.io.PropertiesUtil#load(java.util.Properties, java.io.Reader)}
     * .
     */
    @Test
    public void testLoadPropertiesReaderReaderNull() {
        exception.expect(NullArgumentException.class);
        exception.expectMessage(is("[ECL0008]argument[reader] is null."));
        final InputStreamReader inputStreamReader = null;

   */
  fun fromDer(reader: DerReader): T

  fun fromDer(byteString: ByteString): T {
    val buffer = Buffer().write(byteString)
    val reader = DerReader(buffer)
    return fromDer(reader)
  }

  /**
   * Writes [value] to this adapter, unless it is the default value and can be safely omitted.
   *
   * If this does write a value, it will write a tag and a length and a full value.
   */
  fun toDer(
    writer: DerWriter,

    val connection = url.openConnection() as HttpURLConnection
    connection.setRequestProperty("Accept-Language", "en-US")
    val reader = BufferedReader(InputStreamReader(connection.inputStream, UTF_8))
    assertThat(connection.responseCode).isEqualTo(HttpURLConnection.HTTP_OK)
    assertThat(reader.readLine()).isEqualTo("hello world")
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo("GET / HTTP/1.1")

 * String indexName = "your_index_name";
 *
 * ESSourceReader reader = new ESSourceReader(client, settings, indexName);
 * reader.setScrollSize(1000); // Set the scroll size
 * reader.setLimitOfDocumentSize(1024 * 1024); // Limit document size to 1MB
 * reader.setQuery(QueryBuilders.termQuery("field", "value")); // Set a query
 *
 * Map<String, Object> document;
 * while ((document = reader.read()) != null) {
 *     // Process the document

    )
  }

  @Test fun pushPromise() {
    val expectedPromisedStreamId = 11
    val pushPromise =
      listOf(
        Header(Header.TARGET_METHOD, "GET"),
        Header(Header.TARGET_SCHEME, "https"),
        Header(Header.TARGET_AUTHORITY, "squareup.com"),
        Header(Header.TARGET_PATH, "/"),
      )

    // Write the push promise frame, specifying the associated stream ID.