@SuppressWarnings("rawtypes") // the purpose is to test raw type
    Invokable<?, Iterable> delegate =
        Prepender.method("prepend", String.class, Iterable.class).returning(Iterable.class);
    assertEquals(new TypeToken<Iterable<String>>() {}, delegate.getReturnType());
    @SuppressWarnings("unchecked") // prepend() returns Iterable<String>
    Iterable<String> result = delegate.invoke(null, "a", ImmutableList.of("b", "c"));

    @SuppressWarnings("rawtypes") // the purpose is to test raw type
    Invokable<?, Iterable> delegate =
        Prepender.method("prepend", String.class, Iterable.class).returning(Iterable.class);
    assertEquals(new TypeToken<Iterable<String>>() {}, delegate.getReturnType());
    @SuppressWarnings("unchecked") // prepend() returns Iterable<String>
    Iterable<String> result = delegate.invoke(null, "a", ImmutableList.of("b", "c"));

public final class IterablesFilterArrayListTest
    extends AbstractFilteredIterableTest<Iterable<Integer>> {
  @Override
  Iterable<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Iterable<Integer> filter(Iterable<Integer> elements, Predicate<? super Integer> predicate) {
    return Iterables.filter(elements, predicate);
  }

public final class IterablesFilterArrayListTest
    extends AbstractFilteredIterableTest<Iterable<Integer>> {
  @Override
  Iterable<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Iterable<Integer> filter(Iterable<Integer> elements, Predicate<? super Integer> predicate) {
    return Iterables.filter(elements, predicate);
  }

  }

  public void testCharacterSimpleSplitWithNoDelimiter() {
    String simple = "a,b,c";
    Iterable<String> letters = Splitter.on('.').split(simple);
    assertThat(letters).containsExactly("a,b,c").inOrder();
  }

  public void testCharacterSplitWithDoubleDelimiter() {
    String doubled = "a,,b,c";
    Iterable<String> letters = COMMA_SPLITTER.split(doubled);
    assertThat(letters).containsExactly("a", "", "b", "c").inOrder();

   * they are returned by the iterable's iterator.
   *
   * @since 12.0
   */
  public static <E> ArrayDeque<E> newArrayDeque(Iterable<? extends E> elements) {
    if (elements instanceof Collection) {
      return new ArrayDeque<>((Collection<? extends E>) elements);
    }
    ArrayDeque<E> deque = new ArrayDeque<>();
    Iterables.addAll(deque, elements);
    return deque;

   * they are returned by the iterable's iterator.
   *
   * @since 12.0
   */
  public static <E> ArrayDeque<E> newArrayDeque(Iterable<? extends E> elements) {
    if (elements instanceof Collection) {
      return new ArrayDeque<>((Collection<? extends E>) elements);
    }
    ArrayDeque<E> deque = new ArrayDeque<>();
    Iterables.addAll(deque, elements);
    return deque;

  // Ordering<Iterable<String>> o =
  //     Ordering.<String>natural().lexicographical();
  public <S extends T> Ordering<Iterable<S>> lexicographical() {
    /*
     * Note that technically the returned ordering should be capable of
     * handling not just {@code Iterable<S>} instances, but also any {@code
     * Iterable<? extends S>}. However, the need for this comes up so rarely

    @SuppressWarnings("rawtypes") // Iterable.class
    TypeToken<? extends Iterable> genericType = TypeToken.toGenericType(Iterable.class);
    assertEquals(Iterable.class, genericType.getRawType());
    assertEquals(
        Types.newParameterizedType(Iterable.class, Iterable.class.getTypeParameters()[0]),
        genericType.getType());
  }

  public void testOf_empty() {
    Iterable<String> iterable = MinimalIterable.<String>of();
    Iterator<String> iterator = iterable.iterator();
    assertFalse(iterator.hasNext());
    assertThrows(NoSuchElementException.class, () -> iterator.next());
    assertThrows(IllegalStateException.class, () -> iterable.iterator());
  }

  public void testOf_one() {
    Iterable<String> iterable = MinimalIterable.of("a");