*/
@GwtCompatible
public final class Iterables {
  private Iterables() {}

  /** Returns an unmodifiable view of {@code iterable}. */
  public static <T extends @Nullable Object> Iterable<T> unmodifiableIterable(
      Iterable<? extends T> iterable) {
    checkNotNull(iterable);
    if (iterable instanceof UnmodifiableIterable || iterable instanceof ImmutableCollection) {

   * this method returns {@code true} if {@code iterable1} and {@code iterable2} contain the same
   * number of elements and every element of {@code iterable1} is equal to the corresponding element
   * of {@code iterable2}.
   */
  public static boolean elementsEqual(Iterable<?> iterable1, Iterable<?> iterable2) {
    if (iterable1 instanceof Collection && iterable2 instanceof Collection) {

    /**
     * Returns an {@link Iterable} that wraps the array for use in a for-each statement.
     *
     * @param <T> the type of elements
     * @param items the array of elements to iterate (must not be {@literal null})
     * @return an {@link Iterable} wrapping the array
     */
    public static <T> Iterable<T> iterable(final T... items) {
        assertArgumentNotNull("items", items);

public final class MinimalIterable<E extends @Nullable Object> implements Iterable<E> {
  /** Returns an iterable whose iterator returns the given elements in order. */
  public static <E extends @Nullable Object> MinimalIterable<E> of(E... elements) {
    // Make sure to get an unmodifiable iterator
    return new MinimalIterable<>(asList(elements).iterator());
  }

  /**

    /**
     * Returns an {@link Iterable} that wraps a {@link ClassIterator} for use in a for-each statement.
     *
     * @param clazz the class (must not be {@literal null})
     * @return an {@link Iterable} wrapping a {@link ClassIterator}
     */
    public static Iterable<Class<?>> iterable(final Class<?> clazz) {
        return iterable(clazz, true);
    }

    /**

    }

    /**
     * Returns an {@link Iterable} that wraps a {@link LineIterator} for use in enhanced for-loops.
     *
     * @param reader
     *            The {@link BufferedReader} to read strings from. Must not be {@literal null}.
     * @return An {@link Iterable} that wraps a {@link LineIterator}.
     */
    public static Iterable<String> iterable(final BufferedReader reader) {

  }

  private void testGetOnAbc(Iterable<String> iterable) {
    try {
      Iterables.get(iterable, -1);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    assertEquals("a", Iterables.get(iterable, 0));
    assertEquals("b", Iterables.get(iterable, 1));
    assertEquals("c", Iterables.get(iterable, 2));
    try {
      Iterables.get(iterable, 3);
      fail();

import java.util.Iterator;

/**
 * Adapts a test iterable generator to give a TestIteratorGenerator.
 *
 * @author George van den Driessche
 */
@GwtCompatible
public final class DerivedTestIteratorGenerator<E>
    implements TestIteratorGenerator<E>, DerivedGenerator {
  private final TestSubjectGenerator<? extends Iterable<E>> collectionGenerator;

  public DerivedTestIteratorGenerator(

    /**
     * Returns an {@link Iterable} that wraps a {@link SingleValueIterator} for use in a for-each statement.
     *
     * @param <E> the element type
     * @param value the single value returned by the iterator
     * @return an {@link Iterable} wrapping a {@link SingleValueIterator}
     */
    public static <E> Iterable<E> iterable(final E value) {
        return () -> new SingleValueIterator<>(value);

    multimap().putAll(k0(), Collections.<V>emptyList());
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllOnlyCallsIteratorOnce() {
    Iterable<V> iterable =
        new Iterable<V>() {
          private boolean calledIteratorAlready = false;

          @Override
          public Iterator<V> iterator() {
            checkState(!calledIteratorAlready);