// When & Then
            assertThrows(CIFSException.class, () -> transportPool.getChallenge(context, address));
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle null context")
        void testNullContext() {
            // Given

    //                                                                        ============
    /**
     * Verifies that the provided CRUD mode matches the expected mode.
     * Throws a validation error if the modes do not match.
     *
     * @param crudMode the actual CRUD mode
     * @param expectedMode the expected CRUD mode
     */
    protected void verifyCrudMode(final int crudMode, final int expectedMode) {

 * <p>Event subscriber methods must accept only one argument: the event.
 *
 * <p>Subscribers should not, in general, throw. If they do, the EventBus will catch and log the
 * exception. This is rarely the right solution for error handling and should not be relied upon; it
 * is intended solely to help find problems during development.
 *
 * <p>The EventBus guarantees that it will not call a subscriber method from multiple threads

                HttpSession session = req.getSession(false);
                if (session != null && session.getAttribute("npa-workgroup") != null) {
                    throw new IOException("Test error");
                } else {
                    resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                    resp.setHeader("WWW-Authenticate", "NTLM");
                    resp.flushBuffer();

Update `get_current_user` to receive the same token as before, but this time, using JWT tokens.

Decode the received token, verify it, and return the current user.

If the token is invalid, return an HTTP error right away.

{* ../../docs_src/security/tutorial004_an_py310.py hl[90:107] *}

## Update the `/token` *path operation* { #update-the-token-path-operation }

Create a `timedelta` with the expiration time of the token.

- `DecryptKey`: Takes a key ID and an encrypted data key and returns the plain data key - the decryption of the encrypted data key using the master key referenced by the key ID - on success or an error otherwise.

More details about supported KMS implementations and configuration can be found at the [KMS guide](https://github.com/minio/minio/blob/master/docs/kms/README.md).

        dep -->> handler: Raise HTTPException
        handler -->> client: HTTP error response
        dep -->> dep: Raise other exception
    end
    dep ->> operation: Run dependency, e.g. DB session
    opt raise
        operation -->> dep: Raise HTTPException
        dep -->> handler: Auto forward exception
        handler -->> client: HTTP error response
        operation -->> dep: Raise other exception

pkg bufio, method (*Writer) ReadFrom(io.Reader) (int64, error)
pkg bufio, method (ReadWriter) ReadFrom(io.Reader) (int64, error)
pkg bufio, method (ReadWriter) WriteTo(io.Writer) (int64, error)
pkg bufio, type Scanner struct
pkg bufio, type SplitFunc func([]uint8, bool) (int, []uint8, error)
pkg bufio, var ErrAdvanceTooFar error
pkg bufio, var ErrNegativeAdvance error
pkg bufio, var ErrTooLong error
pkg bytes, const MinRead = 512

# Framework Default
# =================
# ----------------------------------------------------------
# Lasta Taglib
# ------------
errors.header = <ul class="has-error">
errors.footer = </ul>
errors.prefix = <li><i class="fa fa-exclamation-circle"></i>
errors.suffix = </li>
# ----------------------------------------------------------
# Javax Validator
# ---------------

     * @param src the source byte array
     * @param si the starting index in the source array
     * @param slim the limit index in the source array
     * @return the decoded String
     * @throws IOException if a decoding error occurs
     */
    public static String dec_utf8(final byte[] src, int si, final int slim) throws IOException {
        final char[] uni = new char[slim - si];
        int ui, ch;