*/
    private byte[] encodeUnicode(String s) {
        char[] chars = s.toCharArray();
        byte[] out = new byte[chars.length * 2];
        for (int i = 0; i < chars.length; i++) {
            out[2 * i] = (byte) (chars[i] & 0xFF);
            out[2 * i + 1] = (byte) ((chars[i] >> 8) & 0xFF);
        }
        return out;
    }

    /**

        // Test extended ASCII characters (not valid URL chars without encoding)
        assertFalse(CharUtil.isUrlChar('\u00A0')); // non-breaking space
        assertFalse(CharUtil.isUrlChar('\u00FF')); // ÿ
    }

    public void test_isUrlChar_unicode() {
        // Test Unicode characters (not valid URL chars without encoding)
        assertFalse(CharUtil.isUrlChar('\u3042')); // あ (Hiragana)

        String result = Hexdump.toHexString(data);
        assertEquals(2048, result.length()); // 1024 bytes * 2 chars

        // Test partial conversion
        String partial = Hexdump.toHexString(data, 512, 256);
        assertEquals(512, partial.length()); // 256 bytes * 2 chars
        assertTrue(partial.startsWith("00010203")); // 512 % 256 = 0, so starts at 0
    }

    @CsvSource({ "a.txt", "very_long_filename_with_many_characters_to_test_buffer_handling.docx", "file with spaces.pdf", "文件.txt", // Unicode filename
            "file-with-special-chars!@#$%^&().bin" })
    void testDecodeWithVariousFileNames(String fileName) throws SMBProtocolDecodingException {
        byte[] buffer = createValidNotificationBuffer(fileName, FileNotifyInformation.FILE_ACTION_ADDED);

        Arrays.fill(decrypted, '\0');
    }

    @Test
    public void testEncryptDecryptEmpty() throws Exception {
        char[] plaintext = new char[0];

        byte[] encrypted = storage.encryptCredentials(plaintext);
        assertNotNull(encrypted, "Encrypted empty data should not be null");

        char[] decrypted = storage.decryptCredentials(encrypted);
        assertNotNull(decrypted, "Decrypted empty data should not be null");

    /** WAVE DASH */
    public static final char WAVE_DASH = '\u301C';

    /** FULLWIDTH TILDE */
    public static final char FULLWIDTH_TILDE = '\uFF5E';

    /** DOUBLE VERTICAL LINE */
    public static final char DOUBLE_VERTICAL_LINE = '\u2016';

    /** PARALLEL TO */
    public static final char PARALLEL_TO = '\u2225';

    /** MINUS SIGN */
    public static final char MINUS_SIGN = '\u2212';

        raf.writeBytes("hi");
        raf.writeChars("yo");

        verify(raf).write(any(byte[].class), eq(0), eq(2)); // bytes
        verify(raf).write(any(byte[].class), eq(0), eq(4)); // chars
    }

    @Test
    @DisplayName("writeUTF(): prefixes size and writes encoded bytes")
    void writeUTF_encodesAndPrefixes() throws Exception {

    default char[] getQueryHighlightBoundaryCharsAsArray() {
        final int[] values = getCrawlerDocumentCharsAsArray(QUERY_HIGHLIGHT_BOUNDARY_CHARS, getQueryHighlightBoundaryChars());
        final char[] chars = new char[values.length];
        for (int i = 0; i < values.length; i++) {
            chars[i] = (char) values[i];
        }
        return chars;
    }

    }

    /**
     * Generates the NT password hash for the given password.
     * This version accepts char[] for better security.
     *
     * @param password the password to hash as char array
     * @return nt password hash
     */
    public static byte[] getNTHash(final char[] password) {
        if (password == null) {
            throw new NullPointerException("Password parameter is required");

        if (length == 0) {
            return;
        }

        final int s = length % 16;
        final int r = s == 0 ? length / 16 : length / 16 + 1;
        final char[] c = new char[r * (74 + NL_LENGTH)];
        final char[] d = new char[16];
        int i;
        int si = 0;
        int ci = 0;

        do {
            toHexChars(si, c, ci, 5);
            ci += 5;
            c[ci] = ':';