return null;
        });
    }

    private OptionalThing<HttpSession> getSession() {
        final HttpSession session = request.getSession(false);
        if (session != null) {
            return OptionalEntity.of(session);
        }
        return OptionalEntity.empty();
    }

        assertFalse(java.util.Arrays.equals(salt1, salt2)); // Should be different
    }

    @Test
    @DisplayName("Test session initialization")
    public void testSessionInitialization() throws CIFSException {
        String sessionId = "test-session-1";
        byte[] salt = preauthService.generatePreauthSalt();

    /**
     * Unwraps this session to the specified type, allowing access to implementation-specific functionality.
     *
     * @param <T> the type to unwrap to
     * @param type the class of the type to unwrap to
     * @return session instance with the given type
     */
    <T extends SmbSession> T unwrap(Class<T> type);

    /**
     * Returns the CIFS context that this session is attached to.
     *

     * @throws IllegalArgumentException if {@code session} is null or invalid
     */
    @Nonnull
    default ArtifactCoordinates create(@Nonnull Session session, @Nonnull String coordinatesString) {
        return create(ArtifactCoordinatesFactoryRequest.build(session, coordinatesString));
    }

    @Nonnull
    default ArtifactCoordinates create(

public class MemoryDataHelper {
    /** Map of session IDs to URL queues for managing crawling queues. */
    protected volatile Map<String, Queue<UrlQueueImpl<Long>>> urlQueueMap = new HashMap<>();

    /** Map of session IDs to access result maps for storing crawling results. */
    protected volatile Map<String, Map<String, AccessResultImpl<Long>>> sessionMap = new HashMap<>();

    /** Map of session IDs to include URL patterns for filtering URLs. */

    }

    /**
     * Retrieves or creates the result document IDs cache from the session.
     * The cache is implemented as an LRU map to limit memory usage.
     *
     * @param session the HTTP session
     * @return the result document IDs cache map
     */
    private Map<String, String[]> getResultDocIdsCache(final HttpSession session) {
        @SuppressWarnings("unchecked")

 *
 * @author mbechler
 *
 */
public class Smb2SessionSetupResponse extends ServerMessageBlock2Response {

    /**
     * Session flag indicating this is a guest session
     */
    public static final int SMB2_SESSION_FLAGS_IS_GUEST = 0x1;

    /**
     * Session flag indicating this is a null/anonymous session
     */
    public static final int SMB2_SESSION_FLAGS_IS_NULL = 0x2;

                @Nonnull Session session, @Nonnull String type) throws ToolchainManagerException {
            return getDelegate().getToolchainFromBuildContext(session, type);
        }

        @Override
        public void storeToolchainToBuildContext(
                @Nonnull Session session, @Nonnull org.apache.maven.api.Toolchain toolchain) {
            getDelegate().storeToolchainToBuildContext(session, toolchain);
        }

                throw new CIFSException("No preauth integrity context found for session: " + sessionId);
            }
            log.warn("No preauth integrity context for session {}, skipping update", sessionId);
            return;
        }

        if (!context.isValid()) {
            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

        try {

     *
     * @param sessionId the ID of the session for which the URL filter is being added
     * @param url the URL to be excluded
     */
    void addExcludeUrlFilter(String sessionId, String url);

    /**
     * Adds a list of URLs to be excluded from crawling for a specific session.
     *
     * @param sessionId the ID of the session for which the URLs should be excluded