* 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) {

 */
@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) {

    Iterable<String> set = newHashSet("a", "b");
    assertFalse(FluentIterable.from(set).contains("c"));
  }

  public void testContains_nonNullIterableYes() {
    Iterable<String> set = iterable("a", null, "b");
    assertTrue(FluentIterable.from(set).contains("b"));
  }

  public void testContains_nonNullIterableNo() {
    Iterable<String> iterable = iterable("a", "b");
    assertFalse(FluentIterable.from(iterable).contains("c"));

    Iterable<Character> result = Traverser.forGraph(graph).breadthFirst(charactersOf("ab"));

    assertEqualCharNodes(Iterables.limit(result, 2), "ab");
    assertThat(graph.requestedNodes).containsExactly('a', 'a', 'b', 'b');

    // Iterate again to see if calculation is done again
    assertEqualCharNodes(Iterables.limit(result, 2), "ab");
    assertThat(graph.requestedNodes).containsExactly('a', 'a', 'a', 'b', 'b', 'b');
  }

  }

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

   * already a {@code FluentIterable}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Collection#stream} if {@code iterable} is a {@link
   * Collection}; {@link Streams#stream(Iterable)} otherwise.
   */
  public static <E extends @Nullable Object> FluentIterable<E> from(Iterable<E> iterable) {
    return (iterable instanceof FluentIterable)
        ? (FluentIterable<E>) iterable

   * already a {@code FluentIterable}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Collection#stream} if {@code iterable} is a {@link
   * Collection}; {@link Streams#stream(Iterable)} otherwise.
   */
  public static <E extends @Nullable Object> FluentIterable<E> from(Iterable<E> iterable) {
    return (iterable instanceof FluentIterable)
        ? (FluentIterable<E>) iterable

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

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

   * @see #breadthFirst(Object)
   * @since 24.1
   */
  public final Iterable<N> breadthFirst(Iterable<? extends N> startNodes) {
    ImmutableSet<N> validated = validate(startNodes);
    return () -> newTraversal().breadthFirst(validated.iterator());
  }

  /**
   * Returns an unmodifiable {@code Iterable} over the nodes reachable from {@code startNode}, in

  // <Integer> needed to prevent warning :(
  private static final Iterable<Integer> iterable = Arrays.<Integer>asList();
  private static final Iterable<Integer> iterable1 = Arrays.asList(1);
  private static final Iterable<Integer> iterable12 = Arrays.asList(1, 2);
  private static final Iterable<Integer> iterable123 = Arrays.asList(1, 2, 3);
  private static final Iterable<@Nullable Integer> iterableNull = Arrays.asList((Integer) null);