Field passwordField = NtlmPasswordAuthenticator.class.getDeclaredField("password");
        passwordField.setAccessible(true);

        char[] originalPassword = (char[]) passwordField.get(authenticator);
        char[] clonedPassword = (char[]) passwordField.get(cloned);

        assertNotSame(originalPassword, clonedPassword, "Cloned password should be a different array instance");

    }

    /**
     * Test password in equals method
     */
    @Test
    public void testEqualsWithSecurePassword() {
        char[] password1 = "TestPass123!".toCharArray();
        char[] password2 = "TestPass123!".toCharArray();
        char[] password3 = "DifferentPass!".toCharArray();

        NtlmPasswordAuthenticator auth1 = new NtlmPasswordAuthenticator("DOMAIN", "user", password1);

                return "u0020u3000";
            }
        };

        int[] chars = fessConfig.getCrawlerDocumentSpaceCharsAsArray();
        assertEquals(2, chars.length);
        assertEquals(32, chars[0]);
        assertEquals(12288, chars[1]);
    }

    public void test_getCrawlerDocumentFullstopCharsAsArray() {
        FessProp.propMap.clear();

      }
    }
  }

  private static String mikeRepeat(String string, int count) {
    int len = string.length();
    char[] strCopy = new char[len * Integer.highestOneBit(count)];
    string.getChars(0, len, strCopy, 0);

    char[] array = new char[len * count];

    int strCopyLen = len;
    int pos = 0;
    while (count != 0) {
      if ((count & 1) != 0) {

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

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

            return "";
        }
        final int mod = inData.length % 3;
        final int num = inData.length / 3;
        char[] outData = null;
        if (mod != 0) {
            outData = new char[(num + 1) * 4];
        } else {
            outData = new char[num * 4];
        }
        for (int i = 0; i < num; i++) {
            encode(inData, i * 3, outData, i * 4);
        }
        if (mod == 1) {

    // read char by char
    CharSequenceReader reader = new CharSequenceReader(charSequence);
    for (int i = 0; i < expected.length(); i++) {
      assertEquals(expected.charAt(i), reader.read());
    }
    assertFullyRead(reader);

    // read all to one array
    reader = new CharSequenceReader(charSequence);
    char[] buf = new char[expected.length()];

        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
    }

  private final char innerNodeCode;

  /** The character used for a leaf node in the trie encoding */
  private final char leafNodeCode;

  PublicSuffixType(char innerNodeCode, char leafNodeCode) {
    this.innerNodeCode = innerNodeCode;
    this.leafNodeCode = leafNodeCode;
  }

  char getLeafNodeCode() {
    return leafNodeCode;
  }

  char getInnerNodeCode() {
    return innerNodeCode;