return forCellsInternal(cells, rowComparator, columnComparator);
  }

  static <R, C, V> RegularImmutableTable<R, C, V> forCells(Iterable<Cell<R, C, V>> cells) {
    return forCellsInternal(cells, null, null);
  }

  private static <R, C, V> RegularImmutableTable<R, C, V> forCellsInternal(
      Iterable<Cell<R, C, V>> cells,
      @CheckForNull Comparator<? super R> rowComparator,

     *
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return {@link ClassIterator}をラップした{@link Iterable}
     */
    public static Iterable<Class<?>> iterable(final Class<?> clazz) {
        return iterable(clazz, true);
    }

    /**
     * for each構文で使用するために{@link ClassIterator}をラップした{@link Iterable}を返します。
     *
     * @param clazz

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

    /**

    private final boolean errors;

    private final T value;

    private final Iterable<? extends ModelProblem> problems;

    private Result(boolean errors, T model, Iterable<? extends ModelProblem> problems) {
        this.errors = errors;
        this.value = model;
        this.problems = problems;
    }

    public Iterable<? extends ModelProblem> getProblems() {
        return problems;
    }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyIterableOnAbsentKey() {
    Iterable<V> iterable =
        new Iterable<V>() {
          @Override
          public Iterator<V> iterator() {
            return ImmutableSet.<V>of().iterator();
          }
        };

    assertFalse(multimap().putAll(k3(), iterable));
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)

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(

    protected int index = 0;

    /**
     * for each構文で使用するために配列をラップした{@link Iterable}を返します。
     *
     * @param <T>
     *            列挙する要素の型
     * @param items
     *            イテレートする要素の並び。{@literal null}であってはいけません
     * @return 配列をラップした{@link Iterable}
     */
    public static <T> Iterable<T> iterable(final T... items) {
        assertArgumentNotNull("items", items);

    /**
     * for each構文で使用するために{@link SingleValueIterator}をラップした{@link Iterable}を返します。
     *
     * @param <E>
     *            要素の型
     * @param value
     *            反復子が返す唯一の値
     * @return {@link SingleValueIterator}をラップした{@link Iterable}
     */
    public static <E> Iterable<E> iterable(final E value) {
        return () -> new SingleValueIterator<>(value);
    }

    /**

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

    public Iterable<UseIterable<? extends Iterable<?>>>
        wildcardOfImplicitBoundedIsSubtypeOfWildcardOfExplicitlyBounded(
            List<UseIterable<?>> withImplicitBounds) {
      return isSubtype(withImplicitBounds);
    }

    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public Iterable<UseSerializableIterable<? extends Iterable<?>>>