.getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    sort(entries, Helpers.entryComparator(navigableMap.comparator()));
    for (int i = 0; i < entries.size(); i++) {
      for (int j = i + 1; j < entries.size(); j++) {
        assertEqualInOrder(
            entries.subList(i, j),
            navigableMap.subMap(entries.get(i).getKey(), entries.get(j).getKey()).entrySet());

///

## Eine `Response` zurückgeben { #return-a-response }

Tatsächlich können Sie jede `Response` oder jede Unterklasse davon zurückgeben.

/// info | Info

`JSONResponse` selbst ist eine Unterklasse von `Response`.

///

Und wenn Sie eine `Response` zurückgeben, wird **FastAPI** diese direkt weiterleiten.

	xhttp "github.com/minio/minio/internal/http"
)

func TestGetObjectLambdaHandler(t *testing.T) {
	testCases := []struct {
		name         string
		statusCode   int
		body         string
		contentType  string
		expectStatus int
	}{
		{
			name:         "Success 206 Partial Content",
			statusCode:   206,
			body:         "partial-object-data",
			contentType:  "text/plain",
			expectStatus: 206,
		},

    byte[] hashBytes = hashCode.asBytes();
    int totalBytes = hashCode.bits() / 8;

    for (int bytes = 0; bytes < totalBytes; bytes++) {
      byte[] bb = new byte[bytes];
      hashCode.writeBytesTo(bb, 0, bb.length);

      assertThat(bb).isEqualTo(Arrays.copyOf(hashBytes, bytes));
    }
  }

  private static class ExpectedHashCode {
    final byte[] bytes;
    final int asInt;

from fastapi import FastAPI

app = FastAPI()

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):

    /**
     * Error categories
     */
    public enum Category {
        AUTHENTICATION, AUTHORIZATION, NETWORK, PROTOCOL, RESOURCE, CONFIGURATION, ENCRYPTION, TIMEOUT, IO, UNKNOWN
    }

    private final int errorCode;
    private final Severity severity;
    private final Category category;
    private final Map<String, Object> context;
    private final long timestamp;
    private String recoveryHint;

    /**

            || this.container.getAttribute(`${this.pfx}-cursor`) || '▋';
        this.lineData = this.lineDataToElements(options.lineData || []);
        this.loadLines()
        if (!options.noInit) this.init()
    }

    loadLines() {
        // Load all the lines and create the container so that the size is fixed
        // Otherwise it would be changing and the user viewport would be constantly

      }

    /**
     * Sets the response body to [body], chunked every [maxChunkSize] bytes.
     */
    public fun chunkedBody(
      body: Buffer,
      maxChunkSize: Int = Int.MAX_VALUE,
    ): Builder =
      apply {
        removeHeader("Content-Length")
        headers_.add("Transfer-encoding: chunked")

        val bytesOut = Buffer()
        while (!body.exhausted()) {

        GeoInfo geoInfo = null;
        FacetInfo facetInfo = null;
        HighlightInfo highlightInfo = null;
        String sort = "";
        int startPosition = 0;
        int pageSize = 10;
        int offset = 0;
        String[] extraQueries = new String[0];
        Map<String, Object> attributes = new HashMap<>();
        Locale locale = Locale.ENGLISH;

    int length = s1.length();
    if (s1 == s2) {
      return true;
    }
    if (length != s2.length()) {
      return false;
    }
    for (int i = 0; i < length; i++) {
      char c1 = s1.charAt(i);
      char c2 = s2.charAt(i);
      if (c1 == c2) {
        continue;
      }
      int alphaIndex = getAlphaIndex(c1);