if (title == null) {
            return StringUtil.EMPTY; // empty
        }

        final int[] spaceChars = getSpaceChars();
        try (final Reader reader = new StringReader(title)) {
            return TextUtil.normalizeText(reader).initialCapacity(title.length()).spaceChars(spaceChars).execute();
        } catch (final IOException e) {
            return StringUtil.EMPTY; // empty
        }
    }

            LOGGER.warn("The {} file does not exist. The --resume / -r feature will not work.", path);
            return properties;
        }

        try (Reader reader = Files.newBufferedReader(path)) {
            properties.load(reader);
        } catch (IOException e) {
            LOGGER.warn("Unable to read {}. The --resume / -r feature will not work.", path);
        }

        return properties;
    }

	public final fun -deprecated_headers ()Lokhttp3/Headers;
	public final fun -deprecated_method ()Ljava/lang/String;
	public final fun -deprecated_path ()Ljava/lang/String;
	public final fun -deprecated_response ()Lokhttp3/mockwebserver/MockResponse;
	public fun <init> (Ljava/lang/String;Ljava/lang/String;Lokhttp3/Headers;Lokhttp3/mockwebserver/MockResponse;)V
	public final fun headers ()Lokhttp3/Headers;
	public final fun method ()Ljava/lang/String;

    private File baseCss;
    private File releaseNotesCss;
    private File releaseNotesJavascript;

    public ReleaseNotesTransformer(Reader original) {
        super(original);
        this.in = new Reader() {
            Reader delegate = null;

            @Override
            public int read(char[] cbuf, int off, int len) throws IOException {
                if (delegate == null) {

def test_security_http_base():
    response = client.get("/users/me", headers={"Authorization": "Other foobar"})
    assert response.status_code == 200, response.text
    assert response.json() == {"scheme": "Other", "credentials": "foobar"}


def test_security_http_base_with_whitespaces():
    response = client.get("/users/me", headers={"Authorization": "Other  foobar "})
    assert response.status_code == 200, response.text

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Reader} that reads the characters in a {@link CharSequence}. Like {@code StringReader},
 * but works with any {@link CharSequence}.
 *
 * @author Colin Decker
 */

                queryLogs);
    }

    /**
     * Indexes documents from a query log reader asynchronously.
     *
     * @param ctx The content indexing context
     * @param queryLogReader The query log reader
     * @param docPerReq The number of documents to process per request
     * @param requestInterval The interval between requests

      .isEqualTo("<< 0x00000003     0 HEADERS       END_STREAM")
    assertThat(frameLog(true, 3, 0, TYPE_DATA, 0x1))
      .isEqualTo("<< 0x00000003     0 DATA          END_STREAM")
  }

  @Test
  fun flagOverlapOn0x4() {
    assertThat(frameLog(true, 3, 10000, TYPE_HEADERS, 0x4))
      .isEqualTo("<< 0x00000003 10000 HEADERS       END_HEADERS")

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

def test_async_generator_with_model(client: TestClient):
    response = client.get("/items/stream")
    assert response.status_code == 200
    assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
    assert response.headers["cache-control"] == "no-cache"
    assert response.headers["x-accel-buffering"] == "no"

    lines = response.text.strip().split("\n")
    data_lines = [line for line in lines if line.startswith("data: ")]