implements Serializable {
  final Equivalence<E> elementEquivalence;

  PairwiseEquivalence(Equivalence<E> elementEquivalence) {
    this.elementEquivalence = Preconditions.checkNotNull(elementEquivalence);
  }

  @Override
  protected boolean doEquivalent(Iterable<T> iterableA, Iterable<T> iterableB) {
    Iterator<T> iteratorA = iterableA.iterator();

     *
     * @param <E>
     *            要素の型
     * @param iterables
     *            {@link Iterable}の並び。{@literal null}であってはいけません
     * @return {@link MultiIterator}をラップした{@link Iterable}
     */
    public static <E> Iterable<E> iterable(final Iterable<E>... iterables) {
        assertArgumentNotNull("iterables", iterables);

        @SuppressWarnings("unchecked")

public class MinimalIterableTest extends TestCase {

  public void testOf_empty() {
    Iterable<String> iterable = MinimalIterable.<String>of();
    Iterator<String> iterator = iterable.iterator();
    assertFalse(iterator.hasNext());
    try {
      iterator.next();
      fail();
    } catch (NoSuchElementException expected) {
    }
    try {
      iterable.iterator();
      fail();
    } catch (IllegalStateException expected) {
    }

     *
     * @param <T>
     *            {@link Iterable}の要素型
     * @param iterable
     *            {@link Iterable}。{@literal null}であってはいけません
     * @return {@link IndexedIterator}をラップした{@link Iterable}
     */
    public static <T> Iterable<Indexed<T>> indexed(final Iterable<T> iterable) {
        assertArgumentNotNull("iterable", iterable);

    /**
     * for each構文で使用するために{@link LineIterator}をラップした{@link Iterable}を返します。
     *
     * @param reader
     *            文字列を読み込む{@link Reader}。{@literal null}であってはいけません
     * @return {@link LineIterator}をラップした{@link Iterable}
     */
    public static Iterable<String> iterable(final Reader reader) {
        assertArgumentNotNull("reader", reader);
        return iterable(new BufferedReader(reader));
    }

    /**

    implements Serializable {
  final Equivalence<E> elementEquivalence;

  PairwiseEquivalence(Equivalence<E> elementEquivalence) {
    this.elementEquivalence = Preconditions.checkNotNull(elementEquivalence);
  }

  @Override
  protected boolean doEquivalent(Iterable<T> iterableA, Iterable<T> iterableB) {
    Iterator<T> iteratorA = iterableA.iterator();

    return 0;
  }

  @Override
  public <E extends @Nullable Object> List<E> sortedCopy(Iterable<E> iterable) {
    return Lists.newArrayList(iterable);
  }

  @Override
  public <E> ImmutableList<E> immutableSortedCopy(Iterable<E> iterable) {
    return ImmutableList.copyOf(iterable);
  }

  @SuppressWarnings("unchecked")
  @Override
  public <S extends @Nullable Object> Ordering<S> reverse() {

    return 0;
  }

  @Override
  public <E extends @Nullable Object> List<E> sortedCopy(Iterable<E> iterable) {
    return Lists.newArrayList(iterable);
  }

  @Override
  public <E> ImmutableList<E> immutableSortedCopy(Iterable<E> iterable) {
    return ImmutableList.copyOf(iterable);
  }

  @SuppressWarnings("unchecked")
  @Override
  public <S extends @Nullable Object> Ordering<S> reverse() {

public class MinimalIterableTest extends TestCase {

  public void testOf_empty() {
    Iterable<String> iterable = MinimalIterable.<String>of();
    Iterator<String> iterator = iterable.iterator();
    assertFalse(iterator.hasNext());
    try {
      iterator.next();
      fail();
    } catch (NoSuchElementException expected) {
    }
    try {
      iterable.iterator();
      fail();
    } catch (IllegalStateException expected) {
    }

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