* Returns the {@code char} value that is equal to {@code value}, if possible.
   *
   * @param value any value in the range of the {@code char} type
   * @return the {@code char} value that equals {@code value}
   * @throws IllegalArgumentException if {@code value} is greater than {@link Character#MAX_VALUE}
   *     or less than {@link Character#MIN_VALUE}
   */
  public static char checkedCast(long value) {
    char result = (char) value;

   * Returns the {@code char} value that is equal to {@code value}, if possible.
   *
   * @param value any value in the range of the {@code char} type
   * @return the {@code char} value that equals {@code value}
   * @throws IllegalArgumentException if {@code value} is greater than {@link Character#MAX_VALUE}
   *     or less than {@link Character#MIN_VALUE}
   */
  public static char checkedCast(long value) {
    char result = (char) value;

    }

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

        .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},

        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 <= '０') {

        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.

        assertEquals("000", Hexdump.toHexString(data1, 0, 3)); // 3 chars = 1.5 bytes (rounds up to 2)
        assertEquals("0001", Hexdump.toHexString(data1, 0, 4)); // 4 chars = 2 bytes
        assertEquals("000102", Hexdump.toHexString(data1, 0, 6)); // 6 chars = 3 bytes
        assertEquals("00010203", Hexdump.toHexString(data1, 0, 8)); // 8 chars = 4 bytes

    String allMatchingChars = allMatchingChars(bitSet);
    char[] result = new char[STRING_LENGTH];
    // Fill with matching chars.
    for (int i = 0; i < result.length; i++) {
      result[i] = allMatchingChars.charAt(random.nextInt(allMatchingChars.length()));
    }
    // Replace some of chars by non-matching.
    int remaining = (int) ((100 - percentMatching) * result.length / 100.0 + 0.5);
    while (remaining > 0) {

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

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