Aber so hätten die Angreifer in wenigen Minuten oder Stunden mit der „Hilfe“ unserer Anwendung den richtigen Benutzernamen und das richtige Passwort erraten, indem sie die Zeitspanne zur Hilfe nehmen, die diese zur Beantwortung benötigt.

   *   <li>{@code [3..6]} encloses {@code [4..4)} (even though the latter is empty)
   *   <li>{@code (3..6]} does not enclose {@code [3..6]}
   *   <li>{@code [4..5]} does not enclose {@code (3..6)} (even though it contains every value
   *       contained by the latter range)
   *   <li>{@code [3..6]} does not enclose {@code (1..1]} (even though it contains every value
   *       contained by the latter range)
   * </ul>
   *

Für dieses Beispiel verwenden wir jedoch ein sehr einfaches HTML-Dokument mit etwas JavaScript, alles in einem langen String.

Das ist natürlich nicht optimal und man würde das nicht in der Produktion machen.

In der Produktion hätten Sie eine der oben genannten Optionen.

Aber es ist der einfachste Weg, sich auf die Serverseite von WebSockets zu konzentrieren und ein funktionierendes Beispiel zu haben:

    protected String lineSeparator = "\n";

    /** Whether to extract top-level fields as metadata. */
    protected boolean extractMetadata = true;

    /** Prefix for flattened nested keys. */
    protected String nestedKeySeparator = ".";

    /** Maximum number of array elements to extract. */
    protected int maxArrayElements = 100;

    /**
     * Constructs a new JsonExtractor.

Sie können einen Body auch als `dict` deklarieren, mit Schlüsseln eines Typs und Werten eines anderen Typs.

So brauchen Sie vorher nicht zu wissen, wie die Feld-/Attributnamen lauten (wie es bei Pydantic-Modellen der Fall wäre).

Das ist nützlich, wenn Sie Schlüssel empfangen, deren Namen Sie nicht bereits kennen.

---

///

Die generierten Responses in der OpenAPI für diese *Pfadoperation* lauten:

```JSON hl_lines="3-12"
{
    "responses": {
        "404": {
            "description": "Additional Response",
            "content": {
                "application/json": {
                    "schema": {

pkg bytes, func ContainsAny([]uint8, string) bool
pkg bytes, func ContainsRune([]uint8, int32) bool
pkg bytes, method (*Reader) Reset([]uint8)
pkg compress/flate, const HuffmanOnly = -2
pkg compress/flate, const HuffmanOnly ideal-int
pkg context, func Background() Context
pkg context, func TODO() Context
pkg context, func WithCancel(Context) (Context, CancelFunc)
pkg context, func WithDeadline(Context, time.Time) (Context, CancelFunc)

Da wir es als **Wert an ein Argument übergeben**, anstatt es in einer **Typannotation** zu verwenden, müssen wir `Union` verwenden, sogar in Python 3.10.

Wäre es eine Typannotation gewesen, hätten wir den vertikalen Strich verwenden können, wie in:

```Python
some_variable: PlaneItem | CarItem
```

## Editor-Unterstützung { #editor-support }

In Ihrem Editor erhalten Sie innerhalb Ihrer Funktion Typhinweise und Code-Vervollständigung überall (was nicht der Fall wäre, wenn Sie ein `dict` anstelle eines Pydantic-Modells erhalten hätten):

<img src="/img/tutorial/body/image03.png">

Sie bekommen auch Fehlermeldungen für inkorrekte Typoperationen:

<img src="/img/tutorial/body/image04.png">

  }

  /*
   * Under Android, MyError propagates up and fails the test?
   *
   * TODO(b/218700094): Does this matter to prod users, or is it just a feature of our testing
   * environment? If the latter, maybe write a custom Executor that avoids failing the test when it
   * sees an Error?
   */
  @AndroidIncompatible
  public void testTaskThrowsError() throws Exception {
    class MyError extends Error {}