return new Appendable() {

      @Override
      public Appendable append(CharSequence csq) throws IOException {
        a.append(csq);
        return this;
      }

      @Override
      public Appendable append(CharSequence csq, int start, int end) throws IOException {
        a.append(csq, start, end);
        return this;
      }

      @Override

    }
    if (cp >= safeMin && cp <= safeMax) {
      return null;
    }
    return escapeUnsafe(cp);
  }

  /* Overridden for performance. */
  @Override
  protected final int nextEscapeIndex(CharSequence csq, int index, int end) {
    while (index < end) {
      char c = csq.charAt(index);
      if ((c < replacementsLength && replacements[c] != null)
          || c > safeMaxChar
          || c < safeMinChar) {

  private static final Appendable NASTY_APPENDABLE =
      new Appendable() {
        @Override
        public Appendable append(@Nullable CharSequence csq) throws IOException {
          throw new IOException();
        }

        @Override
        public Appendable append(@Nullable CharSequence csq, int start, int end)
            throws IOException {
          throw new IOException();
        }

        @Override

    }

    private static boolean isEmpty(Object value) {
      // Put types estimated to be the most frequent first.
      if (value instanceof CharSequence) {
        return ((CharSequence) value).length() == 0;
      } else if (value instanceof Collection) {
        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {

  public void testRepeat_null() {
    assertThrows(NullPointerException.class, () -> Strings.repeat(null, 5));
  }

  @SuppressWarnings("UnnecessaryStringBuilder") // We want to test a non-String CharSequence
  public void testCommonPrefix() {
    assertEquals("", Strings.commonPrefix("", ""));
    assertEquals("", Strings.commonPrefix("abc", ""));
    assertEquals("", Strings.commonPrefix("", "abc"));

              @Override
              public Sub apply(Sub sub) {
                return new ForwardingSub(sub);
              }
            });
  }

  interface Base {
    CharSequence getId();
  }

  interface Sub extends Base {
    @Override
    String getId();
  }

  private static class ForwardingSub implements Sub {
    private final Sub delegate;

  public static TestSuite suite() {
    TestSuite suite = new TestSuite();
    for (boolean asByteSource : new boolean[] {false, true}) {
      suite.addTest(
          CharSourceTester.tests(
              "CharSource.wrap[CharSequence]",
              SourceSinkFactories.stringCharSourceFactory(),
              asByteSource));
      suite.addTest(
          CharSourceTester.tests(

    @Keep
    public void checkDefaultValuesForTheseTypes(
        Gender gender,
        Integer integer,
        int i,
        String string,
        CharSequence charSequence,
        List<String> list,
        ImmutableList<Integer> immutableList,
        Map<String, Integer> map,
        ImmutableMap<String, String> immutableMap,
        Set<String> set,

    assertEquals(-1, Iterables.indexOf(list, equalTo("jack")));
  }

  private static final Predicate<CharSequence> STARTSWITH_A =
      new Predicate<CharSequence>() {
        @Override
        public boolean apply(CharSequence input) {
          return (input.length() > 0) && (input.charAt(0) == 'a');
        }
      };

        Object writeReplace() {
      return super.writeReplace();
    }
  }

  private static final class CharSequenceAsList extends AbstractList<Character> {
    private final CharSequence sequence;

    CharSequenceAsList(CharSequence sequence) {
      this.sequence = sequence;
    }

    @Override
    public Character get(int index) {
      checkElementIndex(index, size()); // for GWT