// 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() {

        }
    }

    @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();

        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";

     * @param dstIndex the starting offset in the buffer
     * @param unicode true to use Unicode encoding, false for OEM encoding
     * @return the number of bytes written
     */
    protected int writeString(final String str, final byte[] dst, int dstIndex, final boolean unicode) {
        final int start = dstIndex;
        if (unicode) {
            // Unicode requires word alignment

        }
    }

    @Nested
    @DisplayName("Unicode Support Tests")
    class UnicodeSupportTests {

        @Test
        @DisplayName("Should always force unicode")
        void testIsForceUnicode() {
            assertTrue(response.isForceUnicode());
        }

        @Test
        @DisplayName("Should consistently return true for unicode")
        void testIsForceUnicodeMultipleCalls() {

        // Domain (12 bytes "DOMAIN" in Unicode at offset 112)
        message[28] = 12; // Length
        message[29] = 0;
        message[30] = 12; // Max Length
        message[31] = 0;
        message[32] = 112; // Offset
        message[33] = 0;
        message[34] = 0;
        message[35] = 0;

        // User (8 bytes "user" in Unicode at offset 124)
        message[36] = 8; // Length

            for (int _i = 0; _i < _uuid_nodes; _i++) {
                this.uuid.node[_i] = (byte) _src.dec_ndr_small();
            }
        }
    }

    /**
     * Unicode string structure for DCE/RPC operations.
     * Represents a Unicode string with length information.
     */
    public static class unicode_string extends NdrObject {

        /**
         * Default constructor for unicode_string.
         */

    /** Receive buffer size in bytes */
    int RCV_BUF_SIZE = Config.getInt("jcifs.smb1.smb.client.rcv_buf_size", DEFAULT_RCV_BUF_SIZE);
    /** Whether to use Unicode strings */
    boolean USE_UNICODE = Config.getBoolean("jcifs.smb1.smb.client.useUnicode", true);
    /** Whether to force Unicode usage */
    boolean FORCE_UNICODE = Config.getBoolean("jcifs.smb1.smb.client.useUnicode", false);
    /** Whether to use NT status codes */