*/
    @Override
    public boolean markSupported() {
        return fileInputStream.markSupported();
    }

    /**
     * Repositions this stream to the position at the time the mark method was last called on this input stream.
     * This method delegates to {@link FileInputStream#reset()}.
     *
     * @throws IOException if an I/O error occurs.
     */
    @Override

This means that instead of the normal process of your users sending requests to your API, it's **your API** (or your app) that could **send requests to their system** (to their API, their app).

This is normally called a **webhook**.

## Webhooks steps { #webhooks-steps }

The process normally is that **you define** in your code what is the message that you will send, the **body of the request**.

        calledName = new Name();
        callingName = new Name();
    }

    /**
     * Constructs a NetBIOS session request packet.
     *
     * @param calledName the NetBIOS name of the called (destination) host
     * @param callingName the NetBIOS name of the calling (source) host
     */
    public SessionRequestPacket(final Name calledName, final Name callingName) {
        type = SESSION_REQUEST;

 * resulting in notification could have occurred to an entry being manually removed or replaced, or
 * due to eviction resulting from timed expiration, exceeding a maximum size, or garbage collection.
 *
 * <p>An instance may be called concurrently by multiple threads to process different entries.
 * Implementations of this interface should avoid performing blocking calls or synchronizing on
 * shared resources.
 *

     */
    final Stack<E> previousElements = new Stack<>();

    /**
     * {@link #nextElements} if {@code next()} was called more recently then {@code previous},
     * {@link #previousElements} if the reverse is true, or -- overriding both of these -- {@code
     * null} if {@code remove()} or {@code add()} has been called more recently than either. We use
     * this to determine which stack to pop from on a call to {@code remove()} (or to pop from and

        when(src.openUnshared(eq(0), eq(SmbConstants.O_RDONLY), eq(SmbConstants.FILE_SHARE_READ), eq(SmbConstants.ATTR_NORMAL), eq(0)))
                .thenReturn(sfd);

        // openCopyTargetFile should be called by serverSideCopy, so dest.openUnshared must succeed
        SmbFileHandleImpl dfd = mock(SmbFileHandleImpl.class);
        when(dest.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(dfd);

            UpgradeResult result = orchestrator.executeStrategies(context, pomMap);

            assertTrue(result.success(), "Orchestrator should succeed when all strategies succeed");

            // Verify all strategies were called
            for (UpgradeStrategy strategy : mockStrategies) {
                verify(strategy).isApplicable(context);
                verify(strategy).apply(Mockito.eq(context), Mockito.any());
            }
        }

## `PATH` Environment Variable { #path-environment-variable }

There is a **special** environment variable called **`PATH`** that is used by the operating systems (Linux, macOS, Windows) to find programs to run.

### Eine Engine erstellen { #create-an-engine }

Eine SQLModel-`engine` (darunter ist es tatsächlich eine SQLAlchemy-`engine`) ist das, was die **Verbindungen** zur Datenbank hält.

Sie hätten **ein einziges `engine`-Objekt** für Ihren gesamten Code, um sich mit derselben Datenbank zu verbinden.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *}

            return super.godHandPrologue(runtime);
        } catch (final UserRoleLoginException e) {
            return redirect(e.getActionClass());
        }
    }

    /**
     * Hook method called before action execution.
     * <p>
     * This method logs user access activity for the current request.
     * </p>
     *
     * @param runtime the action runtime context