verify(session).setAttribute("ntlmuser", "user");
            verify(session).setAttribute("ntlmdomain", "TEST_DOMAIN");

            // Verify that the chain continues
            verify(response, never()).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        }
    }

    /**
     * Test the service method with NTLM authentication that fails.

        return selectedHashAlgorithm;
    }

    /**
     * Calculates hash according to SMB 3.1.1 preauth integrity specification.
     *
     * @param previousHash the previous hash in the chain
     * @param messageData the message data to hash
     * @param hashAlgorithm the hash algorithm to use
     * @return the new hash
     * @throws CIFSException if hash calculation fails
     */

   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *

     * a line containing the cipher suite. Next is the length of the peer certificate chain. These
     * certificates are base64-encoded and appear each on their own line. The next line contains the
     * length of the local certificate chain. These certificates are also base64-encoded and appear
     * each on their own line. A length of -1 is used to encode a null array. The last line is

    `HandshakeCertificates` holds the TLS certificates required for a TLS handshake. On the server
    it keeps your `HeldCertificate` and its chain. On the client it keeps the root certificates
    that are trusted to sign a server's certificate chain. `HandshakeCertificates` also works with
    mutual TLS where these roles are reversed.

                .findFirst()
                .orElseThrow(() -> new AssertionError("Custom resource not found"));

        // Verify targetPath was preserved through conversion chain
        assertEquals(
                "custom-output", customResource.getTargetPath(), "targetPath should be preserved in ConnectedResource");

        assertEquals(1, notifications.size());
        assertEquals(action, notifications.get(0).getAction());
    }

    @Test
    @DisplayName("Should handle notification chain with alignment")
    void testNotificationChainAlignment() throws Exception {
        // Given - notifications must be 4-byte aligned
        byte[] buffer = new byte[1024];
        int offset = 0;

        Exception level1 = new IOException("Level 1", level2);
        CrawlerSystemException topLevel = new CrawlerSystemException("Top level", level1);

        // Verify chain
        assertSame(level1, topLevel.getCause());
        assertSame(level2, topLevel.getCause().getCause());
        assertSame(level3, topLevel.getCause().getCause().getCause());

        // Test constructor with config and andx
        TestAndXServerMessageBlock block3 = new TestAndXServerMessageBlock(mockConfig) {
            {
                // Set andx via constructor chain
                super.setCommand((byte) 0x25);
            }
        };
        assertNotNull(block3);
    }

      object : X509TrustManager {
        @Throws(CertificateException::class)
        override fun checkClientTrusted(
          chain: Array<X509Certificate>,
          authType: String,
        ) = throw CertificateException()

        override fun checkServerTrusted(
          chain: Array<X509Certificate>,
          authType: String,
        ) = throw AssertionError()