final HttpServletResponse response = LaResponseUtil.getResponse();

            final HttpSession session = request.getSession(false);
            if (session != null) {
                final String sesState = (String) session.getAttribute(SAML_STATE);
                if (StringUtil.isNotBlank(sesState)) {
                    session.removeAttribute(SAML_STATE);
                    try {

        }

        @Test
        @DisplayName("Should handle session key retrieval")
        void testSessionKeyRetrieval() throws CIFSException {
            // When: Getting session key
            byte[] sessionKey = handle.getSessionKey();

            // Then: Should return expected session key
            assertNotNull(sessionKey);

 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of

     */
    @Resource
    protected HttpServletRequest request;

    /**
     * Returns an empty OptionalThing for login manager since API actions
     * use token-based authentication instead of traditional session-based login.
     *
     * @return empty OptionalThing indicating no login manager is used
     */
    @Override
    protected OptionalThing<LoginManager> myLoginManager() {
        return OptionalThing.empty();
    }

package jcifs.internal.smb2.session;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

  val scheme: String
    get() =
      when (javaNetSocket) {
        is SSLSocket -> "https"
        else -> "http"
      }

  val handshake: Handshake?
    get() = (javaNetSocket as? SSLSocket)?.session?.handshake()

  val handshakeServerNames: List<String>
    get() =
      (javaNetSocket as? SSLSocket)
        ?.let { Platform.Companion.get().getHandshakeServerNames(it) }
        ?: listOf()

     *
     * @return negotiated multiplex count
     */
    public int getNegotiatedMpxCount() {
        return this.maxMpxCount;
    }

    /**
     * Gets the negotiated session key.
     *
     * @return negotiated session key
     */
    public int getNegotiatedSessionKey() {
        return this.sessionKey;
    }

    /**
     * {@inheritDoc}
     *

var errInvalidMaxParts = errors.New("Part number is greater than the maximum allowed 10000 parts")

// error returned for session policies > 2048
var errSessionPolicyTooLarge = errors.New("Session policy should not exceed 2048 characters")

// error returned in SFTP when user used public key without certificate

            extraSteps = extraBuildSteps,
            preSteps = preBuildSteps,
        )

        failureConditions {
            // JavaExecDebugIntegrationTest.debug session fails without debugger might cause JVM crash
            // Some soak tests produce OOM exceptions
            // There are also random worker crashes for some tests.
            // We have test-retry to handle the crash in tests

 * <p>
 * Built-in scopes include:
 * <ul>
 *   <li>{@link Singleton} - One instance per container</li>
 *   <li>{@link SessionScoped} - One instance per Maven session</li>
 *   <li>{@link MojoExecutionScoped} - One instance per plugin execution</li>
 * </ul>
 *
 * @see Singleton
 * @see SessionScoped
 * @see MojoExecutionScoped
 * @since 4.0.0
 */
@Target(ANNOTATION_TYPE)