func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
	full, frag, n, err := b.collectFragments(delim)
	// Allocate new buffer to hold the full pieces and the fragment.
	buf := make([]byte, n)
	n = 0
	// Copy full pieces and fragment in.
	for i := range full {
		n += copy(buf[n:], full[i])
	}
	copy(buf[n:], frag)
	return buf, err
}

@app.get("/items/stream-raw", response_class=EventSourceResponse)
async def sse_items_raw():
    yield ServerSentEvent(raw_data="plain text without quotes")
    yield ServerSentEvent(raw_data="<div>html fragment</div>", event="html")
    yield ServerSentEvent(raw_data="cpu,87.3,1709145600", event="csv")


router = APIRouter()


@router.get("/events", response_class=EventSourceResponse)
async def stream_events():

import java.util.Comparator;
import java.util.List;

import org.apache.commons.cli.Option;
import org.junit.jupiter.api.Test;

import static java.util.Objects.nonNull;

/**
 * Pseudo test to generate documentation fragment about supported CLI options. TODO such documentation generation code
 * should not be necessary as unit test but should be run during site generation (Velocity? Doxia macro?)
 */
@Deprecated
class CLIManagerDocumentationTest {

    val queryParameter: String? = httpUrl.queryParameter("")
    val queryParameterNames: Set<String> = httpUrl.queryParameterNames()
    val encodedFragment: String? = httpUrl.encodedFragment()
    val fragment: String? = httpUrl.fragment()
    val getFromUrl: HttpUrl? = HttpUrl.get(URL(""))
    val getFromUri: HttpUrl? = HttpUrl.get(URI(""))
    val parse: HttpUrl? = HttpUrl.parse("")
  }

  @Test @Disabled

        isStart = (flags & DCERPC_LAST_FRAG) == DCERPC_LAST_FRAG;

        length = Encdec.dec_uint16le(buf, 8);
        if (length > max_recv) {
            throw new IOException("Unexpected fragment length: " + length);
        }

        while (off < length) {
            off += in.readDirect(buf, off, length - off);
        }
    }

    @Override
    public void close() throws IOException {

        HttpUrl link = response.request().url().resolve(href);
        if (link == null) continue; // URL is either invalid or its scheme isn't http/https.
        HttpUrl linkWithoutFragment = link.newBuilder().fragment(null).build();
        if (!queue.offer(linkWithoutFragment)) break; // Queue is full.
      }
    }
  }

  public static void main(String[] args) throws IOException {
    if (args.length != 2) {

 * **Headers**: size
 * **HeldCertificate**: certificate, keyPair
 * **HttpLoggingInterceptor**: level
 * **HttpUrl**: encodedFragment, encodedPassword, encodedPath, encodedPathSegments, encodedQuery,
   encodedUsername, fragment, host, password, pathSegments, pathSize, port, query,
   queryParameterNames, querySize, scheme, username
 * **MockResponse**: headers, http2ErrorCode, socketPolicy, status, trailers

query.highlight.boundary.position.detect=true
# Type for text fragment in query highlighting.
query.highlight.text.fragment.type=query
# Size for text fragment in query highlighting.
query.highlight.text.fragment.size=3
# Prefix length for text fragment in query highlighting.
query.highlight.text.fragment.prefix.length=5
# Suffix length for text fragment in query highlighting.
query.highlight.text.fragment.suffix.length=5

   */
  @get:JvmName("proxySelector") val proxySelector: ProxySelector,
) {
  /**
   * Returns a URL with the hostname and port of the origin server. The path, query, and fragment of
   * this URL are always empty, since they are not significant for planning a route.
   */
  @get:JvmName("url")
  val url: HttpUrl =
    HttpUrl
      .Builder()

        // ## Test factory methods with special characters in URL ##

        // ## Act ##
        final String specialUrl = "http://example.com/path?query=value&param=123#fragment";
        final CurlRequest getRequest = Curl.get(specialUrl);
        final CurlRequest postRequest = Curl.post(specialUrl);
        final CurlRequest putRequest = Curl.put(specialUrl);