final char originalChar1 = sb.charAt(i);
            final char originalChar2 = sb.charAt(i + 1);
            final char margedChar = mergeChar(originalChar1, originalChar2);
            if (margedChar != originalChar1) {
                sb.setCharAt(i, margedChar);
                sb.deleteCharAt(i + 1);
            } else {

    }

    /**
     * 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);

    }

    /**
     * Convert char array to byte array (UTF-8)
     */
    private byte[] charsToBytes(char[] chars) {
        if (chars == null) {
            return null;
        }

        // Use UTF-8 encoding
        byte[] bytes = new byte[chars.length * 3]; // Max 3 bytes per char in UTF-8
        int byteIndex = 0;

        for (char c : chars) {
            if (c < 0x80) {

     * @return the detected delimiter character
     */
    protected Character detectDelimiter(final String line) {
        final char[] candidates = { ',', '\t', ';', '|' };
        int maxCount = 0;
        char bestDelimiter = ',';

        for (final char candidate : candidates) {
            final int count = countOccurrences(line, candidate);
            if (count > maxCount) {

        assertNotNull(constantTimeMethod, "constantTimeEquals method should exist");
        constantTimeMethod.setAccessible(true);

        // Test the method directly
        char[] password1 = "testpassword".toCharArray();
        char[] password2 = "testpassword".toCharArray();
        char[] password3 = "testpassworX".toCharArray();

    private final BytesRef scratchBytes = new BytesRef();

    private final CharsRef scratchChars = new CharsRef();

    private int longestMatchEndOffset;

    private int ch;

    private final char[] readBuffer;

    private int readBufferIndex;

    private int readBufferLen;

    StringBuilder block;

    int blkStart;

    int nextBlkStart;

    private int finalOffset;

        assertEquals('N', (char) type2Bytes[0]);
        assertEquals('T', (char) type2Bytes[1]);
        assertEquals('L', (char) type2Bytes[2]);
        assertEquals('M', (char) type2Bytes[3]);
        assertEquals('S', (char) type2Bytes[4]);
        assertEquals('S', (char) type2Bytes[5]);
        assertEquals('P', (char) type2Bytes[6]);
        assertEquals(0, type2Bytes[7]); // Null terminator

            buffer[i] = (short) 0;
        }
    }

    @Override
    public String toString() {
        final int len = length / 2 - (zterm ? 1 : 0);
        final char[] ca = new char[len];
        for (int i = 0; i < len; i++) {
            ca[i] = (char) buffer[i];
        }
        return new String(ca, 0, len);
    }

        if (initialCapacity > 0 && initialCapacity <= MAX_BUF_SIZE) {
            bufferSize = initialCapacity;
        } else {
            bufferSize = DEFAULT_BUF_SIZE;
        }
        char[] buf = new char[bufferSize];
        int size = 0;
        int len;
        try {
            while ((len = reader.read(buf, size, bufferSize - size)) != -1) {
                size += len;

     */
    public static char[] addAll(final char[] a, final char[] b) {
        if (a == null) {
            return b;
        }
        if (b == null) {
            return a;
        }
        if (a.length == 0) {
            return b;
        }
        if (b.length == 0) {
            return a;
        }
        final char[] array = (char[]) Array.newInstance(char.class, a.length + b.length);