this.capabilities &= this.server.scapabilities;
        if ((this.server.scapabilities & SmbConstants.CAP_EXTENDED_SECURITY) == SmbConstants.CAP_EXTENDED_SECURITY) {
            this.capabilities |= SmbConstants.CAP_EXTENDED_SECURITY; // & doesn't copy high bit
        }

        if (ctx.getConfig().isUseUnicode() || ctx.getConfig().isForceUnicode()) {

        }
        snd_buf_size = Math.min(snd_buf_size, server.maxBufferSize);
        capabilities &= server.capabilities;
        if ((server.capabilities & CAP_EXTENDED_SECURITY) == CAP_EXTENDED_SECURITY) {
            capabilities |= CAP_EXTENDED_SECURITY; // & doesn't copy high bit
        }

        if ((capabilities & SmbConstants.CAP_UNICODE) == 0) {
            // server doesn't want unicode

    }

    @Test
    public void testReadBytesWireFormatWithExtendedSecurity() {
        response.getServerData().scapabilities = SmbConstants.CAP_EXTENDED_SECURITY;
        // Use reflection to set protected byteCount field
        int byteCountValue = 16 + 10; // guid + token
        setByteCount(response, byteCountValue);
        byte[] buffer = new byte[byteCountValue];

        assertEquals(0x1000, SmbConstants.CAP_DFS);
        assertEquals(0x4000, SmbConstants.CAP_LARGE_READX);
        assertEquals(0x8000, SmbConstants.CAP_LARGE_WRITEX);
        assertEquals(0x80000000, SmbConstants.CAP_EXTENDED_SECURITY);
    }

    @Test
    @DisplayName("Should define file attribute constants")
    void testFileAttributes() {
        assertEquals(0x01, SmbConstants.ATTR_READONLY);

    int CAP_LOCK_AND_READ = 0x0100;
    /** NT find capability */
    int CAP_NT_FIND = 0x0200;
    /** DFS capability */
    int CAP_DFS = 0x1000;
    /** Extended security capability */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /** Read-only file attribute */
    int ATTR_READONLY = 0x01;
    /** Hidden file attribute */
    int ATTR_HIDDEN = 0x02;

    /**
     * Large write operations are supported capability.
     */
    int CAP_LARGE_WRITEX = 0x8000;
    /**
     * Extended security exchanges are supported capability.
     */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /**
     * File is marked read-only
     */
    int ATTR_READONLY = 0x01;
    /**
     * File is marked hidden
     */

        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_STATUS32) != 0);
        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_EXTENDED_SECURITY) != 0);
        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_LARGE_READX) != 0);
        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_LARGE_WRITEX) != 0);

                do {
                    switch (state) {
                    case 10: /* NTLM */
                        if (auth != NtlmPasswordAuthentication.ANONYMOUS && transport.hasCapability(SmbConstants.CAP_EXTENDED_SECURITY)) {
                            state = 20; /* NTLMSSP */
                            break;
                        }

                        request = new SmbComSessionSetupAndX(this, andx, auth);

            this.capabilities = (this.useNTSmbs ? SmbConstants.CAP_NT_SMBS : 0) | (this.useNtStatus ? SmbConstants.CAP_STATUS32 : 0)
                    | (this.useExtendedSecurity ? SmbConstants.CAP_EXTENDED_SECURITY : 0)
                    | (this.useLargeReadWrite ? SmbConstants.CAP_LARGE_READX : 0)
                    | (this.useLargeReadWrite ? SmbConstants.CAP_LARGE_WRITEX : 0) | (this.useUnicode ? SmbConstants.CAP_UNICODE : 0);