}
      }
      return chars.subSequence(0, l + 1);
    }

    @Override
    public boolean canDecode(CharSequence chars) {
      checkNotNull(chars);
      chars = trimTrailingPadding(chars);
      if (!alphabet.isValidPaddingStartPosition(chars.length())) {
        return false;
      }
      for (int i = 0; i < chars.length(); i++) {
        if (!alphabet.canDecode(chars.charAt(i))) {
          return false;

        .isEqualTo(1);
    assertThat(
            Chars.indexOf(
                new char[] {(char) 2, (char) 3, (char) 2, (char) 3, (char) 4, (char) 2, (char) 3},
                new char[] {(char) 2, (char) 3, (char) 4}))
        .isEqualTo(2);
    assertThat(
            Chars.indexOf(
                new char[] {(char) 2, (char) 2, (char) 3, (char) 4, (char) 2, (char) 3, (char) 4},

            return null;
        }
        final char[] chars = new char[text.length()];
        for (int i = 0; i < chars.length; i++) {
            final char c = text.charAt(i);
            if (c >= 'ａ' && c <= 'ｚ') {
                chars[i] = (char) (c - 'ａ' + 'a');
            } else if (c >= 'Ａ' && c <= 'Ｚ') {
                chars[i] = (char) (c - 'Ａ' + 'A');
            } else if (c >= '０' && c <= '９') {

    }

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

            char charA = (i < a.length) ? a[i] : '\0';
            char charB = (i < b.length) ? b[i] : '\0';
            result &= (charA == charB) ? 1 : 0;
        }

        return result == 1;
    }

    /** The authentication type */
    private AuthenticationType type;
    /** The authentication domain */
    private String domain;
    /** The username for authentication */

        if (isEmpty(name)) {
            return name;
        }
        final char[] chars = name.toCharArray();
        if (chars.length >= 2 && Character.isUpperCase(chars[0]) && Character.isUpperCase(chars[1])) {
            return name;
        }
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }

    /**
     * Capitalizes a string according to JavaBeans conventions.

    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));
      return charactersOf(String.copyValueOf(chars));
    }
  }

  public static class CharactersOfCharSequenceGenerator extends TestCharacterListGenerator {
    @Override
    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));

    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));
      return charactersOf(String.copyValueOf(chars));
    }
  }

  public static class CharactersOfCharSequenceGenerator extends TestCharacterListGenerator {
    @Override
    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));

  static long copyReaderToBuilder(Reader from, StringBuilder to) throws IOException {
    checkNotNull(from);
    checkNotNull(to);
    char[] buf = new char[DEFAULT_BUF_SIZE];
    int nRead;
    long total = 0;
    while ((nRead = from.read(buf)) != -1) {
      to.append(buf, 0, nRead);
      total += nRead;
    }
    return total;
  }

  /**

        assertNull(StringUtil.newStringUnsafe(null));
        char[] chars = new char[0];
        assertThat(StringUtil.newStringUnsafe(chars), is(""));
        chars = new char[] { 'a', 'b', 'c' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc"));
        chars = new char[] { 'a', 'b', 'c', ' ' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc "));
    }