assert items == {"foo": {"name": "Fighters"}, "bar": {"name": "Tenders"}}

    # The end of the "with TestClient" block simulates terminating the app, so
    # the lifespan ends and items are cleaned up

    get() = eventListenerAdapter

  /** Events that haven't yet been removed. */
  val eventSequence: Deque<CallEvent> = ConcurrentLinkedDeque()

  /** The full set of events, used to match starts with ends. */
  private val eventsForMatching = ConcurrentLinkedDeque<CallEvent>()

  private val forbiddenLocks = mutableListOf<Any>()

  /** The timestamp of the last taken event, used to measure elapsed time between events. */

And then adding the extra keyword argument `hashed_password=hashed_password`, like in:

```Python
UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
```

...ends up being like:

```Python
UserInDB(
    username = user_dict["username"],
    password = user_dict["password"],
    email = user_dict["email"],
    full_name = user_dict["full_name"],

    }

    /**
     * Returns true if the string ends with the specified substring, ignoring case.
     *
     * @param target1
     *            the text to check
     * @param target2
     *            the substring to compare
     * @return {@literal true} if the string ends with the specified substring, ignoring case
     */

    // (1) "Reversal", the one we have here.
    // (2) "Dolphin". If we're rotating an array a of size n by a distance of d, then element a[0]
    //     ends up at a[d], which in turn ends up at a[2d], and so on until we get back to a[0].
    //     (All indices taken mod n.) If d and n are mutually prime, all elements will have been

`Depends()` receives a `scope` parameter that can be:

* `"function"`: start the dependency before the *path operation function* that handles the request, end the dependency after the *path operation function* ends, but **before** the response is sent back to the client. So, the dependency function will be executed **around** the *path operation **function***.

Dieses spezielle Suchmuster im regulären Ausdruck überprüft, dass der erhaltene Parameterwert:

* `^`: mit den nachfolgenden Zeichen beginnt, keine Zeichen davor hat.
* `fixedquery`: den exakten Text `fixedquery` hat.
* `$`: dort endet, keine weiteren Zeichen nach `fixedquery` hat.

        textBuf.setLength(0);
    }

    /**
     * SAX event handler called to process character data between XML elements.
     * Accumulates text content in a buffer for later processing when the element ends.
     *
     * @param ch the characters from the XML document
     * @param start the start position in the character array
     * @param length the number of characters to use from the character array

    testRotate(new boolean[] {true}, 1, 0, 1, new boolean[] {true});
    testRotate(new boolean[] {true}, 1, 1, 1, new boolean[] {true});

    // Rotate the central 5 elements, leaving the ends as-is
    testRotate(
        new boolean[] {false, true, false, true, false, true, false},
        -6,
        1,
        6,
        new boolean[] {false, false, true, false, true, true, false});

This specific regular expression pattern checks that the received parameter value:

* `^`: starts with the following characters, doesn't have characters before.
* `fixedquery`: has the exact value `fixedquery`.
* `$`: ends there, doesn't have any more characters after `fixedquery`.