this.useUnicode = true;
            } else {
                this.useUnicode = false;
                this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_UNICODE;
            }
        } else {
            this.useUnicode = ctx.getConfig().isUseUnicode();
        }

        if (this.useUnicode) {
            log.debug("Unicode is enabled");
        } else {

    public void testBatchLimitForDifferentCommands() throws CIFSException {
        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.useBatching", "true");
        props.setProperty("jcifs.smb.client.useUnicode", "true");

        PropertyConfiguration config = new PropertyConfiguration(props);

        // Test various command batch limits
        int readAndXClose = config.getBatchLimit("ReadAndX.Close");

     * @return the useUnicode
     */
    public final boolean isUseUnicode() {
        return this.useUnicode;
    }

    /**
     * Sets whether to use Unicode encoding for this message
     * @param useUnicode
     *            the useUnicode to set
     */
    public final void setUseUnicode(final boolean useUnicode) {
        this.useUnicode = useUnicode;
    }

    /**

        nativeLanMan = readString(buffer, bufferIndex, start + byteCount, 255, useUnicode);
        bufferIndex += stringWireLength(nativeLanMan, bufferIndex);
        if (!extendedSecurity) {
            primaryDomain = readString(buffer, bufferIndex, start + byteCount, 255, useUnicode);
            bufferIndex += stringWireLength(primaryDomain, bufferIndex);
        }

        return bufferIndex - start;

                    }
                } else if (DISABLE_PLAIN_TEXT_PASSWORDS) {
                    throw new RuntimeException("Plain text passwords are disabled");
                } else if (useUnicode) {
                    // plain text
                    final String password = auth.getPassword();
                    lmHash = new byte[0];
                    ntHash = new byte[(password.length() + 1) * 2];

    int writeString(final String str, final byte[] dst, final int dstIndex) {
        return writeString(str, dst, dstIndex, useUnicode);
    }

    int writeString(final String str, final byte[] dst, int dstIndex, final boolean useUnicode) {
        final int start = dstIndex;

        try {
            if (useUnicode) {
                // Unicode requires word alignment
                if ((dstIndex - headerStart) % 2 != 0) {

    @DisplayName("Should parse boolean properties correctly")
    void testBooleanProperties() throws CIFSException {
        // Given
        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.useUnicode", "true");
        props.setProperty("jcifs.smb.client.disablePlainTextPasswords", "false");
        props.setProperty("jcifs.util.loglevel", "1");

        // When

    protected SecureRandom random;
    /** Whether to use command batching for improved performance */
    protected boolean useBatching = false;
    /** Whether to use Unicode encoding for strings */
    protected boolean useUnicode = true;
    /** Force use of Unicode encoding regardless of negotiation */
    protected boolean forceUnicode = false;
    /** Whether SMB signing is preferred but not required */
    protected boolean signingPreferred = false;

        assertTrue(next.writeParamCalls > 0, "chained SMB parameter words should be written");
        assertTrue(next.writeBytesCalls > 0, "chained SMB bytes should be written");
    }

    @Test
    @DisplayName("decode basic AndX block with no chaining")
    void testDecodeBasicNoAndx() {
        DummyAndXBlock block = new DummyAndXBlock() {

        byte[] dst = new byte[100];
        smbComRename = new SmbComRename(config, oldFileName, newFileName);

        // Set unicode to false
        Field useUnicodeField = ServerMessageBlock.class.getDeclaredField("useUnicode");
        useUnicodeField.setAccessible(true);
        useUnicodeField.setBoolean(smbComRename, false);

        int dstIndex = 0;

        // When