assertTrue(treeConnectCreate >= 0, "TreeConnectAndX.CreateDirectory batch limit should be non-negative");
    }

    /**
     * Test that batch limit respects Unicode settings
     */
    @Test
    @DisplayName("Batch limit configuration with Unicode enabled")
    public void testBatchLimitWithUnicodeEnabled() throws CIFSException {
        Properties props = new Properties();

            // When even alignment (offset 2), Unicode string starts immediately
            assertTrue(bytesWritten >= 8); // "Test" in Unicode + null terminator
            // First byte should be 'T' in UTF-16LE
            assertEquals(0x54, buffer[2] & 0xFF);
        }

        @Test
        @DisplayName("Test read string with odd Unicode alignment")
        void testReadStringUnicodeAlignment() {

        // Test Unicode configuration is enabled by default
        assertTrue(cfg.isUseUnicode(), "Unicode should be enabled by default");
    }

    @Test
    public void testAsciiConfiguration() throws Exception {
        Configuration asciiCfg = new OffUnicodeConfig();
        assertFalse(asciiCfg.isUseUnicode(), "Unicode should be disabled in ASCII config");
    }

    @Test

        }
    }

    @Nested
    @DisplayName("Unicode String Tests")
    class UnicodeStringTests {

        @Test
        @DisplayName("Should encode unicode string with null buffer correctly")
        void testUnicodeStringEncodeNullBuffer() throws NdrException {
            // Given: A unicode string with null buffer
            rpc.unicode_string unicodeString = new rpc.unicode_string();

    private final Configuration config;
    private final boolean unicode;

    /**
     * Constructs a file both directory info.
     *
     * @param config the configuration
     * @param unicode whether to use unicode encoding
     */
    public FileBothDirectoryInfo(final Configuration config, final boolean unicode) {
        this.config = config;
        this.unicode = unicode;
    }

    @Override
    public String getName() {

    /**
     * Encodes a string into UTF-16LE (Unicode Little Endian) bytes.
     *
     * @param str the string to encode
     * @return the string as bytes (UTF16-LE)
     */
    public static byte[] getUNIBytes(final String str) {
        return getBytes(str, UNI_ENCODING);
    }

    /**
     * Encodes a string into ASCII bytes.
     *
     * @param str the string to encode
     * @return the string as bytes (ASCII)
     */

        assertEquals(expectedNextEntryOffset, fileBothDirectoryInfo.getNextEntryOffset());
    }

    @Test
    @DisplayName("Test decode with Unicode filename")
    void testDecodeWithUnicodeFilename() throws SMBProtocolDecodingException {
        // Prepare test data with Unicode filename
        String expectedFilename = "日本語ファイル.txt";
        byte[] buffer = createValidBuffer(expectedFilename, "~1.TXT", true);

        // Decode

            }
        } else {
            this.useUnicode = ctx.getConfig().isUseUnicode();
        }

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

    /**
     * {@inheritDoc}
     *

        assertEquals((byte) 0x04, dst[secondBufferFormatIndex]);
    }

    /**
     * Test writeBytesWireFormat with Unicode encoding
     */
    @Test
    @DisplayName("Test writeBytesWireFormat writes file names correctly in Unicode")
    public void testWriteBytesWireFormatUnicode() throws Exception {
        // Given
        String oldFileName = "oldFile.txt";

            if (useUnicode) {
                // should Unicode alignment be corrected for here?
                str = new String(src, srcIndex, len, UNI_ENCODING);
            } else {

                /* On NT without Unicode the fileNameLength
                 * includes the '\0' whereas on win98 it doesn't. I
                 * guess most clients only support non-unicode so
                 * they don't run into this.