* @return CharSequence
         */
        public static CharSequence bbb() {
            return createCharSequence("bbb");
        }

        /**
         * @return CharSequence
         */
        public static CharSequence ccc() {
            return createCharSequence("ccc");
        }

        /**
         * @return CharSequence
         */
        public static CharSequence hoge() {

        assertArgumentNotEmpty("pattern", pattern);

        return converter(new NumberConverter(pattern), propertyNames);
    }

    /**
     * Converts an array of {@literal CharSequence} to a {@literal List} of {@literal String}.
     *
     * @param array
     *            An array of {@literal CharSequence}

    @DisplayName("Should handle StringBuilder as CharSequence")
    void testJoinWithStringBuilder() {
        StringBuilder sb1 = new StringBuilder("first");
        StringBuilder sb2 = new StringBuilder("second");
        String result = StringUtil.join(",", sb1, sb2);
        assertEquals("first,second", result);
    }

    @Test
    @DisplayName("Should handle StringBuffer as CharSequence")
    void testJoinWithStringBuffer() {

      checkNotNull(sequence);
      return "";
    }

    @Override
    public String replaceFrom(CharSequence sequence, char replacement) {
      char[] array = new char[sequence.length()];
      Arrays.fill(array, replacement);
      return new String(array);
    }

    @Override
    public String replaceFrom(CharSequence sequence, CharSequence replacement) {

   * {@code b} have no common prefix, returns the empty string.
   *
   * @since 11.0
   */
  public static String commonPrefix(CharSequence a, CharSequence b) {
    checkNotNull(a);
    checkNotNull(b);

    int maxPrefixLength = min(a.length(), b.length());
    int p = 0;
    while (p < maxPrefixLength && a.charAt(p) == b.charAt(p)) {
      p++;

   * the {@code charSequence} is mutated while it is being read, so don't do that.
   *
   * @since 15.0 (since 14.0 as {@code CharStreams.asCharSource(String)})
   */
  public static CharSource wrap(CharSequence charSequence) {
    return charSequence instanceof String
        ? new StringCharSource((String) charSequence)
        : new CharSequenceCharSource(charSequence);
  }

  /**

   * the {@code charSequence} is mutated while it is being read, so don't do that.
   *
   * @since 15.0 (since 14.0 as {@code CharStreams.asCharSource(String)})
   */
  public static CharSource wrap(CharSequence charSequence) {
    return charSequence instanceof String
        ? new StringCharSource((String) charSequence)
        : new CharSequenceCharSource(charSequence);
  }

  /**

    checkNotClosed();
    target.append(c);
    return this;
  }

  @Override
  public Writer append(@Nullable CharSequence charSeq) throws IOException {
    checkNotClosed();
    target.append(charSeq);
    return this;
  }

  @Override
  public Writer append(@Nullable CharSequence charSeq, int start, int end) throws IOException {
    checkNotClosed();
    target.append(charSeq, start, end);
    return this;

     * @param elements the elements to join
     * @return elements separated by delimiter
     */
    public static String join(final CharSequence delimiter, final CharSequence... elements) {
        final StringBuilder sb = new StringBuilder();
        for (final CharSequence element : elements) {
            if (sb.length() > 0) {
                if (delimiter != null) {
                    sb.append(delimiter);

        return str == null ? defaultStr : str;
    }

    /**
     * <p>Checks if the CharSequence contains only ASCII printable characters.</p>
     *
     * <p>{@code null} will return {@code false}.
     * An empty CharSequence (length()=0) will return {@code true}.</p>
     *
     * <pre>
     * StringUtils.isAsciiPrintable(null)     = false